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, Codex, Cursor, GitHub Copilot or Windsurf, 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 | An intelligence layer for the coding agents you already use: CLI, MCP server, VS Code extension and Pathrule Cloud |
| Who edits the knowledge | The agent, with built-in memory tools | Your team and its agents; learned findings stay advisory and team patterns need a person's approval |
| 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 | `pathrule setup` connects Claude Code, Codex, Cursor, GitHub Copilot and Windsurf; any MCP client can use the server |
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, Cursor, GitHub Copilot or Windsurf 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. In Pathrule, what an agent saves sits in a shared workspace where the team can see, edit and remove it, findings it records stay advisory and are never promoted to rules automatically, and team patterns reach agents only after a person verifies them. That is slower per item, and it 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 and verification
Official documentation verified 1 October 2026. Letta product version was not available in the reviewed docs and was not locally tested. Pathrule claims reviewed against the Pathrule v1 CLI on 19 October 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 connects to the coding agents you already run (Claude Code, Codex, Cursor, GitHub Copilot and Windsurf) and 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 save, and the team stays in control. The MCP tools let an agent write a memory, rule or skill, which then sits in the workspace where your team can see, edit or remove it. What Pathrule learns on its own is handled more carefully: findings stay advisory and are never turned into rules automatically, and team patterns reach agents only after a person verifies them. 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.