Ein Creeper reichte, um Astras 141-Stunden-Lauf auf Kartoffel-Anbau zu reduzieren. Was der Harness erlaubt – Portal friert, Mineflayer zeigt Blöcke hinter Fels, Vorwissen verzerrt –, entscheidet das Ergebnis.

Google DeepMindは、GoogleのAIモデル「Gemini 4 Argon」を搭載した4つのAIエージェントが、人間の介入を一切受けることなく、マインクラフトのクリアに成功したというチャレンジ結果を公開しました。この挑戦は、AIエージェントが複雑な環境下で、自律的に計画を立て、協調してタスクを遂行する能力を検証するものです。 AIエージェントによる自律的なゲームクリアのプロセス 今回のチャレンジでは、AIエージェントがマインクラフトのボット用ライブラリである「Mineflayer」を活用し、ゲーム内での移動、採掘、戦闘などの操作を行いました。エージェントは、JavaScriptを…

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 …

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 …

Four Gemini 4 Argon agents just defeated the Ender Dragon in Minecraft survival mode without human intervention. They wrote 2,783 programs, died 605 times, and ran for 27 hours straight. No pre-assigned roles, no hand-written game logic, no human debugging. Just four agents, the Mineflayer library, shared memory, and in-game chat. This is not a demo. It is a stress test for multi-agent orchestration in a complex, long-running environment where state diverges, tools break, and coordination failures cascade. The plumbing matters more than the milestone. ## The Setup: Four Agents, One Goal, Zero Orchestrator Each agent controlled a Minecraft player through Mineflayer, an open-source Node.js library that exposes game state and player actions as JavaScript APIs. The agents could: * Read world state (inventory, health, nearby blocks, entities) * Execute actions (move, mine, craft, attack) * Send and receive in-game chat messages * Access a shared memory store The task: defeat the Ender Dragon. This requires mining resources, crafting tools, building a base, finding a stronghold, activating an End portal, and fighting the dragon. Hundreds of dependent steps across a randomly generated world. The researchers provided a live dashboard for observability but never intervened. The agents planned, coded, debugged, and recovered from failures autonomously. ## Coordination Without a Central Orchestrator Most multi-agent systems use a supervisor or coordinator to assign tasks and resolve conflicts. This setup had none. Agents coordinated through two channels: **In-game chat** : Agents broadcast intentions, request help, and share discoveries. Chat is asynchronous, lossy (agents can miss messages), and unstructured. No protocol enforcement. **Shared memory** : A key-value store accessible to all agents. Used for persistent state like base location, resource counts, and task assignments. Roles emerged organically. One agent focused on mining, another on crafting, a third on exploration. No explicit role assignment. The agents negotiated through chat and adjusted based on what others were doing. ### The Failure Modes This coordination model creates predictable failure modes: * **Stale reads** : Agent A reads shared memory, Agent B updates it, Agent A acts on outdated state. * **Race conditions** : Two agents decide to craft the same item because they both read the same resource count. * **Chat overload** : As agents generate more messages, critical information gets buried. * **Role drift** : An agent switches tasks mid-stream, leaving dependencies unmet. The paper does not detail how often these occurred, but 605 deaths and 27 hours of runtime suggest they were frequent. ## Mineflayer as a Tool Boundary Mineflayer abstracts Minecraft's protocol into JavaScript functions. For example: // Move to coordinates await bot.pathfinder.goto(new goals.GoalBlock(x, y, z)); // Mine a block await bot.dig(block); // Craft an item await bot.craft(recipe, count); This abstraction is both a strength and a constraint. **Strength** : Agents do not need to understand Minecraft's network protocol or low-level game mechanics. They call high-level functions and Mineflayer handles the rest. **Constraint** : Mineflayer's API defines what agents can perceive and do. If the library does not expose a game feature, agents cannot use it. If a function has a bug, agents inherit that bug. ### Tool Boundary Lessons 1. **Abstraction leaks** : Pathfinding can fail if the world generates unexpected terrain. Agents must detect and recover from these failures. 2. **Async hell** : Many Mineflayer functions are async. Agents must manage promises, handle timeouts, and retry on failure. 3. **State synchronization** : Mineflayer maintains local state (inventory, position). If this state diverges from the server, agents make bad decisions. The agents wrote 2,783 programs. Many of those programs were likely bug fixes for edge cases in Mineflayer or their own code. ## Shared Memory Architecture The paper does not specify the shared memory implementation, but we can infer constraints: * **Read-heavy** : Agents frequently check base location, resource counts, and task status. * **Write-light** : Updates happen when resources are deposited, tasks are completed, or plans change. * **No transactions** : Agents do not lock memory during multi-step operations. This creates race conditions. A likely architecture: Component | Implementation | Trade-off ---|---|--- Store | In-memory key-value (Redis, dict) | Fast reads, no durability Consistency | Eventually consistent | Stale reads possible, no coordination overhead Conflict resolution | Last-write-wins | Simple, but agents can overwrite each other Schema | Unstructured JSON | Flexible, but no validation This design prioritizes speed and simplicity over correctness. Acceptable for a research demo, problematic for production. ### What Production Would Need * **Versioned writes** : Agents include a version number with updates. Conflicts are detected and resolved. * **Event log** : All state changes are appended to a log. Agents can replay history to debug divergence. * **Schema validation** : Enforce structure on shared memory to prevent agents from writing malformed data. * **Access control** : Limit which agents can write to which keys to prevent accidental overwrites. ## Observability: The Missing Layer The researchers had a live dashboard. The paper does not describe what it showed, but here is what you would need to debug four agents running for 27 hours: **Per-agent metrics** : * Current task and subtasks * Inventory state * Health and position * Recent chat messages sent and received * Programs written and executed * Errors and retries **System-wide metrics** : * Shared memory state and update frequency * Task dependency graph * Resource flow (who mined what, who crafted what) * Death events and causes * Time spent on each major milestone **Trace correlation** : * Link chat messages to state changes * Link deaths to recent actions * Link program writes to execution outcomes Without this, debugging a 27-hour run is impossible. You cannot replay Minecraft deterministically, so observability must be real-time and comprehensive. ## Role Emergence: Coordination Through Imitation Agents did not receive role assignments. Roles emerged through observation and imitation. An agent sees another mining iron, infers that iron is needed, and starts mining coal instead to avoid duplication. This works when: * Agents can observe each other's actions (chat, shared memory, world state) * The task has natural parallelism (mining, crafting, exploring are independent) * Agents can recover from role conflicts (two agents mining the same resource is inefficient but not fatal) This fails when: * Dependencies are tight (Agent A needs Agent B to finish before starting) * Roles require sustained focus (switching tasks mid-stream wastes progress) * Coordination overhead exceeds task complexity (too much chat, not enough work) The 605 deaths suggest role conflicts were common. Agents likely duplicated work, left tasks incomplete, or failed to coordinate during combat. ## Security and Sandboxing The agents ran in a sandboxed Minecraft world. What does that mean? **Likely boundaries** : * Isolated server instance (no access to other worlds or servers) * Network restrictions (agents cannot call external APIs or exfiltrate data) * Resource limits (CPU, memory, disk to prevent runaway processes) * Code execution sandbox (agents write JavaScript, but execution is monitored) **Attack surface** : * Agents can grief each other (destroy blocks, steal items, attack) * Agents can write infinite loops or memory leaks * Agents can spam chat or shared memory * Agents can exploit Mineflayer bugs to crash the server The paper does not mention griefing or sabotage. Either the agents cooperated naturally, or the researchers filtered out failed runs where agents fought. ## Code Generation at Scale 2,783 programs in 27 hours is roughly one program every 35 seconds. Most were likely small scripts: mine 10 blocks, craft 5 torches, move to coordinates. But some were complex: pathfinding, combat logic, crafting chains. **Code quality challenges** : * **No tests** : Agents cannot write unit tests for Minecraft scripts. They test by running in the world. * **No version control** : Agents overwrite programs. If a new version breaks, they must rewrite from memory. * **No code review** : Agents do not review each other's code. Bugs propagate. This is closer to REPL-driven development than software engineering. Agents iterate quickly, accept failures, and move on. ## When This Approach Works Use multi-agent coordination without a central orchestrator when: * Tasks are naturally parallel and loosely coupled * Agents can observe each other's state and actions * Coordination overhead is low (chat, shared memory) * Failures are recoverable (deaths, bugs, conflicts) * You have strong observability to debug divergence Examples: distributed data processing, swarm robotics, collaborative editing. ## When This Approach Fails Avoid this approach when: * Tasks have tight dependencies and require strict ordering * Coordination overhead exceeds task complexity * Failures are catastrophic (financial transactions, safety-critical systems) * You cannot afford stale reads or race conditions * Observability is weak or missing Examples: database transactions, real-time trading, medical devices. ## Technical Verdict This is a research milestone, not a production pattern. Four agents defeated Minecraft through brute force: 605 deaths, 2,783 programs, 27 hours of runtime. The coordination model (chat + shared memory) is simple but fragile. Stale reads, race conditions, and role conflicts are inevitable. **Use this when** : * You need to explore multi-agent coordination in a sandbox * Failures are cheap and recoverable * You have strong observability * You can tolerate inefficiency in exchange for emergent behavior **Avoid this when** : * Correctness matters more than exploration * Coordination overhead is high * You cannot debug 27-hour runs * You need deterministic outcomes The real value is not the Ender Dragon. It is the evidence that agents can coordinate through simple primitives (chat, shared memory) in a complex environment. The plumbing is messy, but it works. ## Source Links * ArXiv Paper: A team of Gemini 4 Argon agents beats Minecraft * Mineflayer Library

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.

Create Minecraft bots with a powerful, stable, and high level JavaScript API. - PrismarineJS/mineflayer

Create Minecraft bots with a powerful, stable, and high level JavaScript API. - PrismarineJS/mineflayer