Status — Minecraft backend: the Fabric server and bot stack described below is in active development. I am working on high-performance simulation architectures that can break past what typical Minecraft rendering and world simulation impose on a single machine, so long-horizon, population-scale civilizational experiments are not permanently bounded by vanilla client/server throughput on one box. The rest of this page stays the design intent; expect the Minecraft path to evolve as that infra lands.
Most multi-agent benchmarks are ephemeral — spin up agents, run a scenario, tear everything down. The questions that matter (norm driftThe gradual shift in group behavioral conventions over time — norms that were adaptive in one context may persist and become counterproductive as conditions change., knowledge accumulation, emergent specialization) only appear when agents persist in a shared environment for days, weeks, or months alongside humans. A persistent world is valuable because it is expensive in the right ways: spatial interference, resource contention, irreversible edits, and social signaling all carry real costs. Ephemeral eval harnesses erase those costs, which flatters models on precisely the dynamics that matter for long-horizon coexistence.
Why multiple backends
Different backends test different hypotheses. Block worlds (Minecraft) give you legible economics and cohabitation with real people. Isaac LabNVIDIA's GPU-accelerated simulation platform for robotics research. Used here as an alternative world backend for physics-realistic multi-agent experiments (grasping, locomotion, sensors). gives you contact-rich, sensor-realistic multi-agent dynamics for robotics-flavored questions. WebGPUA modern browser API for GPU-accelerated computation. Enables running multi-agent simulations directly in a web browser — no game server or special software install needed. gives you reach — classrooms, browsers, contributors with no install budget — under explicit compute constraints that still support persistence. The orchestration and institutions layers are designed to plug into any engine: the coordination layer is the constant and the world is the variable, which is what you need to isolate the contribution of institutional design from environmental affordances.
Minecraft: Fabric server and player-parity bots
The reference deployment is a FabricA lightweight modding framework for Minecraft that uses "mixins" to inject code into the game at specific points, without replacing whole classes. 1.21.11 Minecraft server running a flat superflat world called civilization in survival mode. The server holds up to 100 concurrent players with PVP enabled. World state — chunks, player data, advancements, statistics — persists across restarts, so agent actions are as permanent as human ones.
The bridge: ServerPlayer bots, not mobs
The key infrastructure piece is civilization-bridge, a custom server-side Fabric mod. Where the reference implementation spawns agents as PathfinderMob entities (game-controlled creatures), civilization-bridge creates them as ServerPlayerMinecraft's internal class for a real human player on the server. The civilization-bridge creates bots as ServerPlayers (not mobs) so they have the exact same capabilities and limitations as human players. instances — bot accounts that join through a REST APIA standard web interface (HTTP endpoints) that any programming language can call. The civilization-bridge exposes one so the agent orchestration layer can spawn bots, send commands, and read world state. and participate with full vanilla game mechanics. A ServerPlayerMixinA technique for modifying existing code without rewriting it — the mod injects new behavior into Minecraft's player-join path so bot accounts are treated as real players. injects into the player-join path so bots appear in the player list, trigger advancements, interact with redstone, and obey every game rule a human player does. The bridge exposes HTTP endpoints to spawn bots, issue commands, query world state, and observe outcomes; the orchestration layer can live in any language.
The design choice matters: making agents players instead of mobs means they share the same inventory, crafting, and permission model as humans. No special API grants abilities humans lack, and no hobbled subset silently blocks capabilities humans have. Parity is the point — it is what makes the gap between “synthetic success” and “cohabitation success” narrow enough to study.
Reference implementation: Steve AI
The _reference/Steve directory is a complete ForgeAn older Minecraft modding framework. The Steve reference agent was built on Forge 1.20.1; the production civilization-bridge uses the newer Fabric framework. 1.20.1 mod (68+ Java source files) that proved out the agent loop before I rebuilt it on Fabric. Each Steve runs an autonomous cycle:
- A WorldKnowledge module scans a 16-block radius for blocks, entities, and biome data.
- A PromptBuilder compresses that context — plus the agent's current goal and memory — into an LLM prompt.
- A pluggable LLM client (Groq, OpenAI, or Gemini) returns a structured JSON action plan. The client wraps each provider in resilience layers — circuit breakersA resilience pattern borrowed from electrical engineering: if an external service (like an LLM API) fails repeatedly, the circuit "opens" and stops sending requests for a cooldown period, preventing cascading failures. that back off when a model API is down, automatic retries with exponential backoff, and bulkheadA limit on how many concurrent requests one component can make, preventing a single runaway process from consuming all available capacity. Named after ship compartments that contain flooding. limits so one agent cannot monopolize inference capacity.
- A ResponseParser extracts typed tasks, and an ActionExecutor ticks them one placement or pathfind-step at a time so the game loop never blocks.
The action layer covers mining, procedural and NBT-template building, combat with stuck-detection, and pathfinding via vanilla Navigation. Multi-agent construction uses a CollaborativeBuildManager that partitions structures into quadrants, assigns each Steve a section, and uses AtomicInteger cursors so multiple agents build bottom-to-top without conflicts. Agent memory persists in Minecraft's native NBTNamed Binary Tag — Minecraft's native data format for saving game state. Used here to persist agent memory (goals, recent actions) across server restarts. save format.
Related Minecraft AI work
Several research efforts use persistent virtual worlds for AI agents. Generative Agents (Park et al., 2023) placed 25 LLM-powered agents in a virtual town where they autonomously formed relationships, organized events, and spread information — the seminal demonstration that persistent agent worlds produce emergent social dynamics. Project Sid scales this from 25 to 1,000+ agents and adds institutional structure. Voyager (Wang et al., 2023) demonstrated a single LLM-powered agent that explores autonomously, writes reusable skills, and manages its own curriculum — but operates solo, not in a multi-agent society. MineDojo (Fan et al., 2022) provides a massive benchmark suite with thousands of tasks across Minecraft, plus internet-scale knowledge bases (YouTube, Wiki, Reddit) that agents can learn from. Project Sid operates at a different level: not individual agent capability, but civilizational dynamics — what happens when hundreds of agents cohabit a persistent world with humans and develop institutions. The civilization-bridge architecture addresses the gap between these approaches: Voyager-style individual agents can be composed with the coordination primitives to produce multi-agent societies where skill libraries, institutional memory, and governance coevolve.
Isaac Lab (planned)
For questions where block-world physics is the wrong abstraction — grasping, locomotion, warehouse layout, sensors — Isaac Lab brings the same agent and institutions layers to GPU-accelerated rigid-body simulation. The integration targets parity with the Minecraft path: observable state, durable world logs, and a clean boundary between world truth and agent cognition so benchmarks remain comparable across engines.
Specific hypotheses this backend tests: whether the coordination primitives hold when action latency is measured in physics timesteps (milliseconds) rather than game ticks (50ms); whether Claims and Signals generalize to continuous state spaces where “ownership of a region” has no discrete voxel boundary; and whether the hierarchical pod structure survives when agents must coordinate not just on plans but on real-time trajectories that intersect physically. The factory-layout scenario (agents rearranging a shared warehouse) is the target benchmark: it requires spatial Claims, dependency Signals on partially completed assemblies, and Forum-level decisions about layout trade-offs — the same primitive stack, with physics-realistic failure modes (collisions, , jams) that block worlds cannot produce.
Status: the world-adapter interface is specified; the Isaac Lab integration is not yet implemented. The Minecraft path is the current priority because it is the only backend with human cohabitation (real players sharing the server), which is required for the human-in-the-loop research questions.
WebGPU and the browser (planned)
Browser-side WebGPU keeps the barrier to entry low: smaller environments, tighter budgets on agent count and timestep, but still persistent multi-agent dynamics in a shareable browser tab. This is how the civilization stack reaches classrooms, workshops, and contributors who will not install a game server or Isaac on day one.
Specific hypotheses this backend tests: whether coordination primitives degrade gracefully under compute constraints (fewer agents, slower ticks, limited memory); whether the institutional dynamics observed in Minecraft reproduce at smaller scale or require a critical mass of agents; and whether browser-accessible environments enable a new class of human-subject experiment where participants interact with agent civilizations through a URL rather than a lab setup.
Status: not yet implemented. The design constraint is that the WebGPU backend must use the same orchestration contracts as Minecraft and Isaac Lab, so that benchmark results are comparable across backends even when the world fidelity differs. A constrained budget is a forcing function — if the coordination primitives only work with unlimited compute, they are not robust enough for production use.
The modular agent layer (in progress)
On top of each world adapter sits a Python orchestration layer that decomposes agent cognition into swappable modules:
- core — agent lifecycle: spawn, tick, shutdown, event bus.
- modules/cognitive — perception → reasoning → action selection, with an LLM integration layer using the same resilience patterns (cache, retry, circuit breaker) validated in Steve.
- modules/memory — episodic and semantic stores that outlive a single session.
- modules/spatial — world-state indexing, landmark tracking, territory awareness.
- modules/planning — hierarchical goal decomposition with multi-step plan trees and re-planning on failure.
- modules/skills and modules/building — action primitives and composite recipes.
- modules/social and modules/chat — inter-agent communication: who talks to whom, what conventions form, how information .
Above the modules sits an institutions layer — the part that makes Project Sid–style questions concrete. It contains three packages: culture (norms, traditions, memetic spread), groups (alliance formation, role differentiation, governance), and knowledge (collective memory any agent can query — the in-world equivalent of the VAC Collective Brain).
Open-source release
The plan is to open-source the full civilization stack once the core loop is stable enough that someone else can clone the repo, pick a backend, and get running agents without hand-holding. The civilization-bridge Fabric mod (MIT-licensed) releases first as the most self-contained piece. Isaac Lab and WebGPU adapters follow with the same orchestration contracts. The Python module layer ships with a plugin interface so researchers can swap cognitive architectures (chain-of-thought, tree-of-thought, ReAct, PIANO-style deliberation) without rewriting world glue. A benchmark suite with reproducible scenarios (resource gathering, collaborative builds, conflict resolution, long-horizon territory management) ships alongside. The goal is a stack that a research group can fork, point at their own questions, and produce publishable results.
Next deep dive
Measurement — The scoreboard for civilizational AI: coordination metrics, adversarial evaluation, reproducibility, discovery loops — plus collaboration circuits (mechanistic evidence inside the model).
Or explore: Architecture, Failure modes, Human in the loop, Coordination at scale, Results.