Letta gives agents persistent identities and editable memory

Letta builds agents that retain an identity, configuration and memory across separate conversations. That makes it relevant to work where the same assistant should carry project knowledge forward rather than restart from a blank prompt. The central decision is what deserves to become durable memory. Remembering more information is useful only when the agent can keep it accurate, appropriately scoped and distinguishable from the facts of the current task.

01 / ProductAn agent identity can span many conversations

The stateful-agent guide describes an agent as a persistent identity with memory, model configuration, tools and message history. Separate conversations can share that agent’s memory. Separate agents are the route when independent identities or memories are required. That distinction matters for anyone tempted to create a fresh agent for every message thread.

The quickstart offers desktop, CLI and web routes, with different execution environments and connection choices. Signed-in agents can be backed up to the cloud, while local-only agents require their own backup arrangements. A buyer should decide where the work runs and where the agent state lives, rather than assuming those are always the same machine.

Letta grew out of MemGPT research on agents with self-editing memory. Its explanation of the relationship reserves MemGPT for the original agent design pattern and uses Letta for the framework. Readers following older MemGPT tutorials should check the current setup instructions before relying on their package names or interfaces.

02 / AudiencePeople and teams with continuing project context

Letta is relevant when an assistant repeatedly works on the same project and should retain durable preferences or operating knowledge. Examples include a coding companion that learns a repository’s conventions and an internal assistant that maintains a project reference collection. The user needs a way to inspect and correct what carries forward.

It is less compelling for isolated tasks where previous information should not influence the next answer. A one-off document transformation may need a clean input and output rather than an evolving identity. Continuing memory adds value when it reduces repeated explanation without making outdated assumptions harder to notice.

Anthropic is relevant as a broader assistant and model-platform comparison, while LangChain provides tools for building custom agent applications and stateful workflows. Compare whether the desired outcome is a continuing assistant experience or a service your team will build and operate around an agent runtime.

03 / WorkflowA proposed assistant for maintaining one software project

Consider a proposed Letta assistant that helps maintain a single software repository over time. This is an illustrative workflow, not a product test by Sequenced. Its useful memory might include the project’s module map, approved verification commands and explanations of recurring design choices. Each coding request should still begin from the current repository state.

Create a project-specific agent and keep unrelated clients or repositories outside that identity. A shared memory can make future work faster, but it can also carry a private detail or a misleading convention into the wrong task. Decide the boundary based on who may access the project and what information is intended to persist.

Review tool permissions before the first real change. The permissions guide says the interactive CLI starts in unrestricted mode by default. Standard mode asks before tools requiring approval, while strict mode asks before every tool call. Select the intended mode explicitly and test its behavior instead of assuming that a fresh installation prompts for all consequential actions.

Initialize a concise reference for the repository. Include the relevant directories, how to run the existing checks and where release instructions live. Link to authoritative project files rather than copying large policies into memory. A remembered summary should help the agent find the current contract; it should not silently replace that contract when the repository changes.

The MemFS guide describes a Git-backed memory repository projected onto the computer where the agent runs. Files under system are loaded into the system prompt, while other files can be read when needed. Put only enduring, high-value context in the always-loaded area and keep detailed reference material in discoverable files.

For each request, have the assistant inspect the current branch and affected code before relying on remembered implementation details. Suppose memory says the application uses a particular validation library. The current dependency file and source code should determine the implementation, and a mismatch should lead to a corrected memory entry rather than an edit based on the old assumption.

After a useful change, review what the assistant proposes to remember. A durable lesson might describe a stable module boundary or the reason for an unusual integration. A transient failing test, temporary deployment URL or one-time user preference may not belong in lasting project context. Saving every observation makes later retrieval less trustworthy.

Use the memory history to inspect and correct mistaken lessons. MemFS distinguishes local edits from committed and pushed memory, so confirm that intended updates reach the appropriate repository before expecting another computer to see them. Treat memory changes as reviewable project information rather than an invisible side effect of conversation.

Evaluate continuity with paired tasks. First teach a verified convention, then start another conversation with the same agent and see whether the convention is applied appropriately. Also change an authoritative project file and test whether the agent notices the revision. A useful memory system should preserve context while allowing current evidence to override stale details.

Finish the pilot by checking the separation between conversation, memory and filesystem output. Deleting a local generated file should not be confused with deleting a remembered fact or a cloud-backed conversation. Define how a project is retired, how access is removed and what remains available to the owner afterward.

04 / PricingPersonal use and automated API work are different plans

The pricing documentation, consulted on 23 September 2026, distinguishes hands-on personal use authenticated through the app or CLI from automated developer use with API keys. A personal quota should not be treated as the allowance for a backend application.

For the project assistant, estimate usage from actual working sessions rather than agent count alone. A single agent that repeatedly reads a large codebase and runs long tasks may consume more resources than several lightly used agents. Inspect the account’s current quota and overage settings before assuming that a monthly plan covers a full working day.

Bringing your own model credentials changes who bills inference; it does not make the model free. Likewise, running tools on your own machine changes the execution arrangement. Document the chosen route for the pilot so future cost comparisons do not accidentally mix a local setup with a fully hosted automated application.

05 / DistinctionsMemory becomes something a maintainer can inspect

Letta’s file-oriented memory is useful because durable context can be organized and reviewed in a familiar form. A maintainer can distinguish a project fact from a preference and see when an entry changed. The value is the ability to correct and govern memory, not simply the promise that the assistant remembers previous conversations.

The distinction between an agent and its conversations is also practical. Several task threads can share a project identity without becoming one unwieldy chat. Conversely, separate agents can keep projects independent. The appropriate boundary should follow the work and access model rather than the number of open conversation tabs.

MemFS does not provide a semantic or vector index by default according to its documentation; optional search tooling is a separate configuration. A team should therefore test how the assistant finds a specific saved fact as the reference collection grows. Clear file names and a small useful hierarchy may matter as much as the volume of stored material.

06 / QuestionsQuestions about stale memories and authority

Which source wins when memory conflicts with current evidence? Write that rule into the project’s operating instructions and test it with a deliberate contradiction. An assistant should be able to say that its stored note is outdated and point to the file or decision that supersedes it.

Who can edit shared memory, and how are mistaken updates corrected? Review the history after a trial task and make sure the owner can remove a bad lesson. Memory that is easy to create but difficult to inspect can turn an isolated misunderstanding into a recurring error across future conversations.

What tool authority is appropriate on each computer? The same agent identity may run in environments with different files and credentials. Review permissions and available tools for each environment rather than assuming that a remembered project rule supplies an execution boundary. The intended setup needs its own practical verification.

07 / DecisionEvaluate the quality of continuity

Letta deserves consideration when the same assistant should accumulate useful project knowledge over repeated work. Start with a bounded identity, inspectable memory and explicit permissions. Judge the pilot by whether it applies verified context, notices changes and accepts corrections, rather than by how many facts it can retain.