Open source2026Author

Continuum

Open-source memory for AI coding agents

Git, but for the context an AI agent is holding — so switching from one agent to another does not mean re-explaining the codebase, the bug, and everything already tried.

100%

Recall accuracy with context injection

Repository benchmark, against 17–20% without it.

~94%

Context compression

Repository benchmark.

5.5 s

Agent response time

Down from 17–21 s, per the repository benchmark.

Problem

Context dies at the session boundary. An agent that spent an hour learning a codebase, forming hypotheses and ruling things out starts the next session knowing none of it, and switching between Claude Code, Codex and Gemini means paying that cost again each time.

The information exists — it is just never written down in a form another agent can read.

What I built

A three-layer architecture that deliberately mirrors Git.

An append-only SQLite event log, checkpoints as commits, and a materialised `current.md` view
`continuum log / diff / blame / restore / branch / merge`
`note`, `ask`, and semantic `search` over recorded decisions and hypotheses
Decision versus hypothesis tracking, with claim provenance
Local-first — everything in `.continuum/`, nothing uploads by default
Ships as a Claude Code plugin and an MCP server

The browser extension

A capture surface rather than a separate product: it pulls context out of a GitHub PR, an AI chat, docs or an error page and routes it to an agent. Secrets for AWS, GitHub and OpenAI are redacted before anything leaves the page, with per-site permissions and private-tab blocking.

A react-flow task graph provides approval controls to pause, resume or reject individual agent steps. MV3 content scripts talk to a Python native-messaging host bridging to the local CLI.

Git, but for context

The three layers deliberately mirror Git, because the operations people already want from a memory are the ones Git defines.

An agent works, and records as it goes
Appended to a local SQLite event log.
A checkpoint is written
Like a commit, and it records the git commit it was written against.
current.md is materialised
A compact view of where the work actually is — 436 characters against 6,837 of raw history.
Two agents, two branches
`continuum branch codex-lane` gives each its own line of context, so they stop overwriting each other.
`continuum merge codex-lane` brings it back
`log` / `diff` / `blame` / `restore` to see what changed and undo it
A different agent picks the work up
Claude Code, Codex or Gemini, without re-explaining the codebase, the bug, or what was already ruled out.

Benchmark

Measured against real agent CLIs, 30 trials per cell, on a project whose recorded state is controlled. Intervals are 95% Wilson score. The middle row is the uncomfortable one and it stays in the table — an agent left to open `.continuum/` itself answers just as well, so recording the context is what produces the accuracy. Injecting it is what makes it fast.

Arm	Claude	Codex
Continuum injects the context	100% (98–100)	100% (98–100)
No injection; the agent reads .continuum/ itself	100% (98–100)	100% (98–100)
No project memory at all	17% (12–24)	20% (14–27)

Limitations and failure modes

Injection is not what produces the accuracy. An agent left to open `.continuum/` itself scores identically — 100% either way. What injection buys is speed, not correctness, and the benchmark table says so rather than hiding the row.
The reported numbers come from the project's own benchmark, not an independent evaluation.
30 trials per cell. The intervals are Wilson score and are stated with the numbers because a bare percentage at that sample size would overclaim.