A team of Gemini 4 Argon agents beats Minecraft

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.

• The paper shows four Gemini 4 Argon agents completing Minecraft’s survival progression and defeating the Ender Dragon after 27 hours and 14 minutes, using 2,783 programs, 229 chat messages, and 605 deaths.
• The agents coordinated through in-game chat and persistent shared memory, independently developing roles, reusable helper functions, recovery procedures, and a geometric stronghold-localization method.
• The result demonstrates long-horizon code generation and multi-agent recovery, but its significance is limited by one successful run, Easy difficulty, privileged symbolic game state, a 22% program-error rate, and 605 deaths.

Experimental objective and contribution

The paper evaluates whether a small team of general-purpose coding agents can complete Minecraft’s full survival progression without a human-authored route, task decomposition, curriculum, skill library, or game-specific control layer. Four Gemini 4 Argon agents are placed in a newly generated Minecraft Java Edition 1.20.4 world on Easy difficulty and instructed only to defeat the Ender Dragon. Each agent controls one player by writing JavaScript programs executed through Mineflayer, communicates through in-game chat, and maintains private and shared persistent memory. A fifth instance acts as an Observer, verifying claims against the program traces and server logs without participating in gameplay.

The central result is explicit: the team defeated the Ender Dragon after 27 hours and 14 minutes, using 2,783 programs, 229 chat messages, and 605 deaths. The authors characterize this as the first reported end-to-end completion of Minecraft by AI agents using only the standard Mineflayer library, without a pre-scouted seed or human-written Minecraft-specific tools (2610.22319). The result is consequential primarily as a systems demonstration of sustained execution over a long dependency chain. It does not establish high reliability, human-level gameplay, or general competence under more restrictive perception and control conditions.

The run traversed thirteen dependent milestones, beginning with bare-hand resource collection and ending with the dragon’s defeat. The milestones span Overworld resource acquisition, Nether exploration, blaze and ender-pearl collection, stronghold localization, portal activation, End traversal, crystal destruction, and the final combat sequence.

Figure 1: The four agents’ progression through thirteen dependent milestones from initial spawn to the Ender Dragon over 27 hours and 14 minutes.

The result extends prior Minecraft research in a different direction from policy learning and game-specific planning. MineRL, VPT, DreamerV3, SIMA, Voyager, JARVIS-1, and related systems rely on demonstrations, learned policies, explicit planners, domain knowledge, or reusable skill libraries. In contrast, this experiment tests whether a general-purpose coding agent can synthesize executable behavior, maintain state across thousands of short programs, and coordinate with other agents using only a relatively low-level software interface. The comparison is therefore not a controlled benchmark comparison with those systems; it is a change in the evaluated capability profile.

Agent–environment interface

The agents do not observe rendered pixels or issue keyboard and mouse commands. Instead, each writes a JavaScript program whose body receives a Mineflayer bot. Programs can inspect the player’s position, health, inventory, nearby blocks and entities, and other game state, and can invoke actions such as walking, mining, placing blocks, crafting, attacking, and using items. The pathfinding plugin handles route planning around obstacles. The agent receives textual program output and then writes another program.

This interface materially simplifies perception and navigation. Mineflayer exposes exact symbolic state, including information behind solid blocks and internal properties of entities that are unavailable to human players through ordinary visual observation. The agents can also inspect the dragon’s behavioral state and health. Consequently, the experiment measures long-horizon code generation and multi-agent coordination under a privileged state representation, rather than general Minecraft play under human-equivalent observation.

The program granularity is important. A program typically executes for only a short interval: the median runtime was 33.5 seconds, and each player had a program running approximately 40% of the time. The remaining time was spent reading outputs, reasoning, and generating the next program. This produces a recurrent observe–act–verify loop rather than a continuously running policy.

Figure 2: Each agent writes a JavaScript program, executes it through a Mineflayer bot, and receives textual state and outcome information while sharing chat and memory with the other agents.

The agents were allowed to use Node.js built-ins and installed Mineflayer packages, but could not start processes or write files from their in-game programs. Persistent global state was available across program invocations. All programs, outputs, messages, deaths, advancements, and server events were logged. The authors report that none of the 2,839 programs executed during the broader session made a network request or referred to a web source, and that the run contained no server commands.

The experimental instructions are intentionally sparse. The environment description explains how to run code, how chat and logs work, and where Mineflayer documentation is available. It does not specify a game strategy. General instructions require the agents to inspect the environment, verify actions, construct reusable tools, record lessons, preserve important context across compaction, and report outcomes honestly. Thus, the experimental setting supplies general software-engineering scaffolding but leaves the operational decomposition of Minecraft to the agents.

Execution of the 27-hour task

The run exhibits a recognizable progression from parallel resource gathering to increasingly specialized coordination. Within ten minutes, the agents negotiated roles through chat. gyldenia focused on food, beds, and flint; bulicame pursued diamonds; janesick handled iron smelting and tools; and auratian prepared the Nether portal. Within approximately two hours, the group had acquired iron tools, diamonds, and a functioning portal.

The early division of labor reduced contention over resources and allowed multiple prerequisites to be pursued concurrently. This specialization was not hard-coded: it emerged from chat interactions and subsequently remained sufficiently stable to structure the run. The result supports a narrower claim than “multi-agent cooperation” in general: shared communication and persistent state were sufficient for the agents to form and exploit a task decomposition in this particular environment.

Figure 3: The complete run, showing programs, chat messages, advancements, deaths, and six server restarts across the four player lanes.

The Nether phase exposed the cost of unreliable execution. The agents constructed shelters to collect ender pearls from Endermen and located a blaze spawner in a fortress. Five and a half hours into the run, they had accumulated 15 ender pearls in a shared chest. Returning blaze powder to the Overworld was substantially more difficult: one agent died while carrying twelve blaze powder, and a Ghast destroyed dropped items. These failures led to explicit operational rules in shared chat, including practices for protecting or recovering valuable resources.

This sequence illustrates a useful property of the system: failures were not merely repeated; some were converted into shared procedural knowledge. However, the paper does not provide a formal measure of whether the resulting rules improved expected success rates, nor does it compare performance with and without shared memory. The evidence is therefore qualitative and trace-based.

Stronghold localization and failure recovery

The stronghold search demonstrates the agents’ capacity to translate game mechanics into a quantitative procedure. janesick threw Eyes of Ender from two locations, sampled their trajectories every 50 milliseconds, and intersected the resulting rays. The estimated intersection was approximately 1.3 kilometers from the village and only 43 meters from the actual portal room.

Figure 4: The thirteen dependent milestones, with the time at which the team first reached each milestone and the agent responsible.

This episode is a particularly clear example of code synthesis serving as an instrument for state estimation. Rather than searching the terrain exhaustively, the agent implemented geometric triangulation from observations generated by the game. The procedure was not supplied by the environment-specific prompt, although the agent’s prior knowledge of Minecraft mechanics is an acknowledged limitation.

The subsequent item-recovery episode shows coordination under a sharply time-bounded failure. auratian drowned while carrying all twelve Eyes of Ender, approximately eight meters from bulicame. janesick and auratian transmitted the location and despawn deadline, allowing bulicame to recover the entire set with two and a half minutes remaining. This was not simply resource sharing; it required maintaining a sufficiently accurate spatial and temporal model of another agent’s death state.

Figure 5: The team’s response when auratian drowned while carrying all twelve Eyes of Ender, including the recovery location and despawn deadline.

At 13 hours and 17 minutes, the team reported the End portal activated with all twelve eyes installed. The portal milestone marks the transition from resource logistics to a combat problem in which the agents had to infer the dragon’s mechanics through repeated failures.

Learning the End encounter

The End consumed nearly half of the total runtime. The dragon killed the team 69 times, and the agents developed operational rules between attempts. They learned not to wait on the arrival platform, to approach the dragon only while it was perched, and to leave the End when the dragon became stuck so that the dimension could reset. The agents deliberately used deaths to return to the Overworld and coordinated an approximately six-minute interval in which all four players exited the End.

Figure 6: Rules developed between End attempts, including resetting a stuck dragon and approaching only during its perch phase.

The decisive diagnosis came approximately 21 hours into the run. auratian identified the ten healing crystals on the obsidian pillars as the reason the dragon repeatedly returned to full health. The agent then found that the crystals could be reached by stacking dirt beside the pillars and punching them, eliminating the need for a pickaxe. Over the following four hours and forty minutes, the team destroyed all ten crystals. The dragon died 39 minutes after the final crystal was removed, with bulicame reduced to 2.5 of the dragon’s 20 health points.

Figure 7: The ten End crystals destroyed by the agents and the dragon’s health trajectory during the final fight.

This result demonstrates iterative diagnosis rather than efficient planning. The team eventually identified the dominant bottleneck, but only after 69 deaths and approximately 14 hours in the End. The agents’ ability to inspect internal game state likely contributed materially to the diagnosis. Accordingly, the episode supports the claim that agents can revise strategies through interaction, but it also shows that autonomous debugging remained highly inefficient.

Emergent coordination and software reuse

The paper analyzes 229 pre-win chat messages and identifies several behaviors that emerged without explicit role instructions. First, the agents specialized. gyldenia gathered supplies and destroyed six crystals; janesick made tools, located the fortress, and triangulated the stronghold; auratian lit the portal and developed the crystal strategy; and bulicame contributed to Enderman shelters and delivered the final attack.

Second, they developed shared memory. Coordinates of chests, portals, dangers, and useful mechanics were recorded for the team. A Mineflayer crafting quirk identified by gyldenia 19 minutes into the run led to a helper function that appears in 655 programs written by all four agents. This is a strong indication that shared memory can propagate implementation-level knowledge across independently running coding agents.

Third, the agents built and reused their own tools. The run preserved 146 pieces of state and code, including 42 helper functions. These included background loops for remaining afloat, timed walking, item counting, and cancellation of stale code after timeouts. The authors report that these utilities were referenced in 1,519 programs. The implication is that persistent code artifacts reduced repeated implementation effort, but the paper does not isolate their causal effect on completion time.

Fourth, agents corrected false or premature claims. When auratian’s program announced a success that had not occurred, auratian retracted the claim two minutes later, identifying an “unguarded script branch.” When janesick reported returning with blaze powder after having died, gyldenia flagged the contradiction within three minutes. These examples are relevant to multi-agent reliability because the chat channel functioned not only as a coordination mechanism but also as a peer-verification layer.

Figure 8: Examples of emergent specialization, shared memory, reusable helpers, peer correction, and the causes of the 605 deaths.

The failure distribution reinforces the gap between eventual completion and robust execution. Twenty-two percent of programs ended in an error, and most deaths were attributed to monsters. The system therefore achieved persistence through repeated recovery rather than through a low-error control policy.

Verification and resource cost

The authors provide unusually complete traceability for a single autonomous run. Every program and output, all chat messages, and the full Minecraft server log were recorded. The win is independently represented by the server’s advancement event [Free the End], awarded to bulicame 27 hours and 14 minutes after the first program. No program used a server command. The Observer agent checked player claims against the recorded state, and the authors report no specification gaming or safety incident.

This verification architecture is important because the agents themselves occasionally produced inaccurate success reports. The advancement event, rather than the agents’ textual claims, provides the decisive success criterion. The paper’s evidence is consequently stronger than a narrative based solely on model-generated logs, although the single-run design still prevents estimation of the probability of success.

The computational cost was approximately 1.35 billion input tokens, 91% served from context cache, and 16 million output tokens, including 4 million thinking tokens, over roughly 24,000 model calls. Using the reported introductory Gemini 4 Argon API list price, the pre-win cost was approximately $520**, or **$1,040 at the standard price. Including the Observer and post-win activity, the total was approximately $810**, or **$1,620 at standard pricing. These are list-price estimates rather than measured serving costs, and they exclude broader infrastructure and engineering costs.

The cost figures qualify the practical significance of the result. The team succeeded with a relatively modest direct API expenditure, but it required more than a day, thousands of programs, hundreds of deaths, and extensive context processing. The relevant efficiency metric is therefore not merely monetary cost per win; it includes wall-clock latency, failure rate, supervision infrastructure, and the probability of success across independent runs.

Limitations and open questions

The strongest limitations concern ecological validity and statistical reliability. Mineflayer provides symbolic environmental state, pathfinding, and access to internal entity information. This is substantially easier than pixel-based perception and keyboard–mouse control. The agents also played on Easy difficulty, where hostile mobs deal less damage and hunger cannot kill the player. Their prior knowledge of Minecraft and Mineflayer is substantial, so the experiment evaluates the deployment of memorized domain knowledge through code rather than learning Minecraft from scratch.

The run was a single successful launch. It does not establish a success probability, variance in completion time, or sensitivity to world seed. The six server restarts interrupted execution for approximately 20 minutes, introducing infrastructure effects that are not part of the agents’ gameplay strategy. In addition, 605 deaths, a 22% program-error rate, and nearly 14 hours spent fighting the dragon indicate that the system’s behavior was highly failure-prone even under the relatively favorable interface.

The comparison with prior work also requires care. Earlier systems often use pixels, learned policies, domain-specific planners, curricula, or skill libraries, whereas this paper intentionally minimizes human-authored Minecraft-specific structure. The resulting achievement is therefore not a direct superiority claim over those systems. It instead establishes a different point in the design space: general-purpose coding agents can solve a long-horizon interactive task using a standard programmable interface and endogenous tool construction.

Several empirical questions remain open within the paper’s scope. It is unknown how much performance would degrade under Normal or Hard difficulty, pixel observations, restricted access to internal game state, or a Mineflayer interface without pathfinding. It is also unknown whether the emergent roles and shared-memory practices recur across seeds and independent trials, whether a smaller team would be more efficient, and whether the observed software reuse improves reliability or merely accumulates brittle state. Finally, the experiment does not determine whether the same coordination protocol transfers to tasks whose state cannot be inspected as cleanly as Minecraft’s.

Conclusion

The paper reports a complete autonomous Minecraft run by four general-purpose coding agents operating through Mineflayer, shared chat, and persistent memory. The agents generated 2,783 programs, recovered from 605 deaths, developed reusable tools and coordination practices, and defeated the Ender Dragon after 27 hours and 14 minutes. The principal contribution is an end-to-end demonstration of long-horizon code-based agency under sparse task specification.

The result is best interpreted as evidence that general-purpose agents can sustain a coherent objective across thousands of dependent actions while dynamically allocating work, debugging programs, sharing state, and recovering from failures. Its limitations are equally central: privileged symbolic access, Easy difficulty, extensive prior knowledge, high error rates, and a single successful run. The paper therefore establishes a demanding systems demonstration, while leaving reliability, transfer, and performance under human-equivalent interfaces unresolved (2610.22319).