WRITEUP

Ten thousand live workers

Cary Palmer · 9 September 2026 · job_9649456d3e32

On a rented RTX 4090, Puppetmaster held 10,000 operating-system worker processes at the same time. Each process finished a real local inference turn against Ollama qwen2.5:0.5b. Wall time was 49.7 minutes. One spawn wave. No crashes.

That is 10,000 live processes. It is not 10,000 inferences running at once. The model server had eight decode slots. Ten thousand clients waited on eight generations.

In September 2026 OpenAI published a Navier-Stokes note that mentioned on the order of 10,000 concurrent agents, an internal frontier model, and on the order of 130 billion output tokens. This note is smaller: the process table on a $0.34/hr 4090, with a 0.5B model capped at 64 output tokens per worker.

Job id job_9649456d3e32. All 10,000 workers finished. 540,000 tokens in. A later run on the same machine marked 10,000 Linux kernel files dirty. Those writes are markers, not patches.

Puppetmaster ships with a live-worker cap of 100. This measurement overrode that cap. The default stays 100 because the climb to 10,000 broke SQLite more than once.

Queue, processes, decode

A job sitting in SQLite, a process in the operating system, and a generation on the GPU are different widths. Flattening them into one “10,000 agents” number hides which one actually grew.

A queue of 10,000 jobs can be drained by eight live processes. That is a different measurement: the queue is wide, the process table is not. This run grew the process table. 10,000 processes existed together and called one Ollama. Eight generations in flight. Ten thousand clients waiting.

In-flight generations equal the smaller of live processes and Ollama’s parallel slot count. Parallel stayed 8. Raising the live-process cap on short completions did not shorten the clock. Extra processes are accounting. They do not multiply decode.

Hardware

Width was proven on an Apple M5 first, so a billed GPU would not sit idle while the process table broke. macOS caps a user at 8,000 processes. A 4,096-wide spawn leaked to 8,179 and killed the machine. The largest Mac run that held was 2,048 live processes, 145 seconds.

The 10,000-wide run used a community RTX 4090 at $0.34/hr. Host memory was about 58 GB at 10,000 live. After the file-marker wave, the model server sat near 4 GB. It had already died once on a memory spike. Restart and continue. The remaining bottleneck is the inference server, not the orchestrator.

Live-width climb

Counts below are live operating-system workers, not queue length.

Inference

9 September 2026. Every worker completed a local inference turn. Completions are real tokens. Workers were not asked for structured reports: a 0.5B model cannot be trusted to emit them.

Mean output over the wall was about 214 tokens per second. That is eight decode slots on this model and cap.

File markers

Same machine. Same live width. 10,000 files marked dirty. 306,297 tokens out. 43.7 minutes. Each worker claimed one file. Nobody shared a git writer. The tree is dirty in ten thousand places. That is not ten thousand compilers, and it is not a kernel refactor.

Why the number matters

Most multi-agent setups share a transcript: one parent chat plus N subagents in the same thread. That shape dies before the process table does. Puppetmaster workers share a SQLite store instead. This run is that store with 10,000 processes attached.

The orchestrator completed one spawn wave, waited for every worker to attach, and drained the set to empty. The model server recovered after a memory spike. SQLite, which had failed earlier in the climb, accepted 10,000 live connections while decode width stayed 8.

What this is not

This is not OpenAI’s Navier-Stokes work. That note is a claimed numerical blowup of a forced equation, on an internal model, after tens of billions of tokens. The Clay Mathematics Institute has not accepted it as a prize solution.

This is not 10,000 concurrent decodes. Decode width stayed 8.

This is not 10,000 engineers editing the kernel. The files are marked.

This is not how the shipping product runs. The default live cap is 100. SQLite failed on the way up. That failure is why the default is not 10,000.

Ten thousand clients on eight generations is a large process table and a serial GPU. The next measurement is more inferences in flight, or 20,000 live processes now that 10,000 has been held.