Stateful AI Employees, Not Amnesiac Bots: Why We Build on Letta Code, the Best Agent OS

This is the post for anyone who wants an AI employee rather than a clever bot they have to re-train every morning. It goes deep on the technology, because the difference between the two is entirely technical. If you would rather just see it working in your business, talk to us →

Almost everyone shopping for "an AI employee" today is actually being sold an amnesiac. The demo is dazzling. The agent reads your code or your docs, answers brilliantly, handles a real task end to end. Then the session closes, and everything it just learned about you evaporates. The next morning you start over: re-explaining your business, your conventions, the strange thing about your process, the reason that one workflow is the way it is. It is like hiring a genius with anterograde amnesia. Spectacular for an hour, incapable of building on yesterday, and never actually an employee.

That amnesia is not a flaw in one product. It is the default condition of large language models. They are, in the technical sense, stateless: each request is processed in isolation, and nothing carries forward except whatever you manually stuff back into the prompt ^[1]. This is as true of the best coding tools on the market, Anthropic's Claude Code and OpenAI's Codex, as it is of a raw API call. They are extraordinary within a session and forgetful between them. The agent that helped you ship a feature last Tuesday remembers nothing about it on Wednesday.

A real employee is the opposite. They get better at your business every week. They remember the last conversation, the last decision, the thing that went wrong in March and how you fixed it. To build that, you cannot just buy a better model. You need a different foundation, one where the agent has durable state, an identity, and a memory that lives somewhere it cannot be wiped between sessions. That foundation has a name now: an agent operating system. And the best one we have found, after putting it into production, is Letta Code.

Letta Code is most often described as a stateful coding agent, and that is true, but it undersells it. It is really an agent OS: a place where long-lived agents live, remember, learn, and improve, with software engineering as the first and most demanding job they do. The word doing all the work is stateful. A Letta Code agent does not begin every session at zero. It carries forward what it has learned, across sessions, across machines, and even across model generations. That is exactly the property that turns a bot into something you can credibly call an employee.

This is a thorough, sourced look at why we build on it. We will cover what Letta is and the research it stands on, what makes Letta Code an agent OS rather than another CLI, how it stacks up head to head against Claude Code, why people are buying dedicated mini PCs just to keep agents running around the clock, and how we turn all of it into stateful AI employees the businesses we work with can actually rely on.

Click to expand

First, what Letta actually is

To understand Letta Code, you have to understand Letta, and to understand Letta, you have to go back to a research project.

In 2023, researchers at UC Berkeley published a paper called MemGPT: Towards LLMs as Operating Systems ^[2]. The core idea was elegant and slightly subversive. A language model has a fixed context window, a finite amount of text it can "see" at once. That window is, functionally, the model's working memory, and it is small. The MemGPT insight was to treat that limitation the way an operating system treats limited physical RAM: build a memory hierarchy, and let the system page information in and out of the context window the way an OS pages data between RAM and disk ^[2][3].

In that analogy, the context window is RAM, fast, precious, and tiny. External storage, a database, a set of files, an archive of past conversations, is the disk: vast, slower to reach, but durable. The agent itself is given tools to move information between the two: to decide what deserves to stay resident in working memory and what can be written out to long-term storage and recalled later. The model, in other words, manages its own memory through function calls, just as a program asks the OS for more memory ^[2].

MemGPT grew into Letta, now a company and an open-source framework, and the operating-system framing remains the spine of the whole system ^[4]. The headline difference from a normal LLM call is this: a Letta agent is a persistent entity with state that lives in a database, not a transient prompt that evaporates when the request returns. You do not "send a message to a model." You message an agent that exists continuously, that remembers your last conversation, and that has been quietly editing its own memory in between ^[5].

Click to expand

Memory blocks: the abstraction that makes it work

The piece of Letta worth understanding in detail, because it is the piece that does the most work, is the memory block ^[6].

A memory block is a structured, labeled chunk of text that lives inside the agent's context window and is always visible to the model. It is not retrieved on demand like a search result; it sits permanently in the system prompt, so the agent never has to go looking for it ^[6][7]. Each block has a label (say, `human` or `persona` or `codebase_conventions`), a description that tells the agent what the block is for, a value (the actual content), and a size limit so it cannot grow without bound ^[6].

The crucial property is that blocks are read-write by the agent itself. Letta gives the agent memory tools, with names like `core_memory_append` and `core_memory_replace`, so it can update its own persistent state during a conversation ^[6][7]. When you tell the agent "we always use snake_case for database columns," it does not just nod and forget. It can write that fact into a memory block, and from then on the rule is part of who the agent is, surfaced in every future session automatically.

Two more details matter for what comes later. First, blocks can be marked read-only, so some knowledge is fixed and some is mutable. Second, blocks can be shared across multiple agents, giving several agents a single synchronized piece of memory ^[6][8]. That single capability is what lets a fleet of agents cooperate as a coherent system rather than a pile of disconnected bots, and it matters enormously once you move past a single coding agent toward an organization of them.

Around the memory blocks sits a fuller hierarchy: recall memory (searchable conversation history) and archival memory (a long-term vector and text store the agent can query) ^[2][3]. Letta even added a filesystem, MemFS, that lets agents organize and reference documents, PDFs, transcripts, and docs the way a person organizes files in folders ^[9]. In Letta's own benchmarking, a simple filesystem approach scored 74 percent on the LoCoMo long-conversation memory benchmark, beating several specialized memory libraries, which is a tidy demonstration that the OS analogy is not just a metaphor but a genuinely good engineering strategy ^[9].

The reframing that took us a while to internalize: with Letta, memory is not a feature bolted onto a chatbot. Memory is the agent. The model is just the engine that reads and rewrites it.

So what is Letta Code, and why call it an agent OS?

Letta Code, launched in December 2025, is what you get when you take that stateful-agent foundation and aim it squarely at the hardest, most unforgiving job an agent can do: software engineering ^[10]. On the surface it looks like the coding agents you already know, a terminal harness, and now a desktop app, that can read your repo, run commands, edit files, and work through tasks. Underneath, it is something more general: long-lived agents that persist across sessions and improve with use, rather than the independent, throwaway sessions every other coding assistant gives you ^[10][11].

That is why we keep calling it an agent OS rather than a coding tool. An operating system is not the application you run, it is the durable layer underneath that manages memory, storage, identity, and processes so the applications on top can be stateful and reliable. Letta Code plays exactly that role for agents. Coding is simply the first and most demanding application running on it, and if an agent OS can survive a real engineering workload, the same foundation can run a support agent, a research analyst, or a back-office employee without changing the architecture. Choosing your agent OS is the decision that outlasts every model you will ever plug into it, which is why we treat it as the most important choice in the whole stack.

The practical workflow looks like this. When you start, you run an `/init` command, and the agent does deep research on your codebase, reading through it, forming memories, and rewriting its own system prompt, via memory blocks, as it learns what your project is and how it is built ^[10]. From then on it keeps learning automatically, but you can also explicitly tell it to reflect and consolidate what it has learned with a `/remember` command. And because every session is tied to a persistent agent, you can use `/search` to query the full history of your past conversations, vector, full-text, or hybrid search over everything you have ever worked on together ^[10][11].

But the feature that genuinely changed how we work is skill learning ^[12].

Skills: agents that write their own playbook

A huge fraction of real engineering work is repetition with variation. Generating a database migration when a schema changes. Setting up a new dashboard. Following the team's specific, slightly idiosyncratic process for an API change. You coach the agent through one of these gnarly tasks once, and normally that coaching is wasted the moment the session ends.

Letta Code lets the agent learn a skill from that experience ^[12]. After you have walked it through a complex task, you can have it distill what it learned into a reusable skill that it, or another agent, can reference next time a similar task comes up. Letta's own team reports skills their agents have contributed with human help, generating DB migrations on schema changes, creating PostHog dashboards via the CLI, codifying best practices for API changes ^[10]. Their research shows skill learning measurably improving performance on future similar tasks rather than the usual degradation you see as context fills up ^[12][13].

The detail we love, as engineers, is that skills are just markdown files ^[10]. That means they live in git like any other code: versioned, reviewed in pull requests, diffed, rolled back. It also means a skill one agent learns can be picked up by another agent, even a different coding tool that understands the same skill format. The agent's accumulated competence becomes a portable, inspectable asset instead of a black box.

Letta took this even further with Context Repositories, a rebuild of Letta Code's memory on top of git-based versioning, so that an agent's entire memory is a versioned repository of markdown files ^[14]. And with sleep-time compute, sometimes called "dreaming," background subagents review and reorganize the agent's memory during downtime, running in isolated git worktrees so they can tidy up long-term memory without blocking the agent that is actively working ^[15][16]. The agent literally gets better while it is idle.

Click to expand

The part that wins on the benchmarks: it is model-agnostic, and it still leads

Here is the fact that moves Letta Code from "interesting" to "best in class."

Letta Code is the number one model-agnostic open-source harness on Terminal-Bench, the standard benchmark for terminal-using coding agents ^[10][17]. "Model-agnostic" means the harness is not welded to any single model provider. You can run it on Claude, on a GPT model, on Gemini, or on an open-weight model you host yourself, and the harness stays the same. "Number one" means it does this without paying a performance tax: Letta Code's results are comparable to the provider-specific harnesses, Claude Code, Gemini CLI, and Codex CLI, running on those providers' own models, and it significantly outperforms the previous leading model-agnostic harness ^[10]. Even with memory set aside entirely, a Letta Code agent works about as well with a frontier model as the model maker's own bespoke tool does.

That single property has a profound consequence. We wrote recently about the great LLM repricing, how the cost of "good enough to run a business on" is collapsing, and how the smart move is no longer picking one model but routing each task to the cheapest model that can do it well. A model-agnostic harness is what makes that strategy possible. You can move a workload from an expensive frontier model to a cheaper open-weight one without rebuilding the agent, because the agent, its memory, its skills, its identity, lives in Letta, not in the model. The engine is swappable. The agent is not.

Letta's own research articulates this well: they describe continual learning "in token space," and make the point that an agent which can carry its memories across model generations will outlast any single foundation model ^[18]. Models change, seemingly monthly. The work an agent has accumulated should not be thrown away every time a new one ships. Letta lets the memory persist while the models churn underneath it.

Click to expand

Letta Code vs Claude Code: the honest, head-to-head comparison

Because Claude Code is the tool most people mean when they say "AI coding agent," it deserves a real, researched comparison rather than a strawman. So let us be fair to it first. Claude Code is an excellent, deeply polished agent. It is a proprietary harness tuned to extract the most from Anthropic's frontier models, with strong reasoning, a large context window, a mature ecosystem of subagents and MCP integrations, and an enormous, fast-moving user base. For a developer committed to Anthropic whose work fits inside a session, it is genuinely one of the best tools in the world. We use it. We like it. This is not a takedown.

It is also worth being precise, because Claude Code is not the memoryless toy a lazy comparison would make it. Anthropic has been building real memory features into it. There is the familiar `CLAUDE.md` file, a project-level set of rules and preferences the agent reads at the start of a session. More recently it gained Auto Memory, where the agent generates and maintains its own notes, and a background "Dreaming" consolidation pass that prunes and refines those notes between sessions so they do not rot into noise. Those are good features, and they are clearly moving in the same direction Letta has been pointing the whole time.

But look closely at where that memory lives and who owns it, and the structural divide is still stark. Claude Code's memory is fundamentally a layer of files and self-written notes, scoped to a project and a tool, designed to rebuild useful context for the current model in the current session. Letta Code's memory is a first-class, server-side entity: structured memory blocks the agent edits in real time, a tiered hierarchy of recall and archival storage, a filesystem, and git-backed Context Repositories, all living in a database that belongs to the agent, not to a single project folder or a single provider's app ^[4][6][14]. One is excellent context management for a session. The other is a persistent being with state. That is not a difference of polish. It is a difference of kind.

It comes down to two questions that decide whether you are buying a tool or an employee: does the agent truly remember and own its state, and is it locked to one vendor? On both, Letta Code is built differently.

Read down the memory rows, because that is the real divide. Even with Auto Memory and Dreaming, Claude Code's knowledge is anchored to a project folder and the Anthropic model behind it; move tools or providers and the accumulated understanding does not come with you. Letta Code treats memory as the default state of the agent and stores it server-side, so it learns once and keeps it, reachable from any machine and any app the agent serves ^[10][18]. Add the provider row and the strategic picture is complete: with Claude Code you are betting your agent's entire future on Anthropic, with Codex you are betting on OpenAI, and with Letta Code you are betting on no one, free to follow the best price and performance wherever it goes while the agent itself stays put.

Our take, after running all of them, is simple and unhedged. For a quick, single-session task on a model you are already committed to, Claude Code is superb and we will keep using it. But for an agent you intend to keep, one that should know your business better next quarter than it does today and should not be orphaned the day you switch models, Letta Code is the one we reach for, and the one we build employees on.

Where Intueo comes in: we build the employee

Here is the part that matters if you came for an AI employee rather than a benchmark. Letta Code is the agent OS, the foundation. What we build on top of it is the actual product: the role, the personality, the skills, the integrations, the security boundaries. Turning a powerful framework into someone your team trusts to answer the phone, remember every conversation, and follow through. That is what we ship.

We chose Letta's stateful agent architecture because it is the best foundation available. What we do with it is the hard part: we design the agent's role and personality, wire it into your phones, inboxes, CRM, and documents, curate the skills it learns, set the security and data-residency boundaries, and operate it so it is auditable, reliable, and quietly getting better every week. The distance between an impressive framework and a dependable member of your team is real engineering, and that is where we operate. The result is a stateful AI employee that behaves like someone who has worked at your company for a year and remembers all of it.

How we turn the agent OS into an employee

The benchmarks and the architecture are the theory. What matters to a business is what happens when you run this properly, at production grade, instead of as a personal experiment on a laptop in the corner. The distance between "an impressive agent that runs on my machine" and "a stateful employee my company depends on" is made of unglamorous, essential engineering, and that distance is exactly where we operate. Here is what that work actually involves.

One agent, many machines

A stateful agent is not tied to a device. We run Letta Code across both Windows and macOS, and it behaves as one agent with one memory, reachable from either. What it learns on a Mac, it knows on a Windows box, because the state lives with the agent, not the hardware ^[5][19]. Letta's remote-environment support extends this further: you can reach an agent working on one machine from your phone ^[19]. Cross-platform stops being a compatibility headache and becomes a non-issue, because there is only one agent and the operating systems are simply doors into the same room.

Grounded in the real work

A coding agent is far more useful when it is aware of the work it supports, not just the code. Letta's filesystem and memory tooling are built to ingest and organize exactly the material a business runs on, documents, transcripts, specifications, ongoing context, so the agent reasons from a grounded picture of how the software is actually used rather than from the codebase in isolation ^[9]. This connection is what closes the perennial gap between what a team thinks its product does and what its users actually experience.

Secure, isolated, and under your control

This is the part that turns an impressive demo into something a serious organization can adopt. Because the Letta Code harness is open source and model-agnostic, it can be deployed on infrastructure you control rather than handed to a third party ^[10][14]. Every deployment is isolated per-client, with data and memory kept inside that boundary, and routed to whichever model meets the customer's cost, performance, and data-residency requirements, including self-hosted open-weight models where regulation demands it. Git-backed memory and markdown skills mean every change to an agent's knowledge is inspectable, versioned, and reviewable ^[14], which is exactly the auditability that compliance-bound teams need and that off-the-shelf, session-based tools do not provide.

The tell: people are buying mini PCs just to keep agents alive

There is a behavior spreading through engineering teams right now that tells you everything about where this is headed. People are buying dedicated mini PCs, most often a Mac mini, and standing them up in the corner of the office for one purpose: to keep an AI agent running around the clock. They run it headless, reach it remotely over something like Tailscale, register a local model runtime as a background service, and spec it with 32GB of memory so the agent never falls over mid-task. It is, in everything but name, a personal agent appliance, a little always-on box whose entire job is to host an agent that does not stop when the laptop lid closes.

Think about what that impulse is actually saying. These are smart people voting with their hardware budget for a future where an agent is not an app you open, but a persistent worker that is always there, always reachable, and always on the clock. They are trying to build an employee out of a tool that was designed to be a session. And they keep hitting the same wall, because a box that is always on does not fix the deeper problem: the agent on top of it still forgets everything between sessions, still has no secure boundary, still cannot be shared safely across a team, and still has to be re-briefed every morning through a folder of hand-maintained notes.

The mini PC is the right instinct pointed at the wrong layer. The hardware was never the missing piece. The missing piece is the agent OS, and that is exactly what Letta Code provides: the persistent, server-side memory and identity that an always-on machine is supposed to be serving in the first place. Pair the right foundation with the right hosting and the appliance finally makes sense, because now there is genuinely an employee living inside it. That is the gap we close. The teams buying Mac minis to run their own agent are right about where this is going; we get them there on a stateful foundation, hosted securely, integrated with the systems the business already uses, and operated so it stays up and keeps improving, without the duct tape and the 2 a.m. reboots.

The same model productionizes Letta Code for engineering teams and extends, without changing the architecture, to the broader stateful employees the foundation supports: the digital coworkers, the customer-facing agents, the receptionist that remembers your repeat callers ^[10]. For a business that wants a true agent of its own rather than a chatbot wearing its logo, this is the machinery underneath the promise, a stateful employee on a memory architecture designed, from a research paper up, to learn from experience ^[2][20].

A brief note on our stack, since people ask: we build on the same best-in-class agent OS we recommend, and we are proud of that choice rather than apologetic about it. Standing on a foundation a world-class research team has proven and open-sourced is not a shortcut, it is good engineering, and it means every hour of our effort goes into the part our customers actually live with: deploying it exceptionally well, securing it, integrating it, and operating it as a dependable employee. The foundation is theirs to advance. The employee is ours to build, and that is the value we add.

Where this goes next

The direction could not be clearer, and the whole field is now moving toward it: agents that remember, agents that learn from the work they actually do, and a memory layer durable enough to outlive whichever model is fashionable this quarter. Even the provider tools are racing in this direction, which is the strongest possible signal that the stateless era is ending. The companies that win the next few years will not be the ones with the cleverest one-off bot. They will be the ones whose AI employees compounded, getting measurably better every month while everyone else re-briefed a stranger every morning. Letta Code is the most complete agent OS we have found for building exactly that, and turning it into a secure, reliable, deeply integrated employee is the work we are most excited about.

If you want a stateful AI employee working inside your business, on infrastructure you can trust, remembering your context and improving every week, come talk to us. And if your team is already running Claude Code or Codex, or quietly nursing a Mac mini in the corner that runs an agent around the clock, you are closer than you think, and this is exactly the conversation to have.

Intueo Labs is an AI automation and agent engineering practice. We help teams deploy and operate stateful AI agents in production. Talk to us →