Continuum

Shared memory + orchestration for your coding agents.

One MCP server. Tell any client to read the plot — it becomes the orchestrator.

Dispatches fresh agents in isolated worktrees, shares lessons across every Claude Code / Codex / Cline chat on the project.

Quick Start • Memory & Vectors • Workflow • MCP Tools • Wire It In • Configuration

---

Your agents forget. Continuum remembers.

Point any MCP client at Continuum and tell it to read the plot. The client becomes an orchestrator — it researches the codebase, verifies the plan, persists a dispatch record, and hands you a ready-to-paste prompt for a fresh agent in an isolated git worktree. Every other Claude Code / Codex / Cline chat on the project sees what's reserved, shares what's been learned, and never re-explains the codebase. One local server: vector knowledge base, orchestration protocol, agent registry — shared across every MCP-speaking app on your machine.

flowchart TD

CC["Claude Code"] CX["Codex"] CL["Cline"] YOU["YOU"]

subgraph CONTINUUM["CONTINUUM ORCHESTRATOR"] direction LR PLOT["PLOT.md protocol"] KNOW["KNOWLEDGE (vectorized)"] AGENTS["AGENTS registry"] PANEL["WEB PANEL (humans)"] end

DB[("SQLite + sqlite-vec one file, your disk")]

CC -- MCP --> CONTINUUM CX -- MCP --> CONTINUUM CL -- MCP --> CONTINUUM YOU -- HTTP --> CONTINUUM CONTINUUM --> DB

No SaaS. No telemetry. No keys to manage. Boots in seconds. Survives reboots. Scales with you.

---

What you get

---

Why Continuum exists

---

Quick start

🐳 The easy path — one Docker command

docker compose -f docker-compose.dev.yml up

That's it. The whole stack comes up with hot reload, a SQLite browser, and a single shared volume — no Node, no pnpm, no native-build dance on your host machine.

What you get:

The API embeds in-process by default (Snowflake/snowflake-arctic-embed-m-v1.5 via Transformers.js, 768-dim, ONNX q8). No external service required for semantic search. Override via EMBEDDER_URL to point at any HTTP-based embedder (Ollama, TEI, OpenAI-compatible). Turn the bundled TEI container on with the embedder profile:

HF_TOKEN=hf_xxx docker compose -f docker-compose.dev.yml --profile embedder up

Bind mounts keep the source tree on your host — edits are instant. Named volumes hold node_modules so installs survive restarts. Database lives at ./.local-data/dev-orchestrator.db on your host, gitignored, safe to wipe.

Stop everything:

docker compose -f docker-compose.dev.yml down            # keep data

docker compose -f docker-compose.dev.yml down -v # nuke volumes too

🛠️ Or run on bare metal

pnpm install

pnpm dev

Dev SQLite at ./.local-data/orchestrator.db. Gitignored. Wipe to reset — next boot recreates and migrates forward.

Requires Node >=22.12.0 and pnpm 10.33+. The compose path skips both.

---

Memory & vectors

This is the headline. Continuum's knowledge layer is what makes your agents stop being amnesiac.

How a lesson becomes memory

agent finishes a dispatch

│ ▼ knowledge_create({ project, agentSlug, slug, content: "When wiring rate-limit guards in Nest, register them in app.module.ts AFTER the auth guard, not before. Order matters.", kind: 'situational' }) │ ▼ content → embedder (in-process by default, or Ollama / TEI / OpenAI-compatible) │ Snowflake Arctic Embed v1.5 → 768-dim vector ▼ SQLite row + sqlite-vec index entry │ freshness profile = (URL, model, dim) ▼ forever queryable by ANY future agent on this project

How recall works

Phase 1 of every dispatch (the orchestrator does this automatically):

knowledge_list({ project, kind: 'fundamental' })

└─ returns metadata for every binding lesson — slug + agentSlug + timestamps. knowledge_get({ project, slug }) // for each fundamental slug └─ full body — base branch, worktree convention, no-AI-attribution, etc.

knowledge_search({ project, q: "rate limit middleware nest interceptor order" }) └─ vector similarity over your prose └─ returns top-K ranked metadata (no content) └─ does NOT need exact wording — natural language works knowledge_get({ project, slug }) // for each relevant hit └─ pulls the full lesson body

Search and list return metadata only — slug + kind + agentSlug + timestamps. Call knowledge_get for the body of any lesson worth reading. Keeps top-K context cheap; the orchestrator triages first, fetches second.

The result: the agent that's about to plan your task already knows what your last five agents learned the hard way. No prompt engineering. No "here's our convention" copy-paste.

Two kinds of knowledge

The freshness profile

Vectors are pinned to a (EMBEDDER_URL, EMBEDDER_MODEL, EMBEDDER_DIM) triple. Change any one and Continuum marks stale vectors for rebuild on next boot. You stay in control of which embedder owns your memory — local Ollama, self-hosted TEI, or anything OpenAI-shaped.

Pluggable embedders

The embedder is required and runs in-process by default (Snowflake/snowflake-arctic-embed-m-v1.5, 768-dim, ONNX q8). The model weights are bundled in the API image — no extra container, no extra config, semantic search works out of the box.

Override via EMBEDDER_URL to delegate embedding to an HTTP service:

# Option A — Ollama (simplest, fully local)

ollama pull

EMBEDDER_URL=http://127.0.0.1:11434/api/embed

EMBEDDER_MODEL= EMBEDDER_DIM=768

Option B — Hugging Face TEI (production-grade, batched)

HF_TOKEN=hf_xxx docker compose -f docker-compose.dev.yml --profile embedder up embedder

EMBEDDER_URL=http://127.0.0.1:8080/v1/embeddings

EMBEDDER_MODEL= EMBEDDER_DIM=768

Option C — anything OpenAI-compatible /v1/embeddings

Works out of the box. Match the dim.

Built on sqlite-vec

The vector index lives in the same SQLite file as your projects, agents, and plot. One file. One backup. One restore. No separate vector DB to provision, no Pinecone bill, no Chroma daemon to babysit. WAL mode keeps reads concurrent with writes; foreign keys keep your registry consistent; busy_timeout = 5000 keeps things calm under contention.

---

Wire it into your AI client

Claude Code

// ~/.claude.json  →  mcpServers

{ "mcpServers": { "continuum": { "transport": "streamable-http", "url": "http://127.0.0.1:7776/mcp" } } }

Restart Claude Code. Tools appear under mcp__continuum__*.

Codex

# ~/.codex/config.toml

[mcp_servers.continuum] transport = "streamable-http" url = "http://127.0.0.1:7776/mcp"

Anything else (Cline, Cursor, custom)

Point any MCP-compatible client at http://127.0.0.1:7776/mcp. Streamable HTTP, stateful sessions (UUID-keyed). Server name continuum.

---

Your first project

Inside any wired client:

Create a Continuum project for /absolute/path/to/my/repo,

then read the PLOT.md and act as orchestrator for the following task: .

What happens:

1. Client calls project_create({project: "/absolute/path/..."})
2. Server seeds PLOT.md (the orchestration protocol) and an empty knowledge base
3. Client calls plot({project}), reads the protocol, enters orchestrator mode
4. Client follows the 4-phase workflow — researches, verifies, persists a dispatch record, hands you a ready-to-p