Gemini 4 Argon Beat Minecraft for $1,620: The Real Unit Economics of a 27-Hour Agent Run

Four Gemini 4 Argon agents walked into a randomly generated Minecraft world with no roles, no strategy, and no game-specific tools. Twenty-seven hours and fourteen minutes later, one of them killed the Ender Dragon. Along the way the team wrote 2,783 JavaScript programs, exchanged 229 chat messages, and died 605 times. The session cost $1,620.

Google DeepMind published the run as "A team of Gemini 4 Argon agents beats Minecraft" on arXiv on October 15. It is the first end-to-end autonomous Minecraft completion using only the standard Mineflayer library, with no pre-scouted seeds and no game-specific tools written by humans. It is also, as far as anyone has published, the first per-task bill for a multi-day agent run of this kind. That second fact is the one that matters to your budget.

Your team does not have an API spend problem. It has a resident-process problem, and this run is the first time anyone has shown the meter reading. "Energy per Request Is the New AI Cost Moat" priced the single request. This prices the whole run, failures included. Nobody budgets agents because nobody has had a published invoice to model against. Now there is one, and the arithmetic is uncomfortable.

THE 1,620 DOLLAR RECEIPT

Read the receipt the way the paper wrote it, because most coverage did not. The four players processed about 1.35 billion input tokens and roughly 16 million output tokens, 4 million of them thinking tokens, across about 24,000 model calls. Ninety-one percent of that input came out of the context cache.

The paper gives two costs, and they cover different things. Up to the win, the four players cost about $520 at Gemini 4 Argon's introductory list price and about $1,040 at the standard price. The whole session, including a fifth Observer agent that watched for cheating and the day of activity after the win, came to about $810 at the introductory price and about $1,620 at the standard price. Those are estimates from list prices and the session's token counters, not the cost of serving the model, and the paper says so in the same paragraph.

You can rebuild the $1,040 from the token counts. Google's published standard rate is $4 per million input tokens, $0.20 per million cached input tokens, and $20 per million output tokens, all taking effect December 1, 2026. That puts the uncached 9 percent of input at $486, the cached 91 percent at $246, and the output at $320. The total is about $1,052 against the paper's $1,040, inside 1 percent. The invoice reconciles, which is rarer than it should be.

Now the back of the envelope, and label it as such. At the full-session $1,620 across 27.23 hours, you are paying about $59.49 an hour. Across 2,783 programs, about 58 cents per program written. Across 605 deaths, about $2.68 per death and recovery. On the up-to-win $1,040 the same arithmetic gives $38.19 an hour, 37 cents a program, and $1.72 a death.

Two of those three numbers are the ones people quote. The third is the one that eats the budget. A per-task bill decomposes into cost per meaningful action, cost per failure, and cost per recovery, and almost nobody models recovery. In this run, a death was not an exception. It was a routine line item, and the agent that died had to be re-provisioned, re-equipped, and walked back to the plan by teammates who were already mid-task.

Note the boundary as well. The program and death counts stop at the win. The $1,620 keeps going through the Observer and the following day. Per-unit figures built on the larger number overstate cost per unit slightly, which is the useful direction to be wrong in, but always say which denominator you used.

THE CONTEXT TERM IS THE DOMINANT TERM

Twenty-four thousand model calls mean the context was rebuilt roughly twenty-four thousand times. That is where the money went, and a sponsored analysis from MarkTechPost, funded by TinyFish, puts a number on how badly it can go.

The piece took one Daily Mail article with roughly 4,300 characters of body text and ran it through five extraction providers. TinyFish Fetch returned 4,737 characters, about 1,184 estimated tokens. Exa returned 65,793 characters, about 16,448 tokens. Tavily returned 46,433 characters, about 11,608. Firecrawl returned 171,095 characters, about 42,774. That is a 36-fold spread between the cheapest and the most expensive rendering of the same article. Parallel returned only a 600-character excerpt, so its 150-token figure is not a fair comparison.

Read the caveats before you quote it. The token counts assume about four characters per token and an illustrative $1 per million input price. Retrieval charges, reasoning, and output are excluded. It is one page, and the piece says the difference should not be generalized across all websites. The sponsorship is disclosed in the article itself, and the token arithmetic is still the part your team never measures.

Do the multiplication anyway, as arithmetic and not as a published finding. Three pages at Firecrawl's 42,774 tokens is 128,322 tokens. That is a 128K context window gone before the agent has reasoned about anything, and the article makes the same point about a 128K window explicitly.

The retrieval snapshot matters too. On Artificial Analysis's September 28, 2026 search API snapshot, TinyFish Search scored 71 at $9.30 per 1,000 benchmark tasks with 59.0 seconds per task. Perplexity Search in medium mode scored 80. The no-search baseline scored 33. Skipping retrieval is cheaper and dumber, and the benchmark prices that gap at 38 points.

The framework is two lines, and most teams meter one. What an agent pays to read the web is the retrieval charge plus the model processing cost of everything retrieved. Retrieval charges show up on an invoice. Context volume does not, unless you are counting tokens per action.

THE PER-TASK COST LEDGER

Name the thing, because a named instrument is the only kind that gets built. The Per-Task Cost Ledger is five lines every long-run agent should emit when a run ends.

1. Total run cost.
2. Cost per meaningful action.
3. Cost per failure and recovery.
4. Context tokens consumed per action.
5. Tool and retrieval spend per action.

That is the whole framework, and the constraints are what make it usable. A "meaningful action" has to be defined in your domain before the run starts. Failures and recoveries are counted separately, because recovery is a second cost, not a retry of the first. Context tokens are attributed per action rather than summed at the end, because a total tells you nothing about which step burned the window.

If your agent cannot produce this ledger, you cannot compare it to the $1,620 benchmark, and you cannot price the task you are selling. A run that costs $1,620 and cannot say which steps earned it is a bill with a story attached.

WHAT THE HARNESS CAN AND CANNOT DO ABOUT IT

"Your Agent's Harness Is Your Real Model" made the case that orchestration design beats model selection. This run is the invoice for that argument.

The architectural shift behind it is bigger than Minecraft. Agents are being re-architected around long-lived execution, and the new cost centers are context volume, orchestration latency, control plane load, identity, and the per-task bill at the end. Your harness can move four of those five. It cannot move list price, and it cannot make a recovery free.

The practical levers are short. Filter retrieval before it hits the window. Log per-step cost while the run is happening, not after. Cap context per step so a single bad page cannot eat the budget. Pick the model tier per step rather than per run, because a tool call and a planning step do not need the same model.

monday.com's engineering team published the control plane version of the same lesson. Agent traffic grew 2.5 times, one user sentence became dozens of API calls, and rebuilding the API edge cut CPU 92 percent. That is the same disease at a different layer, and it deserves its own note.

The 91 percent cache hit rate is the part of the Minecraft run to study hardest. It is why 1.35 billion input tokens cost four figures instead of five, and right now it is the lever in the stack that pays back fastest.

WHAT TO DO TODAY

1. Instrument cost per step on one production agent this week. You need total, per action, and per failure.
2. Measure the token spread of your own retrieval path. Fetch the same page through two providers and count.
3. Cap unfiltered page content before it enters the context window. Three large pages can exceed 128,000 tokens.
4. Emit a Per-Task Cost Ledger at the end of every run, even a cheap one.
5. Compare your ledger to the $1,620 Minecraft receipt before you promise anyone a margin.

THE UNCOMFORTABLE QUESTION

DeepMind published the invoice because $1,620 to kill a dragon sounds impressive, and at $38 an hour for the winning portion it is. If your agent costs that much and nobody can say which steps earned it, who exactly is the autonomous one?