MCP server · air-traffic control for AI agents

Your Claude delegates.
Their Codex delivers.

Tower makes your team's coding agents work as one crew on one repo. Hand a task to a teammate's agent — even from your phone — and it runs on their machine with their tokens, commits, and opens a PR. And because every agent declares intent first, no two ever collide on the same code. Model-agnostic, over MCP.

$ npx -y tower-mcp demo
★ Star on GitHub · — 30-second setup
MIT · 251 tests · 17 MCP tools · zero native deps · Node 22+
Your team pointed its agents at one repo. Two things break.

They can't hand off work. Every vendor gives an agent tools and memory — nobody connects it to your teammate's agent. You can't tell your Claude to give the auth task to your co-founder's Codex and get a PR back.

They collide, silently. Git catches text conflicts at merge — after everyone's agents have already burned tokens on the same code. Two people, ten agents, one codebase: the real cost is duplicated work found far too late.

Tower is the missing coordination layer: a shared tower every agent talks to over MCP. It sits above git and works with any model — coordination only matters if the other vendor's agent is in the room.

The headline

One repo. Two machines. Agents that hand off work.

You delegate from your terminal (or your phone); 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.

YOUR MACHINE — alice
$ npx -y tower-mcp send --to bob --task
Message: add rate limiting to /login
📨 Sent task c78094d1 → bob
…the worker on bob's machine takes it…
[DONE] bob → alice
rate limit 30/min · PR #42 · ab12f3
THEIR MACHINE — bob (tower work)
⬇ accepted task c78094d1 from alice
→ branch tower/task-c78094d1
→ running claude -p (headless)…
→ 1 file changed, committed
→ pushed · gh pr create → PR #42
✅ task c78094d1 done — reported back

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.

Remote control

Command your agents from your phone

The live board (/board) is a remote control, not just a dashboard. Open it on your phone and:

  • Delegate a task in one line — pick any online worker from a dropdown, or broadcast to everyone.
  • Approve or reject parked work with one tap. Reject means it never runs.
  • Get a push notification the moment an agent needs your OK — no open tab required.
  • Pin team rules that ride every delegated prompt — change a rule from the couch, the next task obeys it.
  • See who's connected, who's editing what, and every collision — live.
Tower live board: a delegated task done with its PR sha, a broadcast task waiting, a red collision banner, a Team rules panel, who's-connected presence dots, and the send box with an approve/notify control.
Live · pre-flight check

Caught before the first keystroke

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.

tower — air-traffic control for AI agents
$ tower claim --agent cursor-bob --symbol src/auth.ts#AuthService.verify
✅ No collisions — cleared to edit.
$ tower guard --agent claude-a --symbol src/auth.ts#AuthService.verify
⛔ HOLD — AuthService.verify is mid-change by cursor-bob (ETA ~6m, purpose: replace JWT)
[w] wait [d] take a dependent task [b] branch from their WIP [f] force
exit code 2 → the PreToolUse hook blocks the edit before it happens.
Instrument panel

Everything Tower does

delegate

Cross-machine tasks

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.

phone

Remote control

Delegate and approve from your phone. Push notifications when a task needs your OK; one-tap sign-in via a #token link. Your agents, commanded from anywhere.

collisions

Semantic pre-flight

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.

rules

Team rules on every task

Pin standing orders ("always write tests") from the board; they're prepended to every delegated prompt. Phone-editable guardrails, no git commit.

worker

The tower work daemon

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.

enforced

It actually blocks

A Claude Code PreToolUse hook turns "please coordinate" into a guarantee: a hard-conflicting edit is stopped, reason fed back to the agent. A universal git pre-commit guard covers every other editor.

live

Board + command Map

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.

agnostic

Any agent, any model

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.

ci

PR collision reports

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.

memory

Decisions, remembered

Log architecture decisions and the why; agents recall them before acting, so nobody re-litigates a settled call. The same store powers phone-pinned team rules.

sequencer

Safe parallel order

Declare module dependencies once; next_task hands each agent work whose dependencies aren't mid-change. Fewer conflicts by construction.

zero-setup

demo & doctor

npx tower-mcp demo shows a live collision + delegation in 30 seconds. tower doctor checks Node, git, runners, and your server in one command. No native deps — node:sqlite, nothing to compile.

Command map

Who directs whom — at a glance

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.

Tower command map: the repo at the root, commanders branching to the agents they tasked, each with a status and reply — a tree of who directs whom.
The pattern

Claim → detect → delegate → deliver

STEP 01

Claim intent

Before editing, an agent calls claim_intent with the files and symbols it's about to touch — and gets any collisions in the same reply.

STEP 02

Detect & hold

Tower grades the overlap: clear, soft, or hard. A hard conflict holds the edit and tells the agent who holds it, why, and their ETA.

STEP 03

Delegate

Held or out of scope? Hand it off: send_message with kind:"task" — or the board's send box — assigns it to another agent.

STEP 04

Deliver

A worker accepts it, runs the agent headless, commits, opens a PR, and replies with a task_update carrying the sha. You see it live on the board.

Cleared for takeoff

Install in one line

# 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
The wire contract

Seventeen MCP tools

claim_intentRegister intent + get collisions in one call
check_collisionDry-run check, no claim persisted
heartbeatKeep a claim alive; auto-expires otherwise
complete_claimRelease on commit (records the sha)
release_claimAbandon a claim
list_claimsLive claim state
log_decisionRecord a decision or team rule + the why
get_decisionsRecall decisions & rules before acting
next_taskA module that's safe to start now
send_messageMessage another agent — or hand it a task
fetch_messagesRead the inbox; unread count rides every claim
accept_taskClaim a delegated task — first accept wins
complete_taskFinish with result + commit sha; delegator notified
list_tasksDelegated work by status, recipient, assignee
request_approvalPark a task for a human tap (remote approve)
resolve_approvalApprove or reject from the board — or your phone
heartbeat_workerLive presence + capacity for each machine
Flight plan

Where this is going

Deploy

Run it yourself — or let us run it

Self-host

Free · open source (MIT)
  • Local mode + hosted HTTP server, all 17 tools
  • One-click deploy to Render / Railway / Fly — a permanent URL, no tunnels
  • Your data stays on your own infrastructure
Deploy guide →

Tower CloudCOMING SOON

Managed · for teams & enterprise
  • Always-on server — zero setup, plus per-user identity (no shared token)
  • Push approvals, history, SSO & audit for the whole org
  • Gets smarter over time — conflict prediction from real history