Prototyping — race your favorite agents on the same brief

Here is the short version. Prototyping takes one brief and runs it through several coding agents at once — Claude, Codex CLI, GitHub Copilot CLI, in the engine-and-model combinations you pick. Each contender gets its own DevBox and its own branch and works the task to completion without waiting on the others. When they finish you have a row of real, comparable results: what each one cost, how long it took, a summary of what it did, and a live preview of its terminal and screen. You pick the winner, promote it, and that branch becomes the pull request. It is vibe coding with the guardrails a team needs — parallel, on infrastructure you own, ending at a PR you review.

The problem it solves is a familiar argument. Which agent is best for this task? People answer from habit and from last month's benchmark, but the honest answer is that it depends on the task, and the only way to know is to run it. Doing that by hand is tedious — you would launch the same brief three times, babysit three terminals, and hold three half-finished attempts in your head to compare them. Almost nobody bothers, so the strongest opinion in the room wins instead of the strongest result. Prototyping turns that debate into an experiment you actually run, because running it is now one action instead of three.

A prototype starts the way any task does: you write the brief once. Then, instead of choosing a single engine, you pick the contenders — each is an engine paired with a specific model, so "Claude with one model" and "Claude with another" are two legitimate entries in the same race, right alongside Codex CLI and GitHub Copilot CLI. Launch, and the orchestrator fans the identical brief out to every contender at once. Each runs in its own disposable DevBox on your own workers, on its own branch, fully autonomous — no contender can see or step on another's work.

While they run, you watch. Each contender is a card, and the cards update live: status, elapsed time, accumulating cost, and the agent's own running summary of what it is doing. Open any one and you get the same preview you would have for a single run — the live Terminal streaming its commands and, for a contender working in a desktop DevBox, the Display showing its screen. One preview is expanded at a time so the comparison stays legible rather than turning into a wall of terminals. Nothing about the race is hidden behind a spinner; you can see each agent think.

When the contenders finish, the cards become a comparison. Side by side you have the four things you actually decide on: total cost, wall-clock duration, the agent's summary of the approach it took, and its branch to inspect. This is the moment the feature exists for — not a leaderboard we computed for you, but the real finished work of each agent laid out so your judgment, not a benchmark, picks the winner. Sometimes the cheapest one is plainly correct. Sometimes the expensive one did something the others missed. You can only tell by looking, and now looking is easy.

Promoting is the last step, and it is deliberately the only one that leaves a mark. You choose the contender you want, promote it, and that branch — the one you already read — is what opens the pull request. The prototype does not merge, and it does not open a PR for every contender and leave you to close the losers; the branches that lost stay branches. "This agent won the race" and "this is a pull request against your repo" are one intentional click apart, with you in between. Everything upstream of that click was an experiment; the promotion is the commitment.

Prototyping is available on every plan, including the free tier, with caps that scale up as you move up. How many engines you can put in a single race grows with your plan — two, three, four, and six contenders per prototype — and so does how many prototypes you can have running at once — one, two, five, and ten. The floor is deliberately usable: even on the free tier you can pit two agents against each other on a real task, which is the whole pitch in miniature.

We are shipping this as Beta, and we mean the label. The race, the live previews, the comparison, and promote-to-PR all work today; what earns the badge is that this is a young surface and we expect to learn from how teams actually use a fan-out — which comparisons matter most, where the caps should sit, what a fourth column on each card should show. It sits naturally beside the rest of ClusterCode: the same DevBoxes, the same worker fleet you own, the same multi-engine roster that already powers Runs and Loops. Prototyping just points all of them at one brief at the same time and lets the results argue for themselves.