eabz/tirith

Coordination server for parallel coding agents.
Claims, a task board, interface contracts, change notices, a decisions log,
path-scoped memory notes, and agent messages, over MCP.
Run five or ten coding agents on one repository and they edit the same
files, rename things others depend on, and build both sides of an interface
to different shapes. Tirith is a small daemon they all talk to: an agent
claims files before editing, gets the notices, contracts, decisions, and
notes for those files back with the claim, and publishes the shape of an
interface before either side implements it.
It works with anything that speaks MCP, over stdio or HTTP: Claude Code,
Cursor, Codex, LangGraph, CrewAI, or a plain script.
It also remembers. Agents leave notes scoped to repository paths, so what
one agent learned about a file reaches the next agent that claims it.
Tirith stores no conversation history and no embeddings.
> **Status: v1 shipped.** Every primitive, the CLI, persistence, and the
> dashboard are built and tested, against the definition in
> ADR-0013; tool schemas follow
> semantic versioning.
Install
macOS and Linux:
Windows (PowerShell):
With cargo (the package is tirith-mcp, the binary is tirith):
Already installed? tirith update replaces the binary in place with the
latest release. Prebuilt binaries for macOS, Linux, and Windows on x86_64
and ARM64 are on the releases page;
every option is in docs/1-about/05-installation.md.
Listed in the MCP Registry:
mcp-name: io.github.eabz/tirith.
Quick start
In the repository, run:
It registers tirith stdio in .mcp.json and puts a short block in
AGENTS.md (--file for another). The protocol itself, from the first
claim to who leads a swarm, arrives as the MCP server's instructions
every time a session connects; a repository that wants its own protocol
keeps it in .tirith/instructions.md (tirith init --instructions
writes the built-in one there to edit). Other clients register the same
command by hand: the shim starts the repository's daemon the first time a
session needs it, replaces a daemon of another version, and proxies to it
after that; nothing has to be started by hand.
| Client | Setup |
|---|---|
| Claude Code | claude mcp add tirith -- tirith stdio |
| Cursor | .cursor/mcp.json: { "mcpServers": { "tirith": { "command": "tirith", "args": ["stdio"] } } } |
| Codex | codex mcp add tirith -- tirith stdio |
| LangGraph, CrewAI, curl | connect over HTTP, see docs/2-examples/02-client-setup.md |
The daemon serves MCP at http://127.0.0.1:7477/mcp and a live dashboard
at http://127.0.0.1:7477/. State is written to .tirith/ in your
repository: contracts, notices, decisions, and memory notes are meant to
be committed; .tirith/runtime/ (claims, tasks, messages) is gitignored
by a .gitignore Tirith writes itself.
Every agent passes a stable agent name with each call. That is the only
convention it has to follow. To run several agents at once, paste the
protocol block from
docs/2-examples/03-swarm-playbook.md
into your project's agent instructions: it says which session leads,
when it spawns workers, what each worker is told, and which model each
runs on. The daemon serves the same rules in its instructions.
What it does
| Primitive | Tools | Purpose |
|---|---|---|
| **Claims** | claim, release, renew, claims_list | Lease files or directories before editing. Overlaps are refused with the owner, reason, and expiry, or waited out server-side with wait_secs. Leases expire if the agent dies, and the agent is told on its next call. |
| **Task board** | task_create, task_pull, task_update, task_list | Tasks with priority, owner, and dependencies. Agents pull the next unblocked task, skipping tasks another agent holds, and can wait server-side for one with wait_secs; a task whose owner goes silent returns to the board. |