Four AI agents beat Minecraft in 27 hours and 605 deaths without help, and the machinery behind it was code they wrote for themselves
Four DeepMind agents played Minecraft unattended for 27 hours and died 605 times; what a product team can copy is the code and shared notes they wrote for themselves, and what that costs.
Four agents entered a freshly generated Minecraft world with one sentence of objective: defeat the Ender Dragon, the game's final boss. They wrote 2,783 programs, died 605 times, and finished 27 hours and 14 minutes later. 1
The agents ran on Gemini 4 Argon, and the researchers are Maxence Faldor, Satinder Singh and Roberta Raileanu at Google DeepMind. They published the technical report on 15 October, and the result drew mainstream coverage this morning. 2
The constraint is the part worth your five minutes. The only tooling the team supplied was Mineflayer, an open-source library for driving a Minecraft player from code, plus one paragraph of instructions. Roles, curriculum, skill library and any tool that knew the game were all withheld. 1
Everything the agents needed beyond that, they wrote themselves and left where the next program could pick it up. That pile of self-written code is the part a product team can copy this quarter.
What the four agents were handed
Minecraft has been the standard hard test for open-ended agents since 2022, when MineDojo named the dragon one of its moonshot goals. 1 Later work trained policies on recorded gameplay, or wrapped a language model in a Minecraft-specific planner, memory and skill library. Each of those systems carried something a person had built for the game.
Two community projects had already killed the dragon. One put a single Claude Opus 5 agent in front of 37 high-level Minecraft tools written by a human, on Normal difficulty, in September. 3 The other paired a planner with an action-selection model on a fixed speedrun seed, on Peaceful. 1
So the claim is narrower than the phrase that traveled. The dragon had already fallen. What the four agents did for the first time was reach it with the tool catalog deleted, the seed unknown and the route unplanned.
An agent's move here is a program. Each wrote a few lines of JavaScript — walk to these coordinates, mine every iron ore within 16 blocks — and a Mineflayer bot ran it. What came back was text: position, health, inventory, what it found, or the error it hit. 1
The median program ran for 33.5 seconds, and each player had one running about 40% of the time. The rest of the clock went into reading results and writing the next program. Every step ended in text the agent could check before committing to the one after it.
The four players shared two further channels: the game's chat, and notes each agent kept where the others could read them. A fifth agent, the Observer, followed the session, checked the players' claims against the server record, and never joined the world. 1
The layer that held for 27 hours
The number to remember from this paper is 146. That is how many pieces of code and state the agents kept alive between programs, so a function written in hour two still ran in hour twenty. Forty-two of them were helper functions: a background loop that keeps a bot from drowning, timed walking, item counting. 1
Two examples show the pile doing real work. Nineteen minutes in, one agent warned the team about a quirk in Mineflayer's crafting, and a helper function containing the fix ended up inside 655 programs written by all four. A counter that makes leftover code from a timed-out program stop itself appears in 1,519 programs.
The agents were told to record mechanics, strategies and workarounds so that no obstacle was met twice, and to keep in memory whatever had to survive context compaction. That instruction matters at this scale. An agent working for a day compacts its context again and again, and whatever it wrote into the workspace survives the cut while the rest leaves with the text it came from.
Coordination started early, and by disagreement. Ten minutes in, janesick proposed a division of labor, and auratian answered within a minute with a different plan; gyldenia replied "Copy that!" Roles settled from there: food and flint for gyldenia, diamonds for bulicame, iron and tools for janesick, the Nether portal for auratian. 1
Losses turned into rules. After a Ghast fireball destroyed a pile of dropped items in the Nether, auratian posted a rule for everyone, and two minutes later janesick posted the root cause and the fix. When a program announced a success that had not happened, auratian retracted it two minutes later: "my previous chat was an unguarded script branch."
What the day looked like
Six hundred and five deaths over 27 hours is about 22 an hour, and 22% of the programs ended in an error. The world server restarted six times, pausing the game for roughly 20 minutes in total. 1
HowLongToBeat puts a first run of Minecraft's main story at a median of 45 hours, and the random-seed speedrun record is under seven minutes. Four agents on Easy, working through programs rather than a screen and keyboard, is a different exercise from either.
The run has a shape. Iron tools, diamonds and a lit Nether portal took under two hours. An Eye of Ender needs blaze powder, which the blazes guarding Nether fortresses drop, and an ender pearl, which Endermen drop; the team had 15 pearls in a shared chest at five and a half hours. Carrying the blaze powder back out of the Nether took more than six hours, and cost them a player who burned to death holding twelve of it.
Navigation was the prettiest part. Finding the stronghold, the underground structure that holds the portal to the End, came next, and from there janesick threw two Eyes of Ender, thrown items that drift toward the structure, sampled each one's flight every 50 milliseconds, and took the intersection of the two lines. The estimate landed 43 meters from the portal room, 1.3 km away. 1
Then came the End, which took nearly 14 hours and killed them 69 times. At hour 21, auratian worked out that the ten crystals on the obsidian pillars were healing the dragon back to full. The same insight removed the pickaxe problem: stack dirt to climb, punch the crystal, dig down by hand. All ten fell over the next four hours and forty minutes.
The win is recorded in the server log as an advancement, the game's achievement flag, [Free the End], at 27 hours 14 minutes 12 seconds. None of the programs used a server command. 1
Loading content card…
The bill
Up to the win, the four players processed about 1.35 billion input tokens, 91% of them served from the context cache, and generated about 16 million output tokens, four million of them thinking. That came to roughly 24,000 model calls. 1
At Gemini 4 Argon's introductory list price the run cost about $520; at the standard price, about $1,040. Adding the Observer and a day of activity after the win, the whole session comes to about $810 at the introductory price and $1,620 at the standard one.
Divide it out, and four agents working round the clock cost between $19 and $38 an hour, and between 19 and 37 cents a program. The authors describe these as estimates from list prices and the session's token counters; the cost of serving the model would be a different figure.
Ninety-one percent of that input arrived from the cache. A team planning a long run should ask what its own cache hit rate would be. An agent that re-reads the same instructions, notes and tool list every step pays full price for all of it.
Where the claim stops
The authors list six limitations, and three of them change how you read every number above. Perception arrived as structured data through Mineflayer, including blocks behind solid rock and the dragon's internal behavior phase — information a human player has to see, or cannot see at all. Difficulty was Easy, where monsters deal less damage and hunger cannot kill. And Gemini 4 Argon already knew a great deal about Minecraft and Mineflayer from its training data. 1
The other three are about failure. The players died 605 times, 22% of programs errored, and the End swallowed nearly 14 hours. The infrastructure restarted six times. And this was a single run, the first launch the team tried, which cannot show how reliably the setup succeeds.
Faldor posted his own framing of that: "An independent research experiment, not an official Minecraft milestone, and not approved by or associated with Mojang or Microsoft." 4
The reliability gap looks general rather than peculiar to this run. A benchmark posted five days earlier measured tool-calling agents against users whose patience varies, and found substantial gaps between average task success and consistent task completion across frontier models. 5 One run at 27 hours gives a path. A rate needs repeats.
The reaction separated along the same line. DeepMind's own account of the run was that four agents "beat Minecraft from scratch in 27 hours." 6 Ethan Mollick read the paper as an accessible case of spontaneous coordination among agents, and worth comparing against how humans would approach the same goal. 7 Zoubin Ghahramani called it "remarkable long-term planning and problem-solving all the way to the end." 8
How a team would run this
Four pieces, and only one of them is about the model.
The first is an action surface made of code. A model that writes a short program per step gets back a parseable result, and a program is something a later program can reuse. A tool with a fixed schema leaves no artifact behind for the next hour.
The second is storage outside the context window. Those 42 helper functions survived 27 hours because they lived in a workspace rather than a transcript. When the transcript is the only memory, every compaction is a chance to lose the fix you already paid for.
The third is a failure budget. Six hundred and five deaths were absorbed because death was cheap, visible and recoverable: a player respawns and keeps going. Map which failures in your system are recoverable at what cost before an agent meets them, and cap the ones that are not.
The fourth is a verifier that reads the world. The Observer compared the players' claims against the server log and flagged no specification gaming, meaning no case of an agent exploiting a flaw in how its success was measured. One agent whose only job is checking what was said against what happened is the cheapest guardrail in the paper.
Gemini 4 Argon mattered here as a coding model good enough to write correct short programs at volume. The scaffolding around it is the part your team builds and owns.
Where your team sits
Your task has an exact checker and reversible actions. Build the loop this quarter. Code changes against a test suite, queries against a row count, config changes against a load test: each one gives an agent a program to write and a result it can read.
Your task is code-shaped but your agents forget. Start tomorrow, and your ceiling is storage. Put the artifact store in before you add the fifth agent, because the second agent multiplies what the first one cannot remember.
Your judgement task carries irreversible actions. Payments, deletions, anything a customer sees. The paper's guardrail here is a monitoring pattern plus a person still deciding; a 22% program error rate needs that person standing before the action, and that person sets your throughput.
| What happened | What the check was | Action window |
|---|---|---|
| Four agents held one goal for 27 hours across 2,783 programs | Every step returned text the agent could verify before the next one | Pilot one code-action loop on an internal task this quarter |
| They wrote 42 helper functions and kept 146 pieces of code and state alive | Reuse across programs, held outside the context window | Ship the artifact store before scaling agent count |
| 605 deaths and 22% program errors, absorbed with nobody paged | Cheap, visible, recoverable failures | Set the retry ceiling before you set headcount |
| The win cost $520 to $1,040, about $19 to $38 an hour for four agents | List prices and token counters, at a 91% cache hit | Price a week of the pilot before you price a quarter |
| One run, on Easy, with prior knowledge of the game | A single launch, with no repeat to estimate a success rate | Read it as a feasibility argument; a planning input needs repeat runs |
What this week establishes: four general-purpose coding agents can hold one goal through thousands of dependent steps for more than a day, coordinate it through chat and self-written code, absorb 605 failures, and finish the job for about the price of a laptop. What it leaves open: how often that happens twice, how much of it survives harder difficulty and a task the model never trained on, what the same loop costs at an OpenAI or Anthropic price, and whether a 22% program error rate is acceptable in any system a customer touches.
References
- 1
- 2
- 3Mine AI MCP
github.com
- 4Maxence Faldor on X
x.com
- 5τ-Emotion-Bench
arxiv.org
- 6Google DeepMind on X
x.com
- 7Ethan Mollick on X
x.com
- 8
This story was produced automatically by a channel. One sentence is all it takes for Neodrop to keep producing for you.