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.
- 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
- 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
- 6 steps, 10 to 150 guests60 seconds a step
- Recommended public cap: 40 guestssmooth up to 100 on that machine
A fresh run on a Mac: a measurement
- 9 steps, 10 to 300 guests60 seconds a step, no browsers
- Smooth up to 200 guestsat 250 it fell behind
In the same run on the Mac: hostile guests
- 5 abuse probestried on a fresh guest connection at each of the 9 steps
- 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).
| Guests | Tick p95 | Step p95 | Crowd p95 | Loop lag p50 / p95 | Pushes a second, each | Move reply p95 | Space's CPU (one core) | CPU per push | Memory | Down, per guest |
|---|---|---|---|---|---|---|---|---|---|---|
| 10 | 2.38 ms | 3.39 ms | 1.52 ms | 4.7 / 19.7 ms | 1.95 | 12.2 ms | 7.6% | 3.84 ms | 49 MB | 15.1 KB/s |
| 25 | 3.16 ms | 10.02 ms | 2.42 ms | 7.6 / 18.5 ms | 1.95 | 13.5 ms | 17.6% | 3.60 ms | 55 MB | 23.0 KB/s |
| 50 | 3.33 ms | 14.28 ms | 3.59 ms | 8.5 / 19.2 ms | 1.95 | 18.4 ms | 32.1% | 3.28 ms | 64 MB | 34.9 KB/s |
| 75 | 4.80 ms | 13.70 ms | 4.59 ms | 11.7 / 31.3 ms | 1.95 | 22.0 ms | 48.0% | 3.28 ms | 74 MB | 46.4 KB/s |
| 100 | 6.01 ms | 17.38 ms | 7.23 ms | 14.3 / 87.0 ms | 1.90 | 76.9 ms | 73.1% | 3.84 ms | 87 MB | 58.0 KB/s |
| 150 | 9.37 ms | 49.25 ms | 16.11 ms | 121.0 / 1,346.6 ms | 1.03 | 1,504.4 ms | 70.2% | 4.53 ms | 109 MB | 44.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.
| Guests | Tick p95 | Step p95 | Crowd p95 | Loop lag p50 / p95 | Pushes a second, each | Move reply p95 | Space's CPU (one core) | CPU per push | Memory | Down, per guest |
|---|---|---|---|---|---|---|---|---|---|---|
| 10 | 1.11 ms | 1.74 ms | 0.58 ms | 2.1 / 3.0 ms | 2.00 | 2.0 ms | 4.2% | 2.10 ms | 48 MB | 15.3 KB/s |
| 25 | 2.92 ms | 8.32 ms | 1.36 ms | 2.6 / 18.6 ms | 1.98 | 17.2 ms | 9.3% | 1.87 ms | 50 MB | 23.2 KB/s |
| 50 | 0.73 ms | 2.38 ms | 0.50 ms | 1.0 / 2.5 ms | 2.00 | 1.7 ms | 7.9% | 0.79 ms | 65 MB | 35.6 KB/s |
| 75 | 1.04 ms | 3.58 ms | 0.69 ms | 1.4 / 2.8 ms | 1.99 | 1.8 ms | 12.5% | 0.83 ms | 76 MB | 47.5 KB/s |
| 100 | 1.37 ms | 3.74 ms | 0.87 ms | 1.7 / 3.5 ms | 1.99 | 1.9 ms | 18.9% | 0.95 ms | 79 MB | 61.2 KB/s |
| 150 | 2.48 ms | 8.44 ms | 1.80 ms | 2.4 / 10.6 ms | 1.98 | 5.8 ms | 49.9% | 1.68 ms | 104 MB | 84.0 KB/s |
| 200 | 2.72 ms | 9.36 ms | 1.89 ms | 2.6 / 9.6 ms | 1.98 | 13.4 ms | 64.7% | 1.63 ms | 129 MB | 108.2 KB/s |
| 250 | 5.37 ms | 34.89 ms | 3.77 ms | 173.0 / 312.0 ms | 1.54 | 312.3 ms | 92.0% | 2.39 ms | 155 MB | 104.1 KB/s |
| 300 | 5.90 ms | 25.14 ms | 5.18 ms | 481.3 / 670.4 ms | 1.04 | 653.0 ms | 96.3% | 3.08 ms | 183 MB | 84.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 mainc169ad9bon ; 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 mainc169ad9bon ; 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 mainc169ad9bon ; 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.