You paid for both. Tower is the layer your agents check before they start — it catches the overlap before the tokens are spent, not at merge. Any vendor, any machine, over MCP.
npx -y tower-mcp demo
The expensive failure isn't the merge conflict. Git catches those, and you fix them in a minute. The one that costs real money is two agents doing the same work — different files, different names, both correct, both billed. Git merges them cleanly and says nothing.
By the time a file exists, the money is gone. An agent researches, reads the codebase, drafts a thousand lines of reasoning — then writes. Every check that fires at write time fires after the spend. Every check that compares file paths misses a duplicate that picked a different filename.
Agents make this worse than it is for humans. People coordinate ambiently — standup, a message, someone saying "I've got that." Agents are cheap to spawn, run in parallel by design, and start every session knowing nothing about what anyone else is doing.
Tower is the coordination layer: one server every agent talks to over MCP, on any machine, from any vendor. It sits above git, and it answers before the work starts.
You delegate from your terminal; their agent picks it up on their machine, with their account — no API keys shared, ever. It runs headless, commits on a branch, opens a PR, and reports back with the sha.
Run tower work on any machine to turn it into a task worker — --auto to run unattended, --approve remote to wait for a human tap, and it slows itself down when the account hits a rate limit. Full guide → docs/worker.md.
Before an agent edits, it claims the files and symbols it's about to touch. Tower compares that against every other active claim — semantically, from tree-sitter ASTs — so AuthService.verify collides with AuthService.verify even across different diff hunks. The second agent is held before it spends a token.
Your agent hands work to a teammate's agent — it runs on their machine and account, commits on a branch, opens a PR, and reports back the sha. First-accept-wins, so a broadcast runs exactly once.
An agent states its plan in one line before researching. Tower matches it against what everyone else is doing — by meaning, not filename — and says stand down if the work already exists.
Overlap detection from tree-sitter ASTs (TS/JS/Python), so the second agent is held before the keystroke — not found at merge, after both burned tokens.
Pin standing orders ("always write tests") from the board; they're prepended to every delegated prompt. Editable from the board, no git commit, no redeploy.
Turn any machine into a task worker — headless claude -p / codex exec / custom runner, branch-per-task, auto-PR, per-task confirm or fully unattended, with rate-limit-aware backoff and a --budget cap.
A Claude Code PreToolUse hook turns "please coordinate" into an actual block: a hard-conflicting Edit/Write exits 2 and never runs, with the reason fed back to the agent. It claims at file granularity (PreToolUse can't know your symbol yet). A universal git pre-commit guard covers every other editor.
Every hosted Tower ships /board: the delegation tree, who's editing what, collisions flashing red, and a Map tab showing who directs which agent — tap any node to command it.
It's an MCP server — Claude Code, Cursor, Codex, and anything that speaks MCP work today. Coordination is only useful if the other vendor's agent is in the room.
A zero-dependency GitHub Action comments when two open PRs touch overlapping lines, and shows which files an agent is editing right now. One workflow file, no server needed.
Log architecture decisions and the why; agents recall them before acting, so nobody re-litigates a settled call. The same store powers team-wide pinned rules.
Declare module dependencies once; next_task hands each agent work whose dependencies aren't mid-change. Fewer conflicts by construction.
npx tower-mcp demo boots a live board seeded with a real hard collision and a completed delegation — 30 seconds, nothing written to disk. tower doctor checks Node, git, runners, and your server in one command. No native deps — node:sqlite, nothing to compile.
The Map tab draws the command hierarchy: the repo at the root, every commander (including 📱 you), the agents they've tasked, and the status of each job. Tap any agent to command it directly.
Coordination is only worth it if it costs less than the collision. Tower runs the cheap check first and never asks the model to do work a parser can do.
propose_intent("rewrite the auth middleware") — one string, one round trip. Tower tokenizes it, strips stopwords, stems, and scores Sørensen–Dice against every active and recently-completed claim. Above the threshold, you get told who is already on it.
Catches the duplicate even when the two agents would have written different files — the case no path-based check can see. Runs entirely in-process: no model, no embedding API, no network call.
claim_intent with the files and symbols you're about to touch. Tower parses the source with tree-sitter (TS/JS/Python, WASM — nothing to compile) and compares real symbols, so AuthService.verify collides with AuthService.verify even when the two diffs are nowhere near each other in the file.
Same symbol → hard, and the claim is refused: no claim is written and you get recommendation: "stand_down". Same file, different symbols, or another branch → soft: you're told, you proceed. force: true overrides, and the override is recorded.
An MCP tool is advisory — the agent has to choose to call it. A Claude Code PreToolUse hook doesn't: a conflicting Edit exits 2 and never runs, with the reason fed back to the model. A git pre-commit guard does the same at commit time for any editor, any agent, including a human.
Every hook fails open but loud: an outage never blocks your editing, and it says so — silence always means verified-clear, never "didn't check".
Coordination is worthless if two people land in different buckets. Tower keys claims on the repository's root commit sha — the one value every clone, fork and mirror shares, and which survives renames and transfers.
So a fork coordinates with its upstream, and git@github.com:acme/app.git is the same place as https://github.com/Acme/App. Branch is deliberately not part of the key: agents mostly work on separate branches, and two of them rewriting one function still converge into a single merge.
acme/app → caaa8780f2853aec824905cc3278402fc26caa0a someone/app-fork → caaa8780f2853aec824905cc3278402fc26caa0a same project. same coordination space.
A hook that exits without printing adds nothing to the model's context. You only pay attention when something is actually about to collide.
Matching is a set intersection and a tree-sitter parse — microseconds of CPU, not an inference call. Coordination cost is a request, not a prompt.
Built-in node:sqlite and WASM tree-sitter. No native modules, so npx works first try on every OS.
Tower implements MCP rather than integrating vendors, so Claude Code, Cursor and Codex all work without a plugin. A coordination layer is only useful if the other vendor's agent is in the room.
# See it work first — a live collision + delegation, in 30 seconds: npx -y tower-mcp demo # In your repo — writes .mcp.json, agent rules, and (with --hooks) enforcement: npx -y tower-mcp setup # Joining a team server? npx -y tower-mcp setup --url https://tower-xxxx.onrender.com/mcp --token <secret> --hooks
setup merges the tower server into .mcp.json and adds the claim-first rule to CLAUDE.md. Reload your editor — done. Stuck? Run tower doctor. Details: enforcement.
# ~/.cursor/mcp.json { "mcpServers": { "tower": { "command": "npx", "args": ["-y", "tower-mcp", "serve"] } } }
Team server? Use "type": "http", "url": "…/mcp" with an Authorization header — same shape as Claude Code.
# ~/.codex/config.toml — Codex speaks stdio, so bridge with mcp-remote: [mcp_servers.tower] command = "npx" args = ["-y", "mcp-remote", "https://tower-xxxx.onrender.com/mcp", "--header", "Authorization: Bearer <secret>"]
Then add the claim-first rule to AGENTS.md — your Codex now sees (and can be handed tasks by) everyone else's agents.
git clone https://github.com/Rohanxmalik/Tower && cd Tower npm install && npm run build node packages/cli/dist/index.js serve