Continuum

A persistent, multi-agent Model Context Protocol (MCP) server. Continuum gives AI coding agents — Claude Code, OpenCode, Codex, Gemini CLI — a shared, live view of a codebase and a memory that survives across agents and sessions.

Why

Standard MCP servers are spawned per-agent over stdio and forget everything when the agent exits. Continuum runs a single long-lived daemon per workspace: agents come and go, but the code graph and the inter-agent memory persist. One agent can hand off architectural intent to the next without re-deriving context.

Features

• Live code graph — tree-sitter parsing of Rust, Python, JavaScript, TypeScript, Go, PHP and Lua, kept in sync by a filesystem watcher.
• Hybrid code search — search_code fuses lexical BM25 ranking with semantic embeddings (a local, pure-Rust model2vec model) via reciprocal rank fusion. One compact row per hit — a token-efficient replacement for grep.
• Code navigation — file outlines, symbol definitions, caller lookup, and local dependency graphs, served from the in-memory code graph.
• Cross-agent memory — architectural decisions, an action-history log of agent intents, and an append-only scratchpad for handoffs.
• Daemon + thin adapter — one stateful daemon per workspace; each agent runs a lightweight stdio↔TCP proxy that auto-spawns the daemon on demand.

Architecture

  AI agent ──stdio(MCP)──> continuum-adapter ──TCP loopback──> continuum-daemon
                           (thin proxy)                       (graph + memory)

The daemon holds the AST knowledge graph in memory and persists agent memory to a local SQLite database. Adapters are stateless. See DESIGN.md for the full design.

Installation

Quick start — npx

No build step. Point any MCP-capable agent at:

{
  "command": "npx",
  "args": ["-y", "continuum-mcp"]
}

The package downloads the prebuilt binaries for your platform on first use — Linux x64, macOS x64/arm64, and Windows x64 are supported.

Prebuilt binaries

Download continuum-daemon and continuum-adapter for your platform from the latest release and keep them in the same directory.

From source

With a recent stable Rust toolchain, from a checkout of this repository:

sh scripts/install.sh          # Linux / macOS
powershell scripts/install.ps1 # Windows

The script builds and installs continuum-adapter and continuum-daemon into ~/.cargo/bin — no registry or account involved. By hand it is just:

cargo install --path crates/continuum-adapter
cargo install --path crates/continuum-daemon

Or run cargo build --release and use the binaries from target/release/.

Semantic search lazily downloads a ~30 MB embedding model from HuggingFace on the first search_code call; until then, and if loading fails, search uses lexical-only ranking and everything else works unchanged.

Windows without Visual Studio: with no MSVC linker, build against the llvm-mingw toolchain — rustup target add x86_64-pc-windows-gnullvm and add a .cargo/config.toml selecting that target.

Connecting an agent

Continuum speaks MCP over stdio. The simplest setup is the npx command above; to use a built binary instead, point the agent at continuum-adapter:

{
  "command": "/absolute/path/to/continuum-adapter",
  "args": []
}

Either way the adapter auto-spawns the per-workspace daemon and treats the current working directory as the workspace root (or pass --workspace <path>).

Per-agent configuration — Claude Code, Codex CLI, Gemini CLI, and OpenCode — is in docs/agent-setup.md.

Self-install (for AI agents)

If you are an AI coding agent with shell access, you can install Continuum and register it with your own MCP host. Follow the three steps.

1 — Install the binaries

With a Rust toolchain — one command, nothing to clone:

cargo install --git https://github.com/redstone-md/Continuum continuum-adapter continuum-daemon

This places continuum-adapter and continuum-daemon on your PATH (in ~/.cargo/bin). Without Rust, skip this step and use npx in step 2 — it fetches prebuilt binaries on first run.

2 — Register the MCP server with your host

Run the line for your host. If you skipped step 1, replace the command continuum-adapter with npx and arguments -y continuum-mcp.

• Claude Code — claude mcp add continuum -- continuum-adapter
• Codex CLI — codex mcp add continuum --transport stdio --command continuum-adapter
• Gemini CLI — add to ~/.gemini/settings.json:

  { "mcpServers": { "continuum": { "command": "continuum-adapter", "args": [] } } }
  

• OpenCode — add to opencode.json:

  { "mcp": { "continuum": { "type": "local", "command": ["continuum-adapter"], "enabled": true } } }
  

3 — Reload and verify

Restart the MCP host or reload its servers, then call the get_stats tool — a JSON reply means Continuum is live. The first search_code call downloads a ~30 MB embedding model; until it finishes, search is lexical-only and everything else works.

Continuum is a local developer tool: nothing to commit, no secrets, one daemon per workspace that idles out after 30 minutes.

Configuration

Continuum reads its settings from the environment, so they propagate through the agent → adapter → daemon spawn chain. All are optional.

MCP tools

Project layout

crates/
  continuum-core       shared domain types, DTOs, protocol
  continuum-transport  JSON-RPC + MCP wire types, IPC framing, stdio proxy
  continuum-graph      in-memory code knowledge graph
  continuum-indexer    tree-sitter parsing + filesystem watcher
  continuum-memory     SQLite-backed agent memory
  continuum-search     semantic search — embeddings + in-memory vector index
  continuum-daemon     the workspace daemon (binary)
  continuum-adapter    the thin MCP adapter (binary)

License

MIT.