Gemini 4 Agents Beat Minecraft 2026: What Google Just Proved

Google DeepMind says a team of four Gemini 4 agents beat Minecraft on their own. They started in a fresh survival world and finished by killing the Ender Dragon, with no human steering at any point. The headline sounds like a stunt, but the method matters more than the trophy. The agents never looked at the screen. They wrote code, divided up the work in chat, and kept shared notes for 27 straight hours. Builders are trying to get that same loop working for real multi-step jobs. This is the clearest public sign yet of how far long-horizon AI agents have come in 2026.

What’s actually new with Gemini 4 agents

On October 16, 2026, Google DeepMind announced on X that four instances of Gemini 4 Argon, run as coding agents, defeated the Ender Dragon in a sandboxed Minecraft survival world. The run took 27 hours, and the agents wrote 2,783 programs of their own to control the game. Researchers watched but did not step in to fix plans, rescue stuck agents, or give hints.

The setup shows what was really tested. The game ran on Easy difficulty. The agents worked through a text-and-code interface, not pixels. An API told them which blocks and creatures were nearby, and a route-planning plugin handled pathfinding around obstacles. This was not a vision benchmark or a reflex test. It tested planning, delegation, coding, and self-correction over a long horizon. The run covered gathering resources, crafting tools, finding diamonds, building a Nether portal, collecting blaze rods and ender pearls, locating the stronghold, and the final fight.

Coordination is the new part. Earlier Minecraft agents were usually a single model in a loop. Here the four agents split tasks over chat, logged what worked and what failed in shared notes, and debugged each other’s code. That is a multi-agent system holding up for more than a full day without a person resetting it. DeepMind has not said whether “Argon” is a public API model, an internal variant, or a preview tier. Treat it as a research result until Google publishes a model card.

Why it matters

• Long-horizon planning is improving fast. Beating Minecraft takes hundreds of dependent steps, and an early mistake (no iron, no portal) blocks everything after it. Agents that recover from those mistakes without help are the main thing separating demo agents from production agents.
• Code as the action space wins. 2,783 programs means the agents mostly wrote and reused skills instead of issuing one click at a time. The lesson for builders: give agents tools and a place to save code, not a raw UI.
• Shared memory beats bigger context. The agents coordinated through notes and chat, not one huge prompt. A shared external scratchpad is a cheap pattern you can copy today with any model.
• Good scaffolding is design, not cheating. The block API and pathfinding plugin did a lot of work. Real agent deployments look the same: the model plans, and deterministic tools handle the parts that need precision.
• Multi-agent setups are now practical. Splitting work across four agents with roles and handoffs is the likely shape of the Gemini 4 agent products that reach developers next.
• Watch the caveats. Easy difficulty, a sandbox, and a text interface make the task far simpler than a human playing on Hard with a mouse. Match your expectations to what was actually shown.

How to use Gemini 4 agents today

You can’t run Argon yourself yet. You can build the same architecture now on the Gemini API: tools, shared notes, a skill library, and a supervisor loop. When Gemini 4 model IDs appear in your account, you change one string.

1. Install the SDK and set your key. Get a free key from Google AI Studio. The free tier is enough to prototype.

   pip install -U google-genai
   export GEMINI_API_KEY="your-key-here"

2. Check which models you can access. Don’t guess model IDs. List them, and look for Gemini 4 entries as they roll out.

   from google import genai
   
   client = genai.Client()
   for m in client.models.list():
       print(m.name)

3. Give the agent tools and a shared notebook. This is the core of the Minecraft setup: the agent acts through functions and records what it learns. The SDK’s automatic function calling turns plain Python functions into tools.

   import pathlib, subprocess
   from google import genai
   from google.genai import types
   
   client = genai.Client()
   MODEL = "gemini-2.5-flash"  # swap in a Gemini 4 model ID when it appears in your list
   
   NOTES = pathlib.Path("shared_notes.md")
   SKILLS = pathlib.Path("skills")
   SKILLS.mkdir(exist_ok=True)
   
   def read_notes() -> str:
       """Return the team's shared notes: decisions, findings, known failures."""
       return NOTES.read_text() if NOTES.exists() else "(empty)"
   
   def append_note(note: str) -> str:
       """Append one short finding or decision to the shared notes."""
       with NOTES.open("a") as f:
           f.write(f"- {note}\n")
       return "saved"
   
   def save_skill(name: str, code: str) -> str:
       """Save a reusable Python function to the skill library."""
       (SKILLS / f"{name}.py").write_text(code)
       return f"saved skills/{name}.py"
   
   def run_skill(name: str) -> str:
       """Run a saved skill and return its output or error (last 2000 chars)."""
       r = subprocess.run(["python", str(SKILLS / f"{name}.py")],
                          capture_output=True, text=True, timeout=120)
       return (r.stdout + r.stderr)[-2000:]
   
   config = types.GenerateContentConfig(
       system_instruction=open("planner_prompt.txt").read(),
       tools=[read_notes, append_note, save_skill, run_skill],
   )
   chat = client.chats.create(model=MODEL, config=config)
   print(chat.send_message("Goal: produce a cleaned, deduplicated CSV from ./raw/. Start.").text)

4. Write a planner prompt that forces milestones. Long-horizon agents fail when they lose track of the goal. Make them break it into a dependency chain and check progress against it.

   You are one agent on a team working toward a long goal.
   Rules:
   1. Before acting, call read_notes. Never redo work already marked DONE.
   2. Break the goal into ordered milestones. Each milestone must have a check
      you can verify with a tool.
   3. Prefer writing a reusable skill (save_skill) over one-off actions.
   4. After every attempt, append_note with: milestone, result, and the
      cause of any failure in one line.
   5. If the same approach fails twice, change strategy and note why.
   6. Stop only when every milestone check passes. Report what you verified.

5. Split the work across roles. DeepMind used four agents. Start with two or three roles that share one notes file. A simple supervisor loop works fine.

   ROLES = {
       "planner":  "Own the milestone list. Assign the next task in notes.",
       "builder":  "Write and save skills for the assigned task.",
       "reviewer": "Run skills, find bugs, append fixes needed to notes.",
   }
   
   agents = {
       role: client.chats.create(
           model=MODEL,
           config=types.GenerateContentConfig(
               system_instruction=open("planner_prompt.txt").read() + "\nRole: " + desc,
               tools=[read_notes, append_note, save_skill, run_skill],
           ),
       )
       for role, desc in ROLES.items()
   }
   
   for step in range(20):
       for role, chat in agents.items():
           reply = chat.send_message(f"Step {step}. Read notes and do your role.")
           print(f"[{role}] {reply.text[:300]}")
       if "ALL MILESTONES VERIFIED" in read_notes():
           break

6. Try Minecraft yourself. The open-source Mineflayer library and its pathfinder plugin give you a text-and-code interface close to the one in the DeepMind run. Point a local server at a test world and expose bot actions as tools.

   npm install mineflayer mineflayer-pathfinder

7. Add guardrails before you scale. Cap steps and tokens, sandbox code execution in a container or VM (not your home directory), log every tool call, and require human approval for anything that spends money or touches production data. The DeepMind run used a sandbox for a reason.

How Gemini 4 agents compare with earlier Minecraft AI

Minecraft has been an AI benchmark for years. Here is where this result sits against the best-known earlier attempts.

System	Year	Approach	Interface	Best milestone
Gemini 4 Argon agents (Google DeepMind)	2026	Four cooperating LLM coding agents, shared notes	Text and code via API, pathfinding plugin	Defeated the Ender Dragon (Easy) in 27 hours
Voyager (NVIDIA and collaborators)	2023	Single GPT-4 agent with a skill library of code	Mineflayer JavaScript API	Diamond tools; did not finish the game
VPT (OpenAI)	2022	Video pretraining plus reinforcement learning	Pixels, keyboard and mouse	Crafted a diamond pickaxe
DreamerV3 (Google DeepMind)	2023	World-model reinforcement learning, no human data	Pixels, simplified actions	Collected diamonds from scratch

The pixel-based systems tackled a harder perception problem. The Gemini 4 run tackled a much harder planning problem. Those are different benchmarks. For builders, the planning result matters more, because most business workflows already have APIs and need no vision.

What’s next

Watch availability first. If Gemini 4 Argon, or its public successor, ships in the Gemini API and Vertex AI with the multi-agent tooling DeepMind used, expect Google to package it as managed agents with built-in memory, code execution, and handoffs. A model card or technical report will reveal token costs, how often the agents got stuck, and how much the scaffolding contributed relative to the model.

Next, watch for harder versions of the test. Easy difficulty with a block-detection API is a solid first step. The next credible claims will involve Normal or Hard difficulty, pixel-only input, or a much shorter run. Expect other labs to answer with their own long-horizon showcases, since autonomous AI agents are now judged on how long they work without a person, not on one-shot answers.

Finally, watch the move from games to work. Milestone planning, code-based skills, shared notes, and peer debugging are exactly what data pipelines, codebase migrations, research tasks, and back-office automation need. Build the scaffolding now on today’s models, measure where your agents get stuck, and swap in Gemini 4 the day it ships.

Frequently Asked Questions

Did Gemini 4 agents really beat Minecraft with no human help?

According to Google DeepMind, yes. Four Gemini 4 Argon agents defeated the Ender Dragon in a sandboxed survival world after 27 hours, and researchers monitored the run without steering it. The run used Easy difficulty and a text-and-code interface, which made the task simpler than normal human play.

Did the agents see the game screen?

No. They worked through code and text. An API reported nearby blocks and creatures, and a plugin handled route planning. The agents wrote 2,783 programs to act in the world, so this tested planning and coding, not vision.

Can I use Gemini 4 Argon through the API today?

Google has not confirmed public access to the Argon variant. You can build the same architecture today on the Gemini API with current models, then switch the model ID when Gemini 4 models appear in your model list.

How do I start using Gemini 4 agents for real work?

Give the model tools, not a UI. Keep a shared notes file the agents read and write. Make them break goals into verifiable milestones and save reusable code as skills. Start with two or three roles, sandbox all code execution, and cap steps and tokens before you scale.

How is this different from Voyager or OpenAI’s VPT?

Voyager used a single GPT-4 agent and reached diamond tools. VPT learned from video and used keyboard and mouse to craft a diamond pickaxe. The Gemini 4 run is the first of these to finish the game, and it did so with several cooperating agents. It also relied on more scaffolding and an easier difficulty setting.

What does this mean for long-horizon AI agents outside of games?

Agents can now pursue one goal across hundreds of dependent steps, recover from failures, and coordinate with each other for more than a day. That carries over directly to multi-step business workflows. Copy the milestone checks, shared memory, and code-based skills.