A team of Gemini 4 Argon agents beats Minecraft

AI summary

Overview

Research area: Artificial Intelligence — long-horizon autonomous agents, multi-agent coordination, and LLM-based code-as-policy agents evaluated in the game Minecraft.

Technical level: Intermediate. The setup is easy to grasp (four AI agents play Minecraft), but the paper assumes some familiarity with coding agents, tool use, and shared memory.

Scope: A single end-to-end run in which four general-purpose Gemini 4 Argon coding agents, given only the open-source Mineflayer library and a one-paragraph objective, coordinated through in-game chat and defeated the Ender Dragon in 27 hours and 14 minutes.

What This Paper Is About

The paper asks whether a team of general-purpose coding agents—not built or tuned for Minecraft—can pursue a single long goal for more than a day, through thousands of self-written programs and hundreds of failures, while coordinating with each other. Four Gemini 4 Argon agents each controlled a player through the open-source Mineflayer library and shared no pre-assigned roles, no human-written game logic, and no plan beyond "defeat the Ender Dragon." The result is presented as the first end-to-end autonomous completion of Minecraft by AI agents using only the standard Mineflayer library, with no pre-scouted seeds or game-specific tools written by humans.

Key Contributions

1. An end-to-end autonomous Minecraft completion. Four agents started from a randomly generated survival world on Easy difficulty (Minecraft Java Edition 1.20.4, cheats disabled, no human input) and defeated the Ender Dragon in 27 hours and 14 minutes, writing and running 2,783 programs before the win and dying 605 times.

2. A no-scaffolding evaluation setup. The agents received the standard Mineflayer library with its pathfinding plugin, a one-paragraph objective, and the same general instructions used for software work. The authors state they added no game instructions, no curriculum, no skill library, no human-written tools, and no route.

3. Documentation of emergent team behaviors. Across 229 chat messages before the win, the agents spontaneously converged on specialization, a shared memory of coordinates and tool quirks, reusable helper functions kept alive between programs, mutual item recovery after deaths, and self-corrections of false success reports.

4. A verified run with an independent observer agent. A fifth agent, the Observer, monitored the session without ever playing or running a program; it flagged no specification gaming, and manual review of a sample of logs found no safety incidents. The win is recorded in the server log as the advancement "Free the End."

Main Findings

• The run succeeded on the first launch. The authors describe a single run, the first launch they tried, which they note cannot show how reliably the setup succeeds.

• Roles emerged within minutes. Ten minutes after the first program, janesick proposed a division of labor in chat; auratian answered with a different plan within a minute and gyldenia replied "Copy that!". Roles settled as: gyldenia scouting food, beds and flint; bulicame going for diamonds; janesick smelting iron and making tools; auratian preparing the Nether portal.

• Early progress was fast. Within two hours the team had iron tools, diamonds and a Nether portal, which was lit 1 hour 42 minutes into the run; auratian found 55 blocks of lava in a village.

• The Endermen shelter trick. Because an Enderman is nearly three blocks tall, the agents built two-block-high shelters from which Endermen could not reach them but would still teleport toward them. Five and a half hours in, the team had 15 pearls in a shared chest.

• Losses became written rules. janesick burned to death carrying twelve blaze powder, and a Ghast fireball destroyed a pile of dropped items; after that, auratian posted a lesson for the team and janesick posted the root cause and a fix two minutes later.

• The stronghold was found by triangulation. janesick threw two Eyes of Ender from different places, sampled each eye's flight every 50 milliseconds, and intersected the two lines: an estimate 1.3 km from the village and 43 m from the actual portal room.

• A coordinated item rescue. When auratian drowned 8 m from bulicame carrying all twelve Eyes of Ender, janesick and auratian each sent bulicame the exact spot and the minute the eyes would vanish; bulicame recovered all twelve with two and a half minutes to spare. At 13 hours 17 minutes, the End portal was lit with all twelve eyes in place.

• The End was the bottleneck. The dragon killed the team 69 times, prompting written rules such as never waiting on the arrival platform, approaching only while it is perched, and leaving the End (by jumping into the void) to reset a stuck dragon. At 17.5 hours, all four did so within six minutes so the empty End would unload.

• The breakthrough was diagnosing the healing crystals. About 21 hours in, auratian identified that the ten crystals kept healing the dragon to full health and worked out a way to reach them without a pickaxe: stack dirt beside each pillar, punch the crystal, dig back down by hand. All ten were destroyed over the next four hours and forty minutes, and the dragon died thirty-nine minutes after the last one, with bulicame at 2.5 of its 20 health points.

• Reusable engineering artifacts. The agents kept 146 pieces of state and code alive between programs, including 42 helper functions; one leftover-code guard was referenced in 1,519 programs, and a crafting-quirk helper first warned about by gyldenia nineteen minutes in appears in 655 programs written by all four agents.

• Agents corrected each other. auratian retracted a false success two minutes later ("my previous chat was an unguarded script branch"), and gyldenia flagged a contradiction in janesick's report within three minutes.

• Failures were frequent. 22% of programs ended in an error, and the players died 605 times, mostly to monsters.

• Operating profile. The median program ran for 33.5 seconds, and each player had a program running about 40% of the time; the rest went to reading results, thinking and writing the next program. The run included 6 server restarts that paused the world for about 20 minutes in total and spanned about 81 in-game days.

• Cost. Up to the win, the four players processed about 1.35 billion input tokens (91% served from the context cache) and generated about 16 million output tokens, including 4 million thinking tokens, over roughly 24,000 model calls—about $520 at Gemini 4 Argon's introductory API list price ($1,040 at standard). The whole session, including the Observer and the day after the win, came to about $810 ($1,620).

• No cheating detected. None of the 2,839 programs run during the session made a network request or referred to a web source, and none used a server command.

Methodology in Plain English

Each of the four players is an instance of the same general-purpose coding agent (Gemini 4 Argon), running on its own cloud machine with ordinary software-engineering tools: a code workspace with version control, a shell, file editing, web search, and a persistent memory with a private and a team-shared part. Rather than seeing pixels or pressing keys, an agent acts by writing a short JavaScript program—for example, walk to these coordinates and mine every iron ore within 16 blocks—sending it to its Mineflayer bot through a command-line client, and reading back text: position, health, inventory, what it found, or the error it hit. It then writes the next program. Programs run with the pathfinding plugin loaded and no added helpers; they can use Node.js built-in modules and installed Mineflayer packages but cannot start processes or write files.

Communication happens through the game's own chat, which reaches every bot and appears in the output of each player's next program. The server records chat, deaths and advancements, keeps every program with its output, and saves the world every five minutes, restarting from the latest save after a failure. A fifth agent, the Observer, followed the session as an independent witness, checking claims against the record and publishing a live report, but never joining the game or intervening on strategy.

Why This Matters

The paper argues that complex real-world software engineering and enterprise tasks demand the same long-horizon coding and multi-agent coordination that completing Minecraft required: keeping a coherent plan across thousands of dependent steps for more than a day, recovering from failure, and sharing what was learned. It is a demonstration that a general-purpose coding agent, given nothing game-specific, can turn prior knowledge into working programs and coordinate with peers.

Real-world applications:

• Long-horizon software engineering: agents that hold a plan across thousands of dependent steps and debug their own tools, which is the core loop the paper exercises.
• Multi-agent enterprise workflows: teams of agents that self-assign roles, share notes, and cover for each other's failures, demonstrated here without any role assignment or human orchestration.
• Failure recovery and observability: written rules derived from incidents, shared memory of pitfalls, and an independent observer agent that verifies claims—patterns directly transferable to production agent deployments.
• Cost modeling for agent teams: concrete token, call-count and dollar figures for a day-long multi-agent run, useful for budgeting agentic workloads.

Industry relevance: the run shows both the promise and the cost profile of deploying general-purpose coding agents on open-ended, multi-day tasks, and it offers a transparent, fully logged setting for studying agent coordination before such systems are trusted with real work.

Future Directions

• Reliability across runs. The authors note this is a single run, the first launch tried, so how often the setup succeeds is unknown; repeated runs would establish success rates.
• Harder perception and difficulty settings. Playing from pixels with a keyboard and mouse (as SIMA 2 does) and on Normal or Hard difficulty remain substantially harder than the code-mediated, Easy-difficulty setting reported here.
• Distinguishing knowledge from skill. Because Gemini 4 Argon already knows a great deal about Minecraft and Mineflayer from training data, testing on games or environments it has not seen would separate prior knowledge from genuine planning ability.
• Reducing the failure and time cost. With 605 deaths, 22% of programs erroring, and nearly 14 hours spent in the End, improving recovery and reducing wasted effort is an open engineering question.

Target Audience

Researchers and engineers working on LLM-based agents, code-as-policy methods, and multi-agent coordination will get the most from this paper, along with practitioners building long-running autonomous agents for software or enterprise workflows. It is also accessible to readers interested in AI benchmark design and evaluation, since a large part of its contribution is the carefully controlled, fully logged evaluation setup and its explicitly stated limitations.

Authors’ abstract

We placed four Gemini 4 Argon agents in a sandboxed Minecraft survival world and gave them one goal: defeat the Ender Dragon. Each agent controlled a player via an open-source library called Mineflayer and coordinated with its teammates through in-game chat and shared memory. No one assigned roles or wrote game logic. The agents planned, wrote, and debugged every program themselves. Researchers could watch the run on a live dashboard and pause or stop it at any time, but they had no cause to intervene. Starting from a randomly generated world on Easy difficulty, the team wrote 2,783 programs and defeated the dragon in 27 hours and 14 minutes, dying 605 times along the way. To our knowledge, this is the first end-to-end autonomous completion of Minecraft by AI agents, achieved using only the standard Mineflayer library without pre-scouted seeds or other game-specific tools written by humans. Winning required the agents to keep a coherent plan across thousands of dependent steps for more than a day. Complex real-world software engineering and enterprise tasks demand the same long-horizon coding and multi-agent coordination. We describe the setup, how the run unfolded, the team's strategies (dividing the work, sharing what they learned, recovering each other's items), and the limits of the result.