Open source/Self-hosted/No account/Written in Rust
Run any coding agent,
on your own servers,
from anywhere.
Give Firetower a machine you can SSH into and a repository. It picks a host, cuts a branch, makes a worktree, starts tmux, launches the agent and keeps it running. Then it does the part that actually costs you time: it tells you the moment it stops being useful without you.
Install Firetower on your server
curl -fsSL https://usefiretower.com/install.shClients available for
From issue to shipped
Your entire workflow, in one place.
From any device
Close your laptop anytime.
Pick up your phone.
The agent runs on your server, not on the device you started it from, so every device can pick up exactly where another left off.
IfYour laptop closes. Or the app crashes.
Nothing happens to the agent.
It never ran on the laptop. Open Firetower on any other device and the conversation is exactly where you left it.
IfThe Firetower server goes down.
The workers keep running.
Each agent is on its own machine, in its own worktree. When the server comes back it catches up on everything that happened while it was away.
IfA worker dies.
The worktree is still there.
Your branch and every file the agent changed are on that machine, and Firetower still knows about them. Restart the worker and carry on.
Each part can fail on its own. The work survives every one of them.
How it fits together
Your favorite agent,
on your favorite hardware
Firetower reaches each machine over SSH and starts a worker there. The agents run on that machine — in tmux, on their own worktree — which is why closing your laptop costs nothing and why the app itself never has to be the thing that is busy.
- *a session that has stopped and needs you
- oone still working, nothing to do
- sshhow the app reaches a machine you own
Workers are authoritative.
They write what happened to their own log before reporting it. When the control plane comes back it asks for everything since the last thing it saw — so a closed laptop costs nothing and a reconnect is a replay, not a guess.
The worker never opens a port.
It reads frames from stdin and writes them to stdout, so who dials is a transport detail: a child process, a container exec, or SSH. The daemon cannot tell the difference, and neither can a firewall.
Small by design
Written
in Rust.
By far the most efficient ADE on the market.
A small core, no accumulating terminal daemons, and workspace memory ceilings where the host supports them. Built for work that keeps running.