What Letta (formerly MemGPT) Does

Letta grew out of the MemGPT research work, which introduced a memorable idea: give a language model an operating-system-style memory hierarchy. In that framing the model has a limited main context, analogous to physical memory, and a larger external context, analogous to disk, and the model itself issues function calls to move information between the two. This lets an agent edit its own memory, keeping salient facts in context while paging older material out to a persistent store and retrieving it when relevant. Under the Letta name, that idea became an open-source framework and platform for building stateful agents whose memory outlives any single conversation.

Letta's design centers memory as a first-class concern, which is genuinely useful and not the default in many agent frameworks. Agents are persistent: a server holds agent state and memory in a backing datastore, so an agent can be stopped and resumed with its accumulated context intact. Memory is organized into blocks that the agent can read and revise. A development environment and a REST API let builders create agents, inspect their memory, and drive them, and Letta has published a format for exporting and importing an agent so that its configuration and memory can move between installations. For teams whose central problem is that their agents forget everything between sessions, this is a thoughtfully built answer.

This article is not a critique of that framework. It concerns one specific structural question Letta does not set out to answer: whether the agent is an object a second, unrelated system can validate and govern purely from the object's own contents, without trusting or querying the runtime that produced it.

The Architectural Axis

The axis here is where agent identity and governability live. In Letta, an agent's durable existence is anchored to the server and its datastore: the persisted state is what makes the agent stateful, and the export format is the mechanism by which that state is moved from one Letta installation to another. This is a coherent and effective model for persistence. It is oriented, naturally, around the Letta runtime and its representation of an agent.

The Agent Schema addresses a different property on the same broad theme of durable, portable agents. Its concern is not only that memory persists, but that the agent is a self-describing object whose admissibility, governing constraints, permitted evolution, and provenance can be determined by any receiving node from the object alone. The distinction is between state that a specific runtime can save and reload, and an object that carries enough embedded structure for an arbitrary, independently operated system to accept, govern, and reason about it without shared session state, a shared database, or the originating runtime. This is a difference in architectural aim, not a defect in Letta; a framework built to persist and manage memory is not thereby built to make the agent a transport-independent, structurally validatable unit of governance.

How the Disclosed Approach Differs

The Agent Schema standardizes the agent as an object rather than as runtime-held state. As disclosed in United States Patent Application 19/452,651, a semantic agent object carries up to six canonical fields embedded directly within it: an intent field naming the agent's objective; a context block situating it within trust and environmental scope; a memory field recording trace outcomes such as prior validations, mutation events, and delegation actions; a policy reference field identifying the governing policies that constrain permissible behavior; a mutation descriptor field defining the transformation pathways the agent is authorized to take; and a lineage field referencing the agent's semantic ancestors.

The defining property is that admissibility is determined from the object's own contents. A node receiving a semantic agent object performs structural validation, checking that the canonical fields present are coherent and permitted to coexist, based only on information embedded in the object, and prior to any execution. Memory here is not merely a store that a runtime reloads; it is one canonical field whose trace outcomes are validated for coherence against the object's lineage and mutation scope as part of that structural check. An object need not carry all six fields: the schema supports partial agents, and a partial object with as few as two coherent canonical fields can be validated and, where a field is missing, resolved through deterministic, policy-bound scaffolding that records every inferred or defaulted value as a trace outcome in the memory field. Evolution is governed rather than open-ended: a mutation is authorized only when the mutation descriptor, the policy reference, and the context permit it, and the resulting derived object references its predecessor through the lineage field, extending an auditable ancestry graph rather than overwriting prior state. Because all of this is embedded, a serialized agent object can be transferred, paused, and rehydrated across stateless or federated systems while preserving its identity, governance, and provenance, without reliance on a central runtime or synchronized session state.

The contrast with a runtime-and-export model is specific. In that model, moving an agent means exporting its state and importing it into another instance of the same platform, and questions such as what rules the agent operated under, or whether the agent now running is the one that passed review, are answered by trusting that platform and its records. Under the schema, those questions are properties a consumer checks from the object itself: the policy reference declares the governing constraints, the mutation descriptor bounds permitted change, and the lineage field lets a verifier confirm that each derivation step was authorized, all without access to the originating system.

Where They Fit Together

The two occupy different layers, and composition is the sensible posture. Letta is a capable runtime for building and persisting stateful, memory-managing agents; the Agent Schema is an object model for making an agent portable, structurally validatable, and governable independently of any runtime. An agent can run inside Letta and also be represented as a semantic agent object. The agent's objective maps onto the intent field and its operating scope onto the context block; the memory Letta manages so carefully can be reflected as governed trace outcomes in the memory field; the rules the agent must satisfy live in its policy reference field; a proposed change is declared in its mutation descriptor; and its derivation history accrues in its lineage field.

Run inside Letta, such an agent keeps the operational benefits of Letta's memory management while gaining a portable, structurally validatable identity that a party who never had access to the Letta server can check, and that survives a move to a different execution environment. Letta's own attention to agent export shows that portability is a recognized need; the schema addresses a stricter form of it, portability with self-contained validation and governance, at the object layer.

Boundary Conditions

Honesty about scope matters. The Agent Schema is a structural model: it defines what makes an agent object admissible, how partial objects are resolved, how mutation is bounded, and how lineage is preserved. It is not a memory-management algorithm and does not prescribe how an agent decides what to remember, how to rank retrieved context, or how to summarize; those are exactly the problems Letta and the MemGPT line of work address, and the schema does not displace them. Structural validation confirms coherence and admissibility from the object's contents; it does not judge semantic correctness, model quality, or whether an agent's remembered facts are true. Determinations are made without interpreting semantic meaning or execution outcomes, so a structurally valid object can still encode a poor objective. The described mechanisms are drawn from a patent application and represent a disclosed design; they are not a claim about any deployed product's benchmarked behavior, and no performance numbers are asserted for the disclosed approach. Every statement here about what the invention does traces to the specification of the cited filing.

Disclosure Scope

The semantic agent object and its six canonical fields, intent, context, memory, policy reference, mutation descriptor, and lineage, together with structural validation from the object's own contents, partial-agent support with deterministic scaffolding, governed mutation, and traceable semantic lineage, are disclosed in the Agent Schema filing, United States Patent Application 19/452,651. This article compares that disclosed object model with Letta (formerly MemGPT) as publicly described. Statements about Letta, MemGPT, memory blocks, persisted agent state, the development environment, the REST API, and agent export describe that project as external market context used for comparison only; they are not claims of the filing, and nothing here asserts any defect in Letta or any relationship with or endorsement by its makers.