Nerveplane is a local-first, MCP-compatible coordination plane for autonomous coding agents working in parallel across repos, branches, git worktrees, and microservice contracts. As teams run many coding agents at once, the bottleneck shifts from code generation to coordination — Nerveplane is that missing layer.
The problem
Run more than one coding agent at a time and they start stepping on each other: editing the same files, breaking shared API or database contracts, and redoing work another agent already finished — all with no shared awareness of what the others are doing. The more agents you add, the worse the collisions get, until coordination — not code generation — is the thing slowing you down.
Nerveplane gives a fleet of agents a common nervous system: passive sensing of what's changing, conflict- and contract-aware routing of who needs to know, and a shared, durable record of the decisions they make.
Architecture
Nerveplane runs as a single user-level daemon bound to localhost and shared by every project on the machine — cross-repo coordination simply isn't possible with a per-repo daemon. Clients (the CLI, Claude Code, Cursor, Codex, and friends) connect to that one daemon, which is organized into layered subsystems over an embedded store.
Clients → daemon → layered subsystems → embedded store.
Core components
- Integration — the MCP tool surface (stdio + HTTP), a REST API, server-sent events for streaming, and a hooks installer for editor/agent clients.
- Core — an Agent Registry, Presence (TTL-based liveness), Tasks, an append-only Event Log, a Decision ledger, and Artifacts.
- Sensing — a repo watcher (git polling + filesystem watch) plus a diff analyzer. The key design point: it is passive — it senses git changes without requiring agents to self-report.
- Service — a service-graph model plus contract parsers and diffing.
- Routing — recipient selection, severity scoring, deduplication and suppression, and conflict detection.
- Storage — an embedded SQL database in WAL mode via an ORM, with a path to a server database later.
Key data flows
- Registration. An agent registers its capabilities, branch, and current task, and receives a join packet describing the active fleet.
- Sync. Agents periodically pull routed updates — file and contract changes, conflicts, and direct messages relevant to them.
- Publish / decision. Agents announce contract, schema, or shared-type changes so affected agents are warned; durable choices are written to the decision ledger.
- Chat. Direct agent-to-agent messaging in threads, including a blocking "wait for reply" mode for real-time coordination.
- Passive sensing → routing. The watcher detects git and diff changes, and the routing layer decides who needs to know — with severity scoring and suppression to keep the noise down.
Tech stack
Nerveplane is built in TypeScript on the Bun runtime. It uses MCP as the agent transport (stdio + HTTP) alongside a lightweight HTTP framework for the REST API and SSE. A schema-validation library enforces typed boundaries, and an ORM sits over an embedded SQL database in WAL mode (with an optional server database later). Git integration is handled through a standard git library, and the whole thing ships as a single compiled binary.
Why it matters
Parallel agents, left to their own devices, collide — overwriting each other's files, breaking shared interfaces, and duplicating effort. By giving them passive sensing (no compliance required from the agents themselves), conflict- and contract-aware routing, and a shared decision record, Nerveplane keeps a fleet of agents aligned instead of colliding.
High-level technical overview. Implementation internals and product/strategy details are intentionally omitted.
Back to home