16 posts tagged “deep-dive”.
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.
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.
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
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.
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.
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.
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.