LAB 12 · HOW MANY STRANGERS CAN THE SPACE HOLD?

How many strangers can the space hold?

The agent space can be opened to anonymous guests: anyone with the link walks in, talks to the agents and asks Odin to check them. Before a link like that is shared, someone has to say how many guests one space can take. We had a written answer, measured on another machine. This page sets it beside a fresh measurement on a Mac, and keeps the two apart.

What it is.

The lab in plain words, and how it runs.

The agent space can be opened to anonymous guests: anyone with the link walks in and talks to the agents. The question is how many guests one space can take before it falls behind.

We had a written answer, a capacity sheet measured on another machine, so for any other host it is an estimate. We ran the load tool once more, on a Mac, stepping guests in from 10 to 300, and kept the two results apart.

The sheet recommends a public cap of 40 guests; on its own machine it stayed smooth up to 100 guests. The fresh run on the Mac stayed smooth up to 200 guests. At 250 guests it fell behind. The machines and the code differ, so read these as an estimate and a measurement, not as a before and after.

How it works: one load tool, run on two different machines with different versions of the code, the estimate and the measurement kept apart
  1. The agent space, with 200 resident crowd agentsguests stepped in, a set number at a time, each step held for a while and then measured
  2. The load toola swarm of guests that keep to the rules; the fresh run also sent hostile ones

The capacity sheet: an estimate, made on another machine

  1. 6 steps, 10 to 150 guests60 seconds a step
  2. Recommended public cap: 40 guestssmooth up to 100 on that machine

A fresh run on a Mac: a measurement

  1. 9 steps, 10 to 300 guests60 seconds a step, no browsers
  2. Smooth up to 200 guestsat 250 it fell behind

In the same run on the Mac: hostile guests

  1. 5 abuse probestried on a fresh guest connection at each of the 9 steps
  2. All 5 held at every stepno guest got more than 1 of Odin's checks in ten minutes, under the limit of 3

The estimate, and the measurement.

Side by side, and never in one box.

AN ESTIMATE, NOT A MEASUREMENT

The capacity sheet

Measured on a shared Windows PC with 12 logical cores and other work running on it (68% of its processor busy before the run). For the space as it would be hosted, these are an estimate, and the sheet says how much room it leaves.

  • Recommended public cap: 40 guests, at most 80 on a processor core of its own.
  • Every loop chore under 50 ms up to 150 guests, the last step tried; smooth up to 100 guests.
  • One core saturated at 150; unusable at 250.
  • On the wire, about 1 to 3 KiB a second per guest: the sheet's own estimate from compressing real pushes offline, not a capture.

A MEASUREMENT, RUN ON 12 NOVEMBER 2026

A fresh run on a Mac

Run on a Mac with an Apple M5 Max (18 cores, 128 GB of memory), shared with other work while it ran, with no browsers.

  • Every loop chore under 50 ms up to 300 guests, the last step tried.
  • Smooth up to 200 guests.
  • At 250 it fell behind: loop lag p95 312 ms, 1.54 pushes a second to each guest instead of two, the space's loop at 92% of one core.
  • Every abuse probe held at all 9 steps.

The two are not the same experiment twice: the machines differ, and so do the versions of the code and its WebSocket library. Read them as an estimate and a measurement, not as a before and after.

The estimate, step by step.

AN ESTIMATE, NOT A MEASUREMENT

The sheet's capacity run, its run 3: 200 resident crowd agents in the space, guests ramped in at 10, 25, 50, 75, 100 and 150, 60 seconds a step, measured after the first 15. On a shared Windows PC with 12 logical cores and other work running on it (68% of its processor busy before the run).

The capacity sheet's run 3, step by step
GuestsTick p95Step p95Crowd p95Loop lag p50 / p95Pushes a second, eachMove reply p95Space's CPU (one core)CPU per pushMemoryDown, per guest
102.38 ms3.39 ms1.52 ms4.7 / 19.7 ms1.9512.2 ms7.6%3.84 ms49 MB15.1 KB/s
253.16 ms10.02 ms2.42 ms7.6 / 18.5 ms1.9513.5 ms17.6%3.60 ms55 MB23.0 KB/s
503.33 ms14.28 ms3.59 ms8.5 / 19.2 ms1.9518.4 ms32.1%3.28 ms64 MB34.9 KB/s
754.80 ms13.70 ms4.59 ms11.7 / 31.3 ms1.9522.0 ms48.0%3.28 ms74 MB46.4 KB/s
1006.01 ms17.38 ms7.23 ms14.3 / 87.0 ms1.9076.9 ms73.1%3.84 ms87 MB58.0 KB/s
1509.37 ms49.25 ms16.11 ms121.0 / 1,346.6 ms1.031,504.4 ms70.2%4.53 ms109 MB44.0 KB/s

The break point and the unusable point come from the sheet's other runs, on the same machine. The bandwidth on the wire is the sheet's estimate, not a capture.

The measurement, step by step.

A MEASUREMENT, RUN ON 12 NOVEMBER 2026

On , from to , on a Mac with an Apple M5 Max (18 cores, 128 GB of memory), shared with other work while it ran: macOS 26.6.1, Python 3.12.13, WebSocket library 17.4. The load tool as it stands at main, from the checked copy described below, and the same space as the sheet: 200 resident crowd agents, 25% of them on shift, guests ramped in at 10, 25, 50, 75, 100, 150, 200, 250 and 300, 60 seconds a step, measured after the first 15, no browsers.

The machine was not idle: its one-minute load was 8.01 when the run started and 15.43 when it ended, and 45.5% of its processor was busy in the ten seconds before. The run is made only below a load of 40.

The fresh run on a Mac, step by step
GuestsTick p95Step p95Crowd p95Loop lag p50 / p95Pushes a second, eachMove reply p95Space's CPU (one core)CPU per pushMemoryDown, per guest
101.11 ms1.74 ms0.58 ms2.1 / 3.0 ms2.002.0 ms4.2%2.10 ms48 MB15.3 KB/s
252.92 ms8.32 ms1.36 ms2.6 / 18.6 ms1.9817.2 ms9.3%1.87 ms50 MB23.2 KB/s
500.73 ms2.38 ms0.50 ms1.0 / 2.5 ms2.001.7 ms7.9%0.79 ms65 MB35.6 KB/s
751.04 ms3.58 ms0.69 ms1.4 / 2.8 ms1.991.8 ms12.5%0.83 ms76 MB47.5 KB/s
1001.37 ms3.74 ms0.87 ms1.7 / 3.5 ms1.991.9 ms18.9%0.95 ms79 MB61.2 KB/s
1502.48 ms8.44 ms1.80 ms2.4 / 10.6 ms1.985.8 ms49.9%1.68 ms104 MB84.0 KB/s
2002.72 ms9.36 ms1.89 ms2.6 / 9.6 ms1.9813.4 ms64.7%1.63 ms129 MB108.2 KB/s
2505.37 ms34.89 ms3.77 ms173.0 / 312.0 ms1.54312.3 ms92.0%2.39 ms155 MB104.1 KB/s
3005.90 ms25.14 ms5.18 ms481.3 / 670.4 ms1.04653.0 ms96.3%3.08 ms183 MB84.3 KB/s

Each step is pooled over its measured window; the tick column counts 76 to 219 ticks a step. The summary above was computed again from the run's own files with the tool's resummarize, and came out the same.

How the run kept to itself.

A load test on a shared machine is only fair to the machine if it touches nothing else. This run:

  • ran from its own copy of the code, taken from the private main with git archive: after the run, all 3,222 files of that copy were checked against main by git's own object hash, every one main's bytes and none missing (the list of their hashes has sha256 737d684b19fa9dcde6f24d5253119458bbbf03e463f7c526d8a2f43f3ff2f5c5). The only files added were the 182 bytecode files Python wrote as it ran, and each was checked to be exactly its own source compiled again. The run's own records name this copy as the place its space's templates were read from. That ties the run to the copy through what the run wrote; nothing here watched which code its processes executed;
  • used a scratch Python environment of its own;
  • started its own space in its own run folder, on free loopback ports it chose at the start, avoiding the ports the live services use;
  • stopped only the processes it had started.

Its listening sockets were listed before, during and after. During the run the space held 3 listeners, all 3 on loopback. None of them was there before the run, none was left after it, and 0 of its processes were left running. Of the machine's other 69 listeners, 67 were exactly the same after the run; 4 changed, and none of those was the run's own: other programs on the machine opened and closed theirs meanwhile.

The listings themselves are not published: they name ports and other programs on the machine. These are their counts.

The limits, under load.

At every step of the ramp, on a fresh guest connection, the tool tries what a hostile guest would:

  • A flood: twenty-five lines at once, of which twenty pass and the rest are told to slow down: held at 9 of 9 steps.
  • A chat line of five thousand characters, which everyone sees cut short: held at 9 of 9 steps.
  • A pasted evidence id, which carries no evidence record: held at 9 of 9 steps.
  • Operator commands, such as inviting an agent, which a guest is refused: held at 9 of 9 steps.
  • A WebSocket frame of two megabytes, which closes that connection while the next guest still gets in: held at 9 of 9 steps.

After the run, Odin's own inspection records were read back: 70 checks in all, and no guest got more than 1 in ten minutes, under the limit of 3.

Check it yourself.

Everything on this page comes from one record, published here and pinned by its sha256. It was read from the public demo's capacity sheet and its load tool in the agent space's private repository, read at its main, and one run on a Mac from a copy of that main. Private commit c169ad9b, cited by hash, checked as part of the private main c169ad9b on ; this page cannot check it, anyone with access can.

The commits it stands on

  • The capacity sheet, with its runs' result files: smooth to a hundred guests, one core saturated at a hundred and fifty, . Private commit 740cd176, cited by hash, checked as part of the private main c169ad9b on ; this page cannot check it, anyone with access can.
  • The load harness: the resident crowd, the space's own loop log and the guest swarm with its abuse probes, . Private commit 9761f918, cited by hash, checked as part of the private main c169ad9b on ; this page cannot check it, anyone with access can.
  • The load tool as it stands at main, . Private commit 0ba604de, cited by hash, checked as part of the private main c169ad9b on ; this page cannot check it, anyone with access can.

The files, by sha256

  • The public demo's capacity sheet: 180f9de4b13b1192668a7c0edf420ddf20cff9b980c99a7e52fcd3198aa68cac
  • The load tool, which starts the space, ramps the guests in and summarises each step: f6b9d2e90b5d36177c0749dba24d2fe4194a7ea8628676d3077436cc16cdb5b5
  • The space's own loop log, which times each tick, step and push: 74651bb23accde250a0e36a2ac7d3259b455a5769fe026340dcd91e8ef086537
  • The capacity sheet's run 3 result file: 1a3c2db614a95b88b18fb634c7a5549e39f77d7ac0255f5c3699e9fc4fe33439
  • This lab's own run, its result file (not published: it names local paths and ports): 3e21451b03cd016d2f4b9a9df4f3a82849efe6d15a16cdb7cd4e617df641650a

Main was checked by GitHub compare of each cited commit against the private main head; behind by 0 means the commit is part of main, on .

What this does not show.

  • Loopback only: no network between the guests and the space, so no latency and no lost packets.
  • The guests are a swarm that keeps to the rules, plus the probes. A real crowd behaves differently, and a hostile client is bounded only by the limits the probes test and by the edge in front of the space.
  • No browser drew the space in this run, so it says nothing about what a guest's screen does at these counts.
  • One run on one machine that was doing other work. A second run, or a quiet machine, would give other numbers.
  • The bandwidth on the wire is the sheet's estimate on both sides; this run counted the bytes of the messages, not the compressed bytes on the wire.
  • The space's interest code ran as plain Python, without its native module, on both machines.
  • Which code ran is shown by the check of the copy and by what the run wrote, not by watching its processes; the page cannot show more than that.