soul.py vs memU: Two Philosophies of Agent Memory

The AI agent memory space is heating up. Two projects with different philosophies are gaining traction: soul.py (ours) and memU. Both solve the “agents forget everything” problem, but they approach it very differently.

This isn’t a hit piece. Both tools are open source, both solve real problems, and depending on what you’re building, either could be the right choice. Here’s an honest comparison.

The Core Philosophy Difference

soul.py asks: “Who is this agent, and how do we keep it the same person across sessions?”

memU asks: “What does this agent know, and how can it anticipate what the user needs?”

These sound similar but lead to very different architectures.

soul.py: Identity-First Memory

soul.py separates identity (who the agent is) from memory (what it has experienced):

your-project/
├── SOUL.md      # Personality, values, constraints, tone
└── MEMORY.md    # Chronological log of interactions

That’s it. Two markdown files. No database, no infrastructure, no configuration.

The insight: Human identity survives memory loss. Patients with severe amnesia still have personalities, preferences, and values. soul.py mirrors this by treating identity as a separate, protected structure.

What this enables:

• Open MEMORY.md in any text editor and see exactly what your agent remembers
• Git diff your agent’s memories over time
• Edit or delete memories by hand — it’s just text
• Version control your agent’s entire identity
• Works offline, no API keys required (with local models)

The tradeoff: soul.py doesn’t anticipate user needs. It remembers what happened; it doesn’t predict what will happen.

memU: Proactive Intelligence

memU treats memory like a file system with automatic organization:

memory/
├── preferences/
│   ├── communication_style.md
│   └── topic_interests.md
├── relationships/
│   └── contacts/
├── knowledge/
│   └── domain_expertise/
└── context/
    └── pending_tasks/

It uses PostgreSQL + pgvector for storage and supports sophisticated retrieval modes (RAG for speed, LLM-based for deep reasoning).

The insight: Proactive agents need to anticipate, not just remember. memU continuously extracts patterns, predicts user intent, and surfaces relevant context before you ask.

What this enables:

• Auto-categorization of memories without manual tagging
• Intent prediction (“you usually buy tech dips above 3%…”)
• Continuous background monitoring
• Enterprise-scale multi-user deployments
• Cloud API for production systems

The tradeoff: Requires infrastructure (PostgreSQL, API keys). Memories aren’t human-readable without going through the API. More complex to set up and debug.

Side-by-Side Comparison

Aspect	soul.py	memU
Storage	2 markdown files	PostgreSQL + pgvector
Infrastructure	None	Database required
Setup time	2 minutes	30+ minutes
Human-readable	Yes — open in Notepad	No — API access only
Version control	Native (just git)	Database migrations
Proactive features	No	Yes (core focus)
Retrieval	RAG + RLM hybrid	RAG + LLM-based
Multi-user	Manual separation	Built-in
Cloud option	Self-hosted only	Cloud API available
Target user	Developers, tinkerers	Enterprise, production

When to Choose soul.py

Choose soul.py if you want:

• Simplicity — pip install soul-agent and you’re running in minutes
• Transparency — see exactly what your agent knows by reading a text file
• Portability — move your agent’s memory by copying two files
• Identity persistence — the agent should feel like “the same person” across sessions
• Local-first — works with Ollama, no cloud required
• Hackability — edit memories by hand, experiment freely

soul.py is ideal for personal assistants, research projects, and developers who want to understand exactly what’s happening.

When to Choose memU

Choose memU if you need:

• Proactive intelligence — the agent should anticipate needs, not just remember
• Enterprise scale — multi-user, 24/7 operation, production reliability
• Structured knowledge — auto-categorization, hierarchical organization
• Cloud deployment — hosted API with managed infrastructure
• Complex workflows — continuous monitoring, background processing

memU is ideal for production systems, enterprise deployments, and use cases where proactive behavior matters more than simplicity.

Can You Use Both?

Actually, yes. They solve different problems:

• soul.py for identity (who the agent is, how it behaves)
• memU for knowledge (what the agent knows, what it anticipates)

You could use soul.py’s SOUL.md to define personality and constraints, while using memU’s infrastructure for large-scale knowledge management. The identity layer is lightweight; the knowledge layer can be as sophisticated as you need.

The Bigger Picture

The agent memory space is still young. We’re all figuring out the right abstractions.

soul.py bets that simplicity and transparency matter — that developers want to see what’s happening, edit it by hand, and version control their agents like code.

memU bets that proactive intelligence matters — that the real value is in anticipation, not just recall.

Both bets might be right for different use cases. The best tool depends on what you’re building.

---

Try soul.py:

• GitHub: github.com/menonpg/soul.py
• PyPI: pip install soul-agent
• Demo: soul.themenonlab.com

Try memU:

• GitHub: github.com/NevaMind-AI/memU
• Cloud: memu.so

Both are open source. Both are worth exploring.