YC Labs Ran 50 AI Agents in Minecraft and Pitted GPT-6.1 Sol Against Opus 5.5 in Mindustry

YC Labs and Olam Labs have published a write-up of what happens when dozens of LLM agents share a game world: 50 GPT-6.1 Sol agents building a Minecraft colony, ten-versus-ten Bed Wars matches, and a seven-game Mindustry series. The headline result is that GPT-6.1 Sol agents coordinated like a hive and beat Claude Opus 5.5 teams 6 to 1 in Mindustry and 6 to 3 in Bed Wars, while the Claude teams were more deliberate, more democratic, and slower to adapt. The write-up is on the YC Labs games page and drew a Hacker News discussion the same day.

This is a behavioral study, not a leaderboard. But for anyone building multi-agent systems, the details about how teams of agents talk, vote, remember and fail are the useful part.

Update, October 30, 2026: YC's thread on X added detail on the Mindustry run, now folded into the Mindustry section below: the "+1" voting system lasted all ~9.5 hours, GPT agents split factory ownership from the first minutes, their shorthand kept compressing, and only GPT went looking for Mindustry's source code when games got close.

TL;DR: what the experiments found

How the harness works

The team built an open-source agent harness on Pi, using Mineflayer tools so that agents can act inside Minecraft. Each agent can observe the world, reason, remember, act, message other agents, and write and run scripts. In the colony run, agents also had an agent directory, a shared sandbox and direct messaging.

For Mindustry, an open-source factory-building and tower-defense game, the PvP mode makes two teams race to build an economy and an army and destroy the opposing core. Both teams got identical API access and no strategy instructions. The Mindustry environments and a multi-agent fork of the Harbor evaluation framework are published as Multi-Agent Mindustry and Multi-Agent Harbor, built on the upstream Harbor project.

Agents handing work into one shared tray as a metaphor for a multi-agent shared workspace

Civ50: what 50 agents did in three hours

In the Civ50 run, 50 GPT-6.1 Sol agents were dropped into a survival world with one goal. The authors report several things that will sound familiar to anyone who has run a large team of agents:

• Resource stripping. The agents cleared nearly all trees near spawn within 90 seconds.
• Emergent hierarchy from a list. Because the agent directory had a fixed order, the first agent, Ada, became the de facto leader and received 616 direct messages.
• Heavy chatter. The colony sent about 5,900 messages.
• Deaths and risk aversion. 34 agent deaths occurred, 22 of them on the first night, and agents became more cautious afterward.
• Rationing. A food system formed around one agent's ledger, with fishing as a key source; eleven agents wrote fishing scripts.
• Rules from incidents. After a cooked chicken was misdelivered and eaten by the wrong agent, the colony wrote a rule that rations go into named chests and are never tossed. The word "toss" appeared 7 times before the incident and 125 times after.
• Bureaucracy. Four agents spent 11 minutes appointing a "sole fertilizer operator" for a single piece of bone meal on one wheat block.

The takeaway is that agent societies copy human organizational failure modes quickly: single points of failure, process creep, and consensus overhead. Nothing in the prompt asked for a hierarchy; list order alone produced one. One commenter on Hacker News (yymir) wondered whether personality prompts would introduce "politics", which is exactly the sort of follow-up the authors list as an open question.

Bed Wars: GPT aggressive, Claude defensive

In nine 45-minute games, ten Claude Opus 5.5 agents played ten GPT-6.1 Sol agents with the instruction to win. GPT took the series 6-3.

According to the write-up, GPT agents farmed the center, bought upgrades and attacked with bridges, ranged weapons and Ender Pearl teleports. Claude played defensively and tried to win on kill count. That was a weak plan: in three of GPT's wins in the last two series, GPT broke Claude's bed with about three minutes left even though Claude led the kill count (63-16, 57-19 and 59-24).

Two further details stand out for builders:

1. A shared tool bug exposed different recovery habits. A block-breaking bug hit both teams. GPT diagnosed it and shared a workaround; several Claude agents concluded breaking was impossible.
2. Memory files did not equal learning. Claude agents wrote lessons into memory files but repeated the same mistakes. GPT left its memory files empty and warned teammates by direct message instead. This echoes the findings in the memory tax study, where memory systems underperformed simple retrieval.

Speech bubbles converging on one decision as a picture of agent teams reaching consensus

Mindustry: a hive versus a Slack channel

Mindustry is where the two styles showed most clearly. GPT-6.1 Sol in Codex played Claude Opus 5.5 in Claude Code across seven games, about 9.5 hours in all. Game 3 alone ran 4 hours 16 minutes. GPT won 6 to 1, and most games were close until the last two, which tilted toward GPT.

The authors' observations:

• Structure. YC summarised it in its thread as "Claudes generally established democracies, GPTs formed hives." GPT behaved like a hive: dense communication and more willingness to do routine work. Claude had a single leader and communicated like a human team on Slack.
• Ownership and sharing. In the seven-match run, GPT agents split factory ownership from the start and were very willing to send resources toward shared goals. They also communicated more than the Claude teams.
• Decisions. Claude operated on a "+1" system: its leader, who came to power after a dispute, and other agents needed many +1s in the team chat, with no disagreements, to pass a proposal. Claude held that system for the whole series of about 9.5 hours.
• Language. As matches went on, the GPT teams' wording kept getting more compressed. They invented their own words and strung many phrases together with no spaces. The authors saw no specialised language develop on the Claude side beyond ordinary colloquial English.
• Leadership. Claude never changed leaders, even after several losses in a row. In close games, individual GPT agents often took initiative on their own attacks or commanded parts of the army.
• Reading the source. Both teams had internet access and neither was told to use it. When a match got close, GPT agents started searching the web for Mindustry's open-source code, looking for advantages and information, and discussed what they found in team chat. Claude did not search for alternative advantages. The source was read only, not modified.
• Fixing a real mistake. After losing game 6 to a 24-zenith air strike, Claude found that 55 of its 74 anti-air duo turrets had been loaded with copper instead of graphite. In game 7 it built a ring of 207 graphite-fed duos that stopped the same strike. Even so, Claude lost game 7: GPT's core finished at 6000 of 6000 health and Claude's at 0.

The anti-air episode is the most honest part of the write-up: Claude did learn, but only after a loss that a quick ammo audit would have caught.

What this means for people building multi-agent systems

The authors conclude that the two experiments point the same way: GPT agents coordinated tightly, shared information heavily and took initiative when games were close, while Claude agents were more deliberate and democratic but slower to adapt, held defensive positions too long, and repeated mistakes despite written notes. Their reading is that multi-agent behavior depends on how a model tends to communicate and coordinate, not only on raw capability.

Practical readings, clearly our interpretation rather than the authors':

• Pick models for the role. If you run agent teams, communication style matters as much as single-agent scores. Compare against the Artificial Analysis index, which measures single-model intelligence, not team behavior.
• Fix list order and directory defaults. If a fixed ordering creates a leader, make the choice explicit.
• Cap process. Voting and appointment rituals burn tokens. Compare cost data in the Spawn ten-person agent company write-up.
• Verify memory loops. Writing lessons down is not applying them. Test that notes change behavior.
• Share tools and sources. The GPT team read the game source and shared a workaround for a bug; those habits transfer to coding agents too, as in Claude Code studio templates with dozens of agents.

If you want to know which GPT-6 variant is which, see our guide to the Luna, Terra, Sol and Astra names. For a related safety angle on agents that act on their own, see OpenAI's report of coding agents weakening monitoring, and for cross-model agent cooperation research see Swarm Telepathy.

What developers are saying

The Hacker News thread had about 20 comments at the time of writing, and the substance was mixed.

• One commenter, grenoire, observed that the Minecraft agents seemed to act almost turn by turn, and wondered whether three hours and an open format gave too little incentive to be reactive; they noted Bed Wars looked similar despite the time pressure.
• MatthiasPortzel argued that Minecraft is less an intelligence problem than a control one, since a human can click several times a second and Mineflayer exposes a different, limited interface.
• Another commenter, manofmanysmiles, asked about human-plus-AI versus human-plus-AI real-time strategy matches where writing your own harness is allowed.
• A design complaint about the page's style also drew replies; we leave that aside.
• On X, replies to YC's thread were mostly jokes about the Civ50 colony inventing permits and rationing before it solved food, such as "even the bots couldn't escape bureaucracy." Treat these as reactions, not findings.

These are individual reports, not verified findings.

Limits and caveats

Seven Mindustry games and nine Bed Wars games are a small sample, there was one prompt per task, and the two models ran in different harnesses (Codex versus Claude Code), so harness differences are mixed in with model differences. The write-up does not report statistical tests, and the Civ50 run used GPT-6.1 Sol only, so there is no Claude colony to compare against. The authors themselves list open questions: mixing model families, how team composition changes hierarchies, whether many weaker agents can beat fewer stronger ones, and how communication limits change outcomes.

How to try it yourself

1. Clone the Multi-Agent Mindustry and Multi-Agent Harbor repositories linked above.
2. Start with a short game and identical API access for both teams, as the authors did.
3. Log message counts per agent and per pair; the 616-DM leader effect is easy to spot in logs.
4. Run each pairing several times before drawing conclusions.

For agent safety work, do not run swarms with real credentials; for guardrails on coding agents, see AgentBeam.

Related reading

• Which GPT-6 model to pick: Luna, Terra, Sol, Astra
• Artificial Analysis Intelligence Index v5 and Opus 5.5
• Swarm Telepathy: KV-cache transfer across model families
• The memory tax: agent memory vs naive RAG
• Spawn: a ten-person company run by an agent fleet
• Claude Code Game Studios template
• OpenAI coding agents weakening misalignment monitoring

Details are accurate as of October 29, 2026; the experiments and repositories may change.