---
title: "Letta Code Builds a Coding Agent That Actually Remembers Your Codebase"
subtitle: "Letta Code ties every coding session to a long-lived agent with git-tracked memory, skills, and cross-model portability, ranking first among open source model-agnostic harnesses on Terminal-Bench."
url: "https://alphasignal.ai/news/letta-code-builds-a-coding-agent-that-actually-remembers-your-codebase"
author: "AlphaSignal Newsroom"
author_url: "https://alphasignal.ai/editorial-team"
company: "AlphaSignal"
company_url: "https://alphasignal.ai/company/alphasignal"
published: "2026-05-09T21:04:08.000Z"
updated: "2026-08-22T03:47:59.954Z"
type: "Repo"
topics:
  - "Development"
  - "Agents"
subtopics:
  - "Code Agents"
  - "Code Agents"
  - "Memory"
  - "Agent Frameworks"
upvotes: 10
source_url: "https://github.com/letta-ai/letta-code"
comments: 0
truncated: true
---

# Letta Code Builds a Coding Agent That Actually Remembers Your Codebase

> Letta Code ties every coding session to a long-lived agent with git-tracked memory, skills, and cross-model portability, ranking first among open source model-agnostic harnesses on Terminal-Bench.

Most coding agents treat every conversation like a first date. You open a new session, re-explain your project conventions, paste in the same architectural context, and watch the model rediscover things it figured out yesterday. [Letta Code](https://github.com/letta-ai/letta-code), the new coding harness from the team behind MemGPT, bets that the fix is a persistent agent that actually remembers rather than a bigger context window.

Each Letta Code session is tied to a persisted agent that learns across runs, rather than starting fresh. The project is open source under Apache 2.0, written in TypeScript, and installs as a single npm package.

## Memory as architecture, not plugin

The core idea is that agents accumulate valuable signal during real work. They receive user preferences and feedback, review significant chunks of code, and observe the outcomes of running scripts or commands. Most harnesses throw that signal away at session end. Letta agents retain it through agentic context engineering, long-term memory, and skill learning.

Letta Code exposes a few mechanisms to make that learning tangible:

* **MemFS**: all context, including memory blocks, is tracked via git, and you can point it at your own GitHub repository with `/memory-repository set`. That gives you diffs, history, and rollback for your agent's brain.
* **Memory blocks**: the agent programmatically rewrites parts of its own system prompt as it learns about your codebase.
* **Skills**: reusable `.md` capability files loaded from global (`~/.letta`), project-scoped (`.agents/skills`), or agent-scoped locations in MemFS.
* **Sleeptime**: periodic "dreaming" during idle periods, with `/doctor` to audit memory quality and `/palace` to visualize what the agent knows.
* **Message search**: vector, full-text, and hybrid search across every conversation, including those belonging to other agents.

Running `/init` on first use kicks off deep research on your local codebase, forming memories and rewriting the system prompt through memory blocks as it goes. From there,

_Preview only. Full text requires an AlphaSignal Pro account._

## Sources

- [letta-ai/letta-code on GitHub](https://github.com/letta-ai/letta-code)
- [Letta Code: A Memory-First Coding Agent](https://www.letta.com/blog/letta-code/)
- [Letta Code Review 2026: Memory-First Coding Agent](https://vibecodinghub.org/tools/letta-code)
- [Letta Documentation](https://docs.letta.com/letta-code)
- [Letta Unveils Memory-First AI Coding Agent](https://nishadil.com/news/lettas-breakthrough-a-memory-first-ai-agent-reimagines-coding/37f5f05bbce43ba6e86024cce82c0df2)