Ironway Tower · traffic control for AI coding agents
Many agents, one repository, no collisions.
Tower keeps track of which agent is working on what, speaks up before two of them collide, and snapshots their work so a crash costs nothing. Git stays the permanent record — Tower looks after the messy hours before a change gets there.
join → claim → checkpoint → integrate → git
Traffic control for agents that share a repository
What it does, in plain terms. When several AI coding agents work on the same codebase at once, they get in each other's way: two of them rewrite the same function, one never learns that another changed something it depended on, and half-finished work vanishes when a run dies partway through. Tower is the traffic control for that. It keeps track of who is working on what, speaks up when two workers are about to collide, records what happens as it happens, takes automatic safety snapshots so a crash doesn't cost you the work, and helps put the finished pieces back together. Git stays the permanent record — Tower looks after the messy hours before a change gets there.
If you run more than one AI coding agent in the same repository — two Claude Code sessions, a few Codex workers, a mix — these are the things that go wrong, and what Tower does about each.
-
1
Two agents edit the same thing.
Each agent tells Tower which functions and files it is working in. When a second agent reaches for the same one, both are told before either has written a line, instead of finding out at merge time.
-
2
An agent works from a stale picture.
One agent changes an interface another depends on, and the second keeps building against the old one. Tower gives every agent a running digest of what its peers have changed, so it can adjust while the work is still cheap to change.
-
3
A crash takes the work with it.
Agent runs die partway through — a timeout, a killed terminal, a machine that sleeps. Tower takes automatic snapshots of each agent's work as it goes, so a dead run can be picked up from where it stopped rather than started over.
-
4
Nobody knows what happened.
Tower records who did what, when, as it happens, so you can see what each agent is doing now and read back what it did later.
-
5
The pieces don't fit back together.
When the agents are done, Tower helps assemble their separate changes into one result and check it, before it goes into Git.
How it works
The tower sees every train
Tower runs beside your repository as one small program. Each agent joins it as a session; from then on Tower watches the working tree, so what it reports is what actually changed on disk — not what an agent says it changed.
tower join → tower claim → (work) → tower leave
-
A session per agent
An agent joins with the part of the tree it means to work in — or the whole tree, or nothing at all if it only watches. Agents whose scopes differ can share one checkout.
-
Claims raise a flag, never a lock
A claim on a file or a function is advisory. A second claim on the same thing is reported to both agents as a conflict; neither is stopped from writing. A claim lasts as long as the session that made it.
-
Checkpoints you never see
Snapshots of each session's work are kept under hidden Git refs (
refs/forge/checkpoints/…), never on a branch and never in your index, and are taken when a session goes quiet, on an interval, and as it leaves. -
Peer work arrives by invitation
Tower never changes an agent's files behind its back. A teammate's change is offered as a read-only view against a numbered integration generation, and is taken only when the agent accepts it.
What you can go and check
Each claim below names the mechanism behind it. If the mechanism is not there, the claim is false.
-
git statusreads the sameCheckpoints are refs under
refs/forge/, and Tower's own state lives in an ignored.forge/directory. Your branches, index and status are untouched. -
The record checks itself
Every event is appended to a hash-chained journal.
tower events -verifywalks the chain with no daemon running and names the first entry that does not fit. -
Nothing reports its own state
Changes are observed from the file system and credited to the session that holds the path. There is no call by which an agent tells Tower what it changed.
-
A crash is recoverable
A session that dies is rebuilt from the journal alone: its last attempt, its claims and the newest checkpoint that holds work Git does not have yet.
Works on any Git repository, with no Ironway account
Tower is one program you install on your own machine. It works on any Git repository you already have — no Ironway account, no sign-up, no hosted service and no change to how you use Git. It works the same whichever tool starts your agents, and it talks to them through an ordinary command line and an MCP server that coding agents can call directly. Tower is part of the Ironway family, and it can plug into the rest of Ironway if you use it, but it never needs to.
- Ironwayplans the work and owns the record
- Conductordispatches agents to it
- Towerkeeps those agents out of each other's way
- Roundhousebuilds and checks what they push
Install
One line to a working tower
The installer picks the build for your platform from this site, refuses it unless
its SHA-256 matches the release's checksums.txt, and puts
tower on your path.
Builds for macOS and Linux, on Apple silicon, Intel and ARM. Every file has a published SHA-256 checksum on the downloads page.
$ curl -fsSL https://tower.ironway.work/install.sh | sh
$ tower version
# later: stays current on its own
$ tower update