Everything between your agents, handled.
Eight mechanisms, all shipped, all local. The card grid is the tour; the detail below each is the machinery — with the real command or store it runs on.
Everything between your agents, handled.
Knowledge graph
Your repo, indexed into a queryable graph. Agents navigate instead of grepping.
Session handoff
One markdown file carries the whole session: objective, plan, checklist, cost estimate.
Worktree isolation
Every agent gets its own git worktree. No clobbered branches, ever.
Live edit signals
See who's editing what, in real time. Overlaps warn before they conflict.
Evidence-anchored memory
Shared facts pinned to commits and content hashes. Stale facts get withheld — agents can't hallucinate from them.
Installable skills
Ten agent playbooks, installed into each agent's own config. bug-fix won't touch a line until an independent skeptic corroborates the root cause at 95% — and you approve.
Model routing
Every task scored by severity, then routed into a tier — no LLM call, deterministic, and it tells you why. The bottom tier runs a local model, so it costs nothing at all.
Cost arbitrage
Agents read the graph's repo map instead of raw files.
Each one, in detail.
One agent, one branch, one working directory.
Every task gets its own branch (baton/my-task) and an isolated git worktree at .baton/wt/my-task. Agents never share a checkout, so there is no checkout juggling and no in-session clobbering — and because worktrees are standard git, removing Baton leaves your repo untouched.
Who is editing what, answered before it becomes a conflict.
Editor hooks record every file touch into a local SQLite store; the daemon reconciles those signals against what git actually says is dirty, then streams them over server-sent events. Two agents drifting toward one file flashes an overlap warning — and agents can ask check_files over MCP before touching a path.
A session becomes one markdown file another agent can pick up.
baton pass distills a session into HANDOFF.md: objective, plan, remaining checklist, and an estimated cost to finish. baton take prints the execution prompt for the receiving agent — and if commits landed after the brief was written, a stale-brief warning tells the receiver to trust git over the brief.
Shared facts that are withheld the moment they might be wrong.
Facts are pinned to a commit and to content hashes of the files they describe. When an anchored file changes, the fact is withheld instead of served — an agent can be told nothing, but it cannot be told something stale. Facts saved without file anchors age out on commit distance rather than living forever.
Agents navigate a map instead of re-reading the repo.
The repo — or a whole multi-repo hub — is indexed into a queryable graph plus a ~2k-token CODEBASE.md map. Agents answer 'where does X live' with a targeted query instead of grepping raw files, which is the difference between ~824 tokens and ~248k for the same question.
Each task scored and routed into a tier — no LLM call deciding.
Deterministic severity scoring sends every task into a tier: heavy, standard, light, or local. It is instant, free, and it tells you why. The local tier runs on Ollama through aider or opencode, so routine work costs exactly nothing.
The same playbooks, in every agent's own config format.
Ten skills — bug-fix discipline, handoff etiquette, routing awareness — install into .claude/skills, .cursor/rules, and the rest from one source. The bug-fix skill will not let an agent touch a line until an independent skeptic corroborates the root cause at 95% confidence and you approve the plan.
Zero dependencies, loopback only, nothing leaves your machine.
The daemon is raw node:http bound to 127.0.0.1, with Origin and Host-header guards on every request and writes disabled unless you pass --write. There is no hosted service and no telemetry — the dashboard on localhost:7077 is the whole surface.
Watch the relay live.
A realtime dashboard on localhost:7077. Activity, conflicts, terminals, memory, the graph.