Agent Upstart

Cool things people are building with agents — and practical help getting the most out of them.

Playbooks · Coding tasks

Fifty agents built a bureaucracy; four beat the game

Written November 4, 2026

Two experiments ran agents loose in Minecraft and got opposite outcomes: fifty agents that organized themselves into paperwork, and four agents that finished the hardest task in the game. The difference was not intelligence. It was the goal, the team size, and what the agents were given to work with.

The civilization that organized itself to a standstill

In October 2026, YC Labs, with Olam Labs, put 50 GPT-6.1 Sol agents into one survival Minecraft world for three hours, with one instruction: build a thriving civilization. The agents had an agent directory, a shared sandbox, and direct messages. They exchanged about 5,900 messages. A hierarchy formed before anything else did, and it formed on the order of names in the directory: Ada, listed first, became the de facto leader, received 616 direct messages, and was never voted in, elected, or challenged. 46 of the other 49 agents sent their first message to Ada.

The colony then organized. A ration ledger appeared, then written rules, then permits, then appointed operators. Four agents spent eleven minutes appointing a sole fertilizer operator for a single piece of bone meal on a single wheat block. Other roles included a fishing shift, a rod holder, and a hub steward, and agents asked permission to remove grass. Meanwhile, the world did not wait: 34 agents died, 22 of them on the first night, and the survivors grew risk-averse, huddling in lit shelters. By the end, YC Labs reports, the colony had shifted to one focused on food and survival, and food production was not established. The agents were not idle; they were busy. The work they chose was the work of governing themselves.

The same program ran two competitive games, and the results there complicate any simple reading of one model beating another. In Bed Wars, 10 GPT-6.1 Sol agents beat 10 Claude Opus 5.5 agents 6–3 across nine 45-minute games. In Mindustry, GPT-6.1 Sol running in Codex beat Claude Opus 5.5 running in Claude Code 6–1 across seven games over about nine and a half hours. The harness is open source, but the games and the civilization run are not the same kind of test: a timed match with a score, and an open-ended world with one sentence of instruction, measure different things. YC Labs calls the tendency toward bureaucracy a tendency, observed once, in one run, under one set of starting conditions. A single run cannot show whether the outcome is typical, and the directory-order leadership may be an artifact of how the agents were introduced rather than a property of agent teams in general. Treat it as a warning about what unstructured multi-agent setups produce, not as a law about coordination.

The four agents that finished the game

The other experiment, reported in a preprint submitted in October 2026 by Faldor, Singh, and Raileanu, gave four Gemini 4 Argon agents a sandboxed Minecraft survival world and one goal: defeat the Ender Dragon. The agents ran through the standard Mineflayer library, talked to each other in game chat, and shared a memory. No roles were assigned, and no game logic was written by humans. The world was randomly generated, the difficulty was Easy, and the agents wrote 2,783 programs in the course of the run. They defeated the dragon after 27 hours and 14 minutes, and died 605 times on the way. The authors describe it as, to their knowledge, the first end-to-end autonomous completion of Minecraft by AI agents, using only the standard Mineflayer library without pre-scouted seeds or other game-specific tools written by humans.

The limits are stated in the paper itself. It was a single run, and a single run cannot show reliability: the same setup run again could fail, or finish faster, and nothing in one completion tells you which. The agents had a single, checkable win condition, a shared memory, and 27 hours to spend on it, with no competing instruction and no open-ended brief to interpret. The 605 deaths are part of the result, not a footnote to it: the agents kept recovering, getting fresh equipment, and trying again, and the run is a story about persistence inside a narrow task as much as about planning.

What the two runs do not prove together

Nothing here is a head-to-head comparison, and no conclusion should be drawn as if it were. The goals differed: an open-ended civilization with no definition of success, against a single boss fight with a binary outcome. The models differed: GPT-6.1 Sol against Gemini 4 Argon. The harnesses differed: YC's directory, sandbox, and messaging setup against Mineflayer, game chat, and shared memory. The run lengths differed by a factor of nine. The fifty agents had three hours and each other; the four agents had more than a day and a memory that outlived any one of them. Any sentence of the form "more agents are worse" or "fewer agents are better" ignores all of that at once. What the pair shows, honestly stated, is two separate observations: an unstructured team of fifty, given an open brief and a directory, spent its effort on self-organization; a team of four, given one checkable goal, shared memory, and a day, kept going until it finished. The interesting question for a builder is not which number of agents wins, but which setup produced which behaviour, and the two runs point at different answers to that question.

What to take into your own multi-agent work

  1. Write the win condition before adding an agent. The four-agent run had one: the dragon, defeated. The fifty-agent run had a sentence: a thriving civilization. If your task cannot be checked, the agents will check something else, and self-organization is a ready-made substitute for progress.
  2. Do not let directory order choose the leader. In the fifty-agent run, the first name in the directory became the leader, received most of the messages, and was never challenged. If a run needs a leader, name one deliberately and give the role a way to be questioned or replaced. If it does not need one, say so, and give each agent a task rather than a hierarchy to negotiate.
  3. Cap the permission layer. Permits, ledgers, and appointed operators are work that feels like progress and consumes the session. Decide in advance which actions need approval and which do not, and keep the approval list short. A role created for one item, like a single piece of bone meal, is a signal that the permission layer is growing faster than the work.
  4. Give the team a memory that survives a death. The four agents shared memory across 605 deaths. A team whose knowledge dies with each failed attempt restarts every time; a team that records what failed, what worked, and where things are does not. Shared, persistent memory was part of the setup that finished, and its absence was part of the setup that did not.
  5. Measure attempts, not messages. The fifty agents sent about 5,900 messages and established no food production. The four agents wrote 2,783 programs and died 605 times. Messages are coordination overhead made visible; programs written and attempts survived are work. Count the second kind.
  6. Run it more than once before believing it. Both experiments rest on single runs. A behaviour seen once — bureaucracy, persistence, a directory-order leader — is a hypothesis for the next run, not a finding. The next run is the test.

Limits

Related playbooks

Sources

Back to: Coding playbooks hub · Also: Have one agent write the code and a second agent check it in the background · Run parallel subagents in Claude Code without losing track of what changed · Agent Skills has a neutral home — and still no security story