Continuum: shared memory for AI coding agents across tool switches

Continuum addresses a friction point in multi-agent workflows: when you switch from one AI coding agent to another, the new agent knows nothing about your project's architecture, why design decisions were made, or where work left off. The tool solves this by creating a shared memory ledger inside your project at .aicontext/—a directory containing STATE.md (where you are right now), TASKS.md (in progress / backlog / done), DECISIONS.md (append-only record of why you chose what you chose), JOURNAL.md (per-session handoff log), manifest.json (metadata), and PROTOCOL.md (the full spec agents follow). Each agent is taught the same protocol: read it when you start, update it before you stop. Because the memory lives in the repo rather than in Claude's ~/.claude/projects/ or any other agent's silo, context survives the switch. On Day 1 you might use Codex to build an auth flow; before the usage limit hits, Codex updates STATE.md and appends a JOURNAL.md entry saying "Built auth flow, left off at wiring the token refresh." On Day 2 you open the project in Claude Code, Claude reads .aicontext/STATE.md, announces "Caught up: building the auth flow, next is token refresh," and continues—no re-explaining needed. The same works if you switch to Antigravity later.

To keep the ledger reliable even when sessions crash or hit limits, Continuum wires native session-start, pre-compaction, and stop hooks into every agent that supports them. Claude Code and Codex are verified to work; Gemini CLI, Cursor, and Windsurf rely on the same hook mechanisms and a git-based fallback. A session-start hook injects STATE.md (plus recent journal and drift notes) into context every session, so catch-up happens automatically. A pre-compaction hook fires right as the context window is about to compact, prompting the handoff then while detail still exists. A stop hook reminds you once per session if you changed files but never saved, or if you committed code but never recorded the decision. If a session ends with no handoff at all—because of a crash or usage limit—the next session detects the gap and runs `continuum import --from auto`, which rebuilds a draft handoff from the last agent's transcript (native parsers for Claude, Codex, Gemini) plus a universal git-based view comparing the saved git commit to HEAD. Drift detection flags commits and uncommitted changes since the ledger was last saved, so the agent verifies against git instead of relying on a stale snapshot.

Installation is straightforward. A one-line command downloads bootstrap.ps1 (Windows) or bootstrap.sh (macOS/Linux) and runs a global installer that wires the Continuum protocol into each agent's global configuration—Claude Code gets the protocol in ~/.claude/CLAUDE.md plus a skill at ~/.claude/skills/continuum/, Codex gets it in ~/.codex/AGENTS.md, and so on. After the global install, any project with a .aicontext/ folder follows the protocol automatically. Alternatively, you can clone the repo and run per-project installers to set up .aicontext/ and drop adapter files directly into a single repository. The helper scripts are plain PowerShell and bash with no runtime or external dependencies; they handle timestamps, manifest updates, git checks, and transcript parsing, while the agent still writes the actual prose handoff. The ledger itself is plain Markdown and JSON, readable and editable by hand, with no service or lock-in. .aicontext/ is gitignored by default so it stays machine-local, but the protocol files are committed so they travel with the repo. The design supports both a fast, living snapshot (STATE.md) and append-only history (JOURNAL.md, DECISIONS.md) for trustworthy long-term context.

The core problem Continuum solves is the siloing of AI agent context. Each coding agent—Claude, Codex, Antigravity—maintains its own private history, and when a developer switches tools (often forced by usage limits), that context is lost. The developer must then spend time and tokens re-explaining the project, and worse, may unknowingly redo work that was already done in a previous session. Continuum's answer is elegant: a small, machine-local memory ledger (.aicontext/) committed to the project repository, not to any single agent's configuration. The ledger is gitignored by default so it stays local, but the adapter files (CLAUDE.md, AGENTS.md, .windsurfrules) are committed, allowing the protocol to travel with the repo and each clone to initialize its own local ledger. The tool teaches every agent a simple protocol: read STATE.md when you start, update it before you stop. Native hooks on Claude Code and Codex guarantee the catch-up and handoff even if the agent forgets; a pre-compaction hook fires right as context compaction begins, ensuring the handoff while detail is fresh. For agents without native hooks, a git-based reconstruction floor uses the last agent's transcript plus git log/diff to rebuild what changed. Because the ledger lives in plain Markdown and JSON with no runtime or service, it is both human-readable and toolchain-agnostic.

No comments yet. Be the first to share your thoughts!