A local agent harness for parallel coding agents, with a propose, evaluate, critique, verify loop and resume after a crash. In development.
In build. Follow along.
You leave a pile of work with AI agents overnight. Some say they're done, then the tests fail. Others died at 2 a.m. and you start over.
Each task runs a propose, evaluate, critique, verify loop (a generator-evaluator loop) until the result meets your bar, so you don't have to sit and watch.
Example: you write “the game builds, every test passes, and the player can reach level two.” The task stops only when all three are true.
Parallel coding agents work different tasks at once, or different paths through one task, and bonfire keeps the best result or a mix of them. A local queue of hundreds of tasks is planned.
Example: on one task, one agent builds the jump with real physics and another snaps it to a grid. You get the winner and a note on why it won.
Every step is saved as a checkpoint when it finishes (durable execution), so a crash or restart carries on where it stopped. That is what lets runs last for days.
Example: force-quit halfway and restart. Each agent resumes from its last saved step, and no finished work is redone.
Queue your tasks, each with the checks that prove it's done, like your tests.
Agents work in parallel, each on its own copy of the project. If the machine restarts, they pick up where they stopped.
You get the finished work plus a log of every choice and every token burned. A live token-burn meter is planned.
For builders: bonfire is an agent harness (the program that runs agents), built around one generator-evaluator loop that proposes, evaluates, critiques and verifies. We call it a gauntlet. Long-running agents are a live idea: Anthropic has written about harnesses for them, and Cursor about running coding agents for weeks. bonfire is a local take on it.
You feed bonfire a queue of jobs and go to bed. One is “Make a one-screen game where a frog crosses a busy road”, with a prep folder from Mise en Place (research and context gathered for the job) and three checks.
Parallel agents start at once, each on its own copy. On the frog job, four of them take different paths: smooth movement, grid hops, the cars, the score screen.
Halfway, you kill the process. Nothing graceful. You start it again.
The agents pick up from their last saved step and finish. A fresh reviewer reads each game, a separate check confirms the reviewer's claims, and bonfire merges the best work into one game that passes all three checks.
In the morning, the run folder shows every decision, in order, and the token meter shows how many tokens went up in smoke.
Plenty of tools run coding agents in parallel, and they are worth a look: Orchestrator.inc, Orca, Conductor and Munder Difflin, for example. Most of what we found is built mainly for a person watching, steering and reviewing agents. bonfire is aimed at the other case.
Status: in development. Nothing here has shipped, and the rival descriptions come from their public pages and search snippets. If you want to watch and steer agents yourself, a cockpit fits better.
bonfire runs the work in a set of five tools David Hatley is building for making things with AI agents.
does the prep for any project (research, assets, references, context), so you or your agents start on the work.
answers an agent's multiple-choice questions fast and says how sure it is.
turns one sentence into a small game you can play from a link.
is a design canvas where you and an AI agent edit the same React components, live.
For short jobs, do that (people call it a Ralph loop). For long ones, bonfire adds a queue of tasks, parallel agents, a fresh reviewer, a check on the reviewer, and progress you can resume after a crash.
Yes, and the reviewers add more. That's the joke in the name. Every run logs the tokens burned at each step, and a live token-burn meter is planned, so you see what the fire cost.
That is the goal, not yet shown. The first proof is the demo above: kill a run mid-way and watch it resume.
Gauntlet is our name for the loop, and the project's earlier name. It is a generator-evaluator loop: propose, evaluate, critique, verify, repeated until the checks pass.
Not decided. The proposal is a thin core on pi's crash-safe runtime library, with no fork. David makes the call.
It runs locally, with no hosted version. The agents still send prompts to their AI model.
No. Nothing has shipped. Read the plan, and watch it get built.