Notes from the team building Watchfire. Releases, deep dives, the occasional behind-the-scenes look at running coding agents in sandboxed git worktrees.
New to the terminology? Skim the Glossary →
7 min
For nine majors Watchfire drove coding agents. Firestorm inverts that: watchfire mcp serve exposes the whole orchestrator to any MCP-capable client as an 18-tool factory, so an outer agent plans and reviews while Watchfire manufactures the code in sandboxed, worktree-isolated runs. It is the fourth thin client, it holds no orchestration logic of its own, and it is local-only by construction.
6 min
Inferno is the first feature-forward major since Beacon, and it's built around a single idea — supervising many projects at once. The Electron GUI goes multi-window, the Project View flips to chat-primary, wildfire becomes a GUI control, the dashboard becomes mission control, and a new analytics layer measures what the agents actually shipped, not just how many tasks closed.
8 min
One daemon, three clients, a long-lived stream of terminal output running alongside ordinary request/response calls. The protocol that carries all of that is gRPC over loopback TCP. Here is the honest accounting: the four alternatives we steelmanned, what the .proto actually looks like, how a client opens the connection, and the costs we took on to get schema-first generated clients in two languages.
6 min
Anatomy of a great task argued from what good looks like. This is the inverse: five specific ways we have watched our own tasks waste an agent run, why each one fails, and what to write instead. Most of these examples are ours. Honestly so.
6 min
The 7.2 → 7.3 arc is a tidy little story about operability. We made the daemon log durable, the durable log grew to 300 GB, and 7.3 caps it. Along the way we closed two wildfire YAML bugs that were silently eating tasks, and gave the GUI a focus-chat mode. Here's what shipped.
6 min
When a task gets stuck, the answer is almost always in watchfired's log. Here is where it lives, what its lines actually look like, and the five events plus three walkthroughs you'll reach for when an agent won't start, a worktree won't spawn, or an auto-merge never fires.
7 min
The happy path is easy: the agent works, sets status done, the daemon merges. This is the other path. The PTY dies, the agent stalls, the sandbox kills it, the daemon restarts. Here is what Watchfire actually does — and what it leaves for you to do — when a run goes wrong.
7 min
Wildfire mode runs the task queue, refines drafts, generates new work, and at some point it stops. The signal that stops it is one empty file. Here is why that signal, and not a timer or an iteration cap, is the one we keep.
7 min
Point Wildfire at a real codebase and within a day you'll ask the question: what happens when two tasks both edit package.json? The honest answer is more nuanced than 'git sorts it out.' Here is exactly what Watchfire does at merge time, the three outcomes you'll see, and how to design tasks so you rarely hit the bad one.
8 min
YAML in 2026 sounds like a punchline. We picked it anyway for project.yaml and every file under .watchfire/tasks/. Here is the honest accounting of what each contender got right, where YAML hurts, and why those tradeoffs were the right ones for a format that humans and agents both have to author.
9 min
There is a binary called watchfired, it runs in the background, it talks gRPC to three clients. The first reasonable question is: why does this need a daemon? Here is the long answer.
10 min
Watchfire runs six coding agents on the same task contract. Knowing you can swap them is not the same as knowing which one to reach for. Here is the opinionated version: given the shape of a task, which backend to pick and which to fall back to.
10 min
The acceptance_criteria block is the single field the daemon, the agent, and the human reviewer all read the same way. It is also where most failed Watchfire runs are decided — long before the agent picks a file to edit. Here is how to write criteria that hold.
10 min
Watchfire's UI feels reactive because the daemon never sleeps on its files. The canonical state of every project lives on disk, agents 'complete' a task by saving a YAML, and a debounced watcher fans the change out to every connected client. Here is the architecture, the trade-offs, and the edge cases.
13 min
Every page on watchfire.io was shipped by a Watchfire task running in an isolated worktree, and the daemon kept a record of each one. After 155 tasks, the numbers say something we did not expect about prompt length, refine passes, and which kinds of work agents actually finish on the first try.
11 min
Watchfire itself is free, but every task it runs spends real money against an agent backend. Here is a practical, numbers-forward breakdown of what each backend costs, which mode burns the most, and three concrete ways to stay under a monthly budget.
10 min
Wildfire only stays on the rails when the project definition does the bounding. After a year of running Watchfire on its own marketing site, here is what a definition needs to contain so the loop produces work you actually want to merge.
8 min
Six agent modes is one more than you can hold in your head when you are staring at the GUI for the first time. Here is a practical, opinionated decision tree for picking the right one without burning a session.
11 min
A practical migration guide for developers already using a coding agent CLI directly. What stays the same, the four real shifts, and the first hour of using Watchfire on a project you already know.
11 min
Watchfire was designed for one developer running many agents — but the same primitives (tasks as files, worktrees as review surfaces, audit trails on disk) turn out to be exactly what a team needs. Here's how it works when there's more than one of you.
10 min
Most failed agent runs aren't model failures — they're prompt failures. After a year of running Watchfire on itself, here's what we've learned about writing tasks an agent can actually complete on the first try.
9 min
The autonomous loop is only useful if a human can hear about it from wherever they happen to be. Beacon is the layer that lets Watchfire talk to Slack, Discord, and the PR queue — and just as carefully, lets them talk back.
8 min
Every page, every blog post, every illustration on watchfire.io was shipped by a Watchfire task running in an isolated worktree. Here's what we learned from one hundred and thirty sessions of running the tool on the tool.
10 min
Worktrees stop an agent from stomping on your branch, but they will not stop it from reading your SSH key. Here is the OS-level sandbox layer that does, and how Watchfire picks the right backend on each host.
10 min
Counting agent sessions is easy. Deciding what survives the session is harder. Watchfire's Insights subsystem keeps a fixed, tiny record per task on disk — and the choice of what not to record is most of the design.
11 min
Two secret stories live inside the daemon — a Markdown file that gets injected into the agent's system prompt, and an OS keyring that holds the bot tokens for every integration. The thread that ties them together is a write-only wire: a gRPC contract that lets a client save a credential but never read one back.
8 min
Watchfire runs Claude Code, Codex, opencode, Gemini CLI, GitHub Copilot CLI, and Cursor on the same task contract. Here is why the agent is the swappable part and the orchestration is the part worth building.
7 min
Wildfire mode turns a project definition into a self-refining queue of tasks. Here is how the loop is shaped, why each phase exists, and where the safety rails are.
9 min
Every Watchfire task runs in its own git worktree on a dedicated branch, not in a fresh checkout of the main tree. Here is why that choice carries more weight than it looks.
1 min
Why we are building Watchfire, what is in v7.1.0 Forge, and what to expect next from the blog.