The Problem

Coding agents (Claude Code, Codex, Cline) each start with a blank slate. They re-explore the codebase, re-learn conventions, and can step on each other's work in parallel sessions. Continuum gives them a shared memory and a coordination protocol so lessons persist and agents don't clobber each other.

What This Does

Continuum is a local MCP server that provides vectorized knowledge storage, an agent registry, and a dispatch workflow. The API (apps/api/src/) is a NestJS app exposing MCP tools via Streamable HTTP. The web panel (apps/web/src/) is an Astro + React UI for humans to browse projects, agents, and knowledge.

The core workflow is a 4-phase dispatch protocol (Intake → Research → Verify → Handoff) seeded into each project's PLOT.md. Agents read the plot, become orchestrators, and dispatch fresh agents into isolated git worktrees. Knowledge is stored as 768-dim embeddings in SQLite via sqlite-vec, with semantic search instead of exact-match.

How It Is Wired

Execution starts at apps/api/src/main.ts (NestJS bootstrap). The routing hub is apps/api/src/app.module.ts — 7 modules import it, making it a high-blast-radius change point. The knowledge.service.ts is the most connected service: 4 modules import it, it calls 17 others, and it's the heaviest dependency in the graph.

Control flow for a typical request: HTTP → controller → service → repository → SQLite. The orchestrator-db.service.ts is the database choke point — 11 modules depend on it, so schema changes ripple widely. The service-errors.ts module is even more central: 13 modules import it, and it's where shared error types live. Keep it stable.

The web panel's cn utility (apps/web/src/lib/utils.ts) is called from 96 places — it's the shadcn class merger and the most-touched symbol in the frontend. The sidebar.tsx component is oversized at 1165 lines and defines 25 functions.

How To Use It

git clone https://github.com/moses-y/continuum
cd continuum
pnpm install
cp .env.example .env  # configure embedder and MCP settings
pnpm --filter api start  # runs the NestJS server
pnpm --filter web dev   # runs the Astro panel

The API Dockerfile (apps/api/Dockerfile) uses node:22.12-bookworm-slim — pin it by digest before production. The .env.example at the root defines required configuration; the embedder is optional but defaults to in-process.

Real-World Use

A team running parallel Claude Code sessions on one repo. Agent A reads the plot, researches the codebase, persists a dispatch record, and hands off a prompt for a fresh agent in a worktree. Agent B in another chat sees what's reserved via knowledge_search({q: "webhook retries"}) and avoids duplicating work. Both share learned lessons without re-explaining the codebase.

Code Health & Issues

Static analysis (not opinion) found 11 findings: 1 high, 10 medium.

  • High — Duplicated code blocks: 347 repeated 6-line blocks across 61 files, concentrated in the controllers (agent.controller.ts, knowledge.controller.ts, project.controller.ts). Extract shared helpers.
  • Medium — High branching density in agent.repository.ts and knowledge.repository.ts (51 branch points over 161 lines) — decompose decision-heavy logic.
  • Medium — Deep nesting (depth 6) in the web data tables (data-table.tsx, ProjectsTable.tsx) — flatten with guard clauses.
  • Medium — Oversized files: knowledge.service.spec.ts and sidebar.tsx at 1165 lines each.

SDLC gaps: no CI/CD pipeline, no LICENSE file (all rights reserved by default), no Dependabot/Renovate for the 4 dependency manifests, and the Dockerfile base image isn't pinned by digest.

The Bottom Line

Solid architecture for a real pain point — local-first, client-agnostic, and the MCP protocol is standard. The main risks are operational: no CI, no license, and duplicated logic that will drift. Worth using if you run multiple AI coding agents on the same codebase, but add a build gate and license before treating it as production-ready.