Agent Swarm Lab

A swarm of drones flies at a target and a defender tries to shoot it down. The swarm is organized in one of two ways: central, where one controller drone coordinates everybody, or mesh, where the drones coordinate with each other and nobody is in charge. This page is a simulated Monte Carlo wargame that runs the same fight thousands of times in your browser and counts how often each design gets through.

Every number here is invented. Distances are units, time is ticks, and none of the parameters describes a real aircraft, weapon or defensive system. The point is the shape of the result, not its size.

Every figure on this page is simulated: arithmetic over made-up parameters, computed in this tab from a seed you can see and change. Nothing here is measured.

Loading the simulation…

One fight, both ways

Both panels replay the same trial from the same seed: the same starting positions and the same dice for every shot. Only the swarm’s organization differs. Drones fly left to right toward the target line; the defender fires from the target. The ringed drone is the central swarm’s controller. In the mesh panel the same drone flies the same path and coordinates nothing.

Central — one controller

—

Mesh — peer to peer

—

  • flying
  • holding (lost its controller)
  • shot down
  • reached the target
  • interceptor hit
  • interceptor miss

Change the fight

Every change replays one sample run above and reruns 10,000 trials of each design for the histogram below.

How big does the swarm need to be?

Mission success probability against swarm size, one curve per design, with every other setting held where you left it. Each point is 2,000 trials, every 2 drones from 2 to 60; the histogram below uses the full 10,000.

—

How many get through?

For the current settings: how many trials out of 10,000 ended with each number of drones at the target. The dashed line is K.

CentralMesh
Mission success——
Average drones arriving——
Shot down, all trials——
Lost coordination, all trials——

A model’s prediction, made blind, then graded

This is the one part of the page with an AI model in the loop. Before any of the four scenarios below had been simulated, claude-opus-5-5 was given a parameter file describing the rules and asked, for each scenario and each design, at what swarm size mission success first reaches 50%. It ran on 27 September 2026 (UTC) in a fresh session with no tools, no files and no network, and its answer was committed before the grading run existed. The simulation then measured each value over 10,000 trials per swarm size, seed 410.

All four scenarios use a hit chance of 0.6, a reload time of 2 ticks and K = 8. The rule, fixed before anything was measured: a prediction within 2 drones of the measured value is a hit, and “never” is a hit only against a measured “never”.

8 of 8 predictions were hits; 6 were exact. Every cell is shown, misses included.

Scenario Interceptors Aims at controller Design Predicted Measured Off by Result
S1 8 off central 13 13 0 hit
S1 8 off mesh 13 13 0 hit
S2 8 on central never never 0 hit
S2 8 on mesh 13 13 0 hit
S3 24 off central 17 17 0 hit
S3 24 off mesh 20 19 1 hit
S4 24 on central never never 0 hit
S4 24 on mesh 20 19 1 hit

Two things limit what this score means. First, the parameter file states every rule of the simulation, so a careful reader can work most of these numbers out with a binomial table: this measures reasoning about a fully described model, not intuition about real swarms. Second, the model that made the predictions is the same model that wrote the simulation. It ran in a fresh session with no tools and saw only the parameter file and the prompt, but it is not an independent party.

What the model said, in its own words

  • S1: All 8 shots land before any arrival and go at non-controller drones; kills ~Bin(8,0.6), so need N-kills>=8, crossing 50% at N=13 for both.
  • S2: Priority sends every shot at the controller, which dies with probability ~0.9993 and collapses the swarm; MESH ignores the toggle and matches S1.
  • S3: CENTRAL: ~14 shots hit other drones before they arrive and the tick-28 shot targets the controller, giving kills ~Bin(14,0.6) and crossing at ~17. MESH is slower, so ~18 shots land on the others plus about 1 on drone 0, crossing at ~20.
  • S4: The controller is targeted first and dies almost surely, collapsing the swarm; MESH is unaffected by priority and matches S3.
The exact message the model was sent
You are taking part in a blind prediction. Below is a parameter file describing a simple, made-up Monte Carlo model of a drone swarm attacking a target while a defender fires interceptors. It has two coordination architectures, CENTRAL and MESH, and four scenarios.

You have no tools and no other information. Nobody has run these scenarios yet, so there are no results to find. Reason from the rules alone.

For each of the four scenarios and each architecture, predict the measured value described in the parameter file: the smallest swarm size N (from 2 to 60) at which the mission success rate reaches at least 50%, or "never" if no N from 2 to 60 gets there.

Answer with a single JSON object and nothing after it, in exactly this shape:

{"predictions": [
  {"scenario": "S1", "central": <integer or "never">, "mesh": <integer or "never">, "rationale": "<one or two sentences>"},
  {"scenario": "S2", ...},
  {"scenario": "S3", ...},
  {"scenario": "S4", ...}
]}

You may think before the JSON, but the JSON object must be the last thing in your answer.

--- parameter file (params.json) follows ---
{
  "title": "Agent Swarm Lab — blind prediction parameter file",
  "note": "Every number here is invented and abstract. Distances are units, time is ticks. Nothing is calibrated against any real system.",
  "model": {
    "swarm": "A red swarm of N drones, numbered 0 to N-1, flies straight at a target. Drone 0 is the controller in the CENTRAL architecture; in the MESH architecture drone 0 flies exactly the same path and coordinates nothing.",
    "startDistance": "Drone 0 starts 150 units from the target. Every other drone starts 100 + J units away, where J is a whole number drawn uniformly from 0 to 40 inclusive, independently per drone.",
    "speed": "CENTRAL drones move 5 units per tick. MESH drones move 4 units per tick (peer-to-peer coordination costs time). A drone starting D units away arrives at tick ceil(D / speed).",
    "defender": "The blue defender fires one interceptor at tick 0, then one every R ticks (ticks 0, R, 2R, ...), until it has no interceptors left or nothing to shoot at.",
    "targetable": "A drone is a target while it has not been shot down and has not arrived. A drone that arrives at tick t cannot be shot at tick t or later.",
    "targeting": "Each shot goes at the nearest target (ties: lowest drone number). If the priority toggle is ON and the swarm is CENTRAL, the shot goes at the controller instead, whenever the controller is still a target. In MESH the toggle has no effect.",
    "hit": "Each shot hits with probability p, independently. A hit shoots the target down.",
    "centralCollapse": "CENTRAL only: if the controller is shot down, every drone that has not yet arrived stops where it is and never arrives. The defender keeps shooting the stopped drones, nearest first, until it runs out of interceptors or the controller's own planned arrival tick has passed. Stopped drones never reach the target.",
    "mesh": "MESH: nothing collapses. Any drone that is not shot down arrives.",
    "success": "A trial is a mission success for red when at least K drones reach the target."
  },
  "common": {
    "p": 0.6,
    "R": 2,
    "K": 8
  },
  "scenarios": [
    {"id": "S1", "interceptors": 8, "priority": false},
    {"id": "S2", "interceptors": 8, "priority": true},
    {"id": "S3", "interceptors": 24, "priority": false},
    {"id": "S4", "interceptors": 24, "priority": true}
  ],
  "measurement": "For each scenario and each architecture, the swarm size N is swept from 2 to 60 in steps of 1, with 10,000 independent trials at each N. The measured value is the smallest N at which the mission success rate is at least 50%. If no N from 2 to 60 reaches 50%, the measured value is \"never\".",
  "grading": "Locked before any measurement exists. A prediction is a HIT when it is within 2 drones of the measured value (|predicted - measured| <= 2). When the measured value is \"never\", only a prediction of \"never\" is a hit; when the prediction is \"never\" and the measured value is a number, it is a miss. Every cell is published, hits and misses alike."
}

How this works

  • Made-up parameters. Nothing is calibrated against a real system. Distances are units and time is ticks.
  • Seeded and reproducible. The same seed and settings give the same result every time, on any machine. Each trial has its own random stream, and both designs share it, so they face the same dice.
  • What one trial does. Drones start 100 to 140 units out; the controller starts at 150, behind everyone. Central drones move 5 units a tick; mesh drones move 4, because agreeing among peers costs time. The defender fires one interceptor at tick 0 and then once per reload, at the nearest drone — or, with the toggle on, at the central controller. If the central controller is shot down, every drone that has not arrived stops and never arrives. The mesh has no such weak point. A trial succeeds when at least K drones reach the target.
  • What the model saw. Only the parameter file and the prompt shown above. It had no tools and no access to this code or to any result.
  • Where it runs. The simulation is Go compiled to WebAssembly, running in a background worker in your browser. Nothing is sent anywhere.

The same trade-off in software

Swarms of AI agents are often built the central way: one orchestrator hands out the work and the other agents wait on it. That is simpler and often faster, which the central curve shows when the defender ignores the controller. It also means one component whose failure stops everything, which the same curve shows the moment the defender aims at it. A peer-to-peer design pays a coordination cost up front and loses capacity gradually instead of all at once. Which one to build depends on how likely that one component is to fail, and this page is a way to get a feel for that trade before it matters.