Comparison
Pathrule vs Letta
Letta is a platform for building stateful agents: you define memory blocks that live in the agent's context window, and the agent edits them itself with built-in tools. Pathrule does not give you an agent. It feeds the ones you already run, Claude Code and Codex and the rest, with the knowledge that governs the path they are working in.
What Letta gets right, and one thing worth crediting properly
Letta descends from the MemGPT paper and it took the right lesson from it: an agent should manage its own memory. Memory blocks are structured sections of the context window that persist across interactions and are always visible without retrieval, and the agent reads and updates them with built-in tools. Archival memory sits behind that as a semantically searchable store queried on demand, so the agent moves knowledge between what it always sees and what it can look up.
The credit worth giving explicitly: core memory does not wait to be queried. It is in the context window by construction. So the argument this site makes against memory APIs, that they answer only when asked, does not apply to Letta's core blocks, and pretending otherwise would be dishonest.
The harness is open source, with a managed cloud or a self-hosted server, and Letta names coding agents among the things you can build with it.
Side by side
| Letta | Pathrule | |
|---|---|---|
| What you get | A platform for building a stateful agent | Pathrule Studio, the workbench that runs the agents you already use, and the knowledge layer under it |
| Who edits the knowledge | The agent, with built-in memory tools | Your team, with the agent proposing and you approving |
| Always in context | Memory blocks, by construction | The path-scoped slice, injected before the first tool call |
| How it scales past the window | Archival memory, queried on demand | Path scoping: only the slice for this directory is sent |
| Organised by | Blocks such as human, persona, task | Repository paths |
| Constraints that can block a change | Not its purpose | Rules carry scope, priority and an enforcement level |
| How agents connect | You build the agent instead | Studio runs six agents natively; Pathrule CLI connects external clients |
Letta claims are from its own docs and blog, read August 2026. If a row is wrong, tell us and we will fix it.
Where the two genuinely diverge
Build an agent, or equip the ones you have. Letta is the right tool if the product you are shipping IS an agent and you want its memory to be first-class. Pathrule assumes you already use Claude Code, Codex, Grok, Kimi, Antigravity or OpenCode in Studio and would rather not rebuild the agent.
Blocks are curated. Paths are given.. Memory blocks are sections somebody designs: a human block, a persona block, a task block. That is a good model for an assistant with a role. For code, the structure already exists: the repository. Pathrule keys on it, so what an agent receives while editing
/services/billingneeds no block design.Self-editing versus reviewed knowledge. An agent editing its own memory is powerful and it is also unreviewed: nothing stops it writing something wrong and reading it back as fact. Pathrule's writes go through you. The agent proposes what is worth keeping and it is saved once you approve, which is slower per item and is the point when the knowledge is shared with a team.
Which to pick
Pick Letta when you are building an agent product and its memory is part of the thing you ship, or when you want the agent itself to own what it remembers.
Pick Pathrule when the agents are already chosen and the problem is that they act inside your repository without knowing what your team decided. If both are true, they do not collide: Letta inside your product, Pathrule under the coding agents that build it.
Sources
Official product documentation reviewed August 20, 2026.
- Letta: platform overview
Official positioning for the stateful agent platform and open source harness.
- Letta: attaching and detaching memory blocks
Official behavior for persistent blocks that stay visible in agent context.
Frequently asked questions
Is Pathrule an agent framework like Letta?
No, and that is the main difference. Letta is a platform for building a stateful agent. Pathrule Studio runs Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode, then gives them shared, path-scoped knowledge that survives switching between them.
Letta's memory blocks are always in context. Is that not better than injection?
For a fixed set of blocks, it is a clean design and we credit it. The tradeoff is scale: everything always in context competes for the window, so it works best when the knowledge is a few curated blocks. Pathrule assumes hundreds of memories and rules across a repository and sends only the slice that governs the current path.
Can an agent write knowledge in Pathrule the way a Letta agent edits its own memory?
It can propose, and you approve. The MCP tools let an agent write a memory, rule or skill, and Pathrule is designed for it to suggest one when something is worth keeping, but the write lands after your confirmation. For team-shared knowledge that review step is the feature, not friction.
Both are open source. Same thing?
Different pieces. Letta open sources its agent harness, with cloud or self-hosted deployment. Pathrule open sources its context core: the path-scoped engine, the MCP surface and an embedded SQLite backend that runs the loop with no account and no network.