Stateful Agentic Engineering Copilots with Letta: Core Memory, Shared State, Semantic Retrieval, Custom Tools, Streaming, and Portable Agent Workflows

This is a tutorial, not a launch, but it shows a direction we think matters. It builds an engineering copilot on Letta where memory isn't a hidden side effect. It lives in labeled blocks the agent edits on its own, application code can read and write, and other agents can share.

The walkthrough stacks the pieces most teams will need: core memory for live state, archival vector memory for semantic lookups, a custom server-side tool for a deterministic calculation, streaming so you can watch steps, conversation history that lives on the server, and export to a portable .af file. That's close to a reference design for an assistant that persists across days.

Our read is that inspectable memory is the right answer to one of the creepier problems in AI assistants. When a system remembers things about you, the reasonable demand is to see what it remembered and fix it. Letta's model, as shown here, makes memory a set of named, size-limited blocks with descriptions, persona, the human, project state, lessons, that a developer can dump and read. That's auditable in a way most consumer assistants aren't.

Two details stand out. First, the tutorial writes CI status directly into the agent's project-state block from code, so the agent's context reflects reality rather than whatever it last heard in chat. Second, it attaches a read-only policies block shared by a copilot and a reviewer agent, alongside a writable shared scratchpad. Read-only rules that agents can see but not edit is a simple, useful pattern for governance.

We also like the choice to push arithmetic into a plain function. The release-risk estimate is ordinary code returning a score and verdict, and the agent calls it rather than guessing. Models are bad at being calculators; giving them calculators is the grown-up move.

The downside deserves airtime. Self-editing memory means the agent decides what's worth keeping, and the tutorial's example stores a person's name, employer, role and working preferences. That's helpful for a copilot and a privacy question at scale. Shared blocks spread whatever lands in them to every attached agent, including mistakes. And the export file carries memory, tools and history together, which makes it portable and also something to guard like a credential. If persistent agent memory becomes normal at work, teams will need retention rules and review for what agents remember about colleagues.

One more honest note: the code wraps nearly every call in fallbacks because the client API shifts across versions. That's a tell that this layer is still moving. We'd build on it, carefully, with pinned versions.

Letta is an agent framework built around persistent memory. In this walkthrough, core memory blocks stay in the model's context, archival memory is a searchable vector store the agent queries when needed, and agents can be reconnected from a fresh process using only their ID. The example uses a fictional Rust ingestion service and Kafka rebalance issue to show memory moving between turns.