A real workload, with the limits left visible.

[ 24 · Fanout ]

The night one agent spawned 85.

One parent, 85 children, and better than half the night's subagents came out of that single decision.

You approve one prompt. What you are actually approving is a hiring decision, and you find out how big it was afterwards.

The mean says 4.7 subagents a session, and the mean is useless here. A fleet that averages 4.7 and peaks at 85 is not a fleet with a typical size.

Nothing in a terminal shows you this while it happens. You get interleaved output, and a cost line at the end.

In that cost line, a fanout that worked and a runaway that happened to finish look identical.

One parent and its 85 children. The widest fanout on the record is 85: a single main agent spawned 85 subagents, every one of them general-purpose. They are drawn as 85 ticks off one rail, with every tenth tick lettered, so the count is read rather than believed. Two things are drawn beside it on the same pitch. The mean is 4.7 subagents a session, which is the short bracket near the left edge, and this one parent is worth 18.1 of it. And 85 of the night's 160 subagents came out of this one decision, which is 53% of them, so the remainder underneath is a comb of 75 on the same pitch and it is shorter than the fan above it. Every tick is one child record. They carry no time and no name: which session this parent belonged to, and the hour it ran, are staged, and the count is not.

[ 25 · The bill ]

88 cents a million tokens.

34 sessions, 416.9 million tokens, and 163 hours of session time inside a ten hour night.

The total is $366.65. It is the least interesting number on this page, and it is the one everybody reads first.

Twelve sessions running at once and twelve running in turn produce the same total. Only one is a bad night, which is why the session mark draws concurrency as strands.

The bill, divided twice. The night cost $366.65, which is 36,665 cents. Divided by 34 sessions that is $10.78 a session, or 1,078.38 cents exactly. Divided by 416.9 million tokens it is 88c a million, or 87.95 cents exactly, blended across every model and every token class that ran. Neither quotient is a rate card. They are what this machine paid, on one night, for the mix of work it happened to do.

The mean session ran 4h 49m, and 34 of those is 163h 46m of session time. The watch is 10h 00m long, from 22:00 to 08:00, so the session time is 16.4 times the night that held it. That does not fit end to end, so the sessions were not queued behind each other: they overlapped heavily, and several were already running when the watch opened. The upper register draws all 34 sessions on the watch, every one of them at the mean span, and 15 of them begin before 22:00 and are cut off at the left edge. The lower register lays the same 34 sessions end to end and wraps them at the width of the watch, which takes 17 rows, the last one 38% full. Read the other way, 16.4 is the mean number of sessions that would have been live at any moment of the watch, if all of that session time had fallen inside it. Some of it did not, which is what the sessions already running at 22:00 are, so the true mean is lower and the record does not say by how much. A cost line at the end of one terminal cannot tell you any of this. It has no way to know what else was running while it ran.

[ 27 · Cache ]

94% of the tokens had been read before.

One total tells you what you spent. Four buckets tell you what you did.

The screens keep the four apart for that reason. A total that arrives as one number can only be read for its size.

The read to write ratio. 11,256,300 cache write tokens were read back as 391,886,000 cache read tokens, which is 34.8 reads for every write, or about 35. The comb draws that as 34 full ticks and one short one, because the ratio is 34.8 and not a whole number. Output was 3,752,100 tokens, 0.9% of the night. The other 99.1% is context. 160 subagents ran, and every one of them reads a context somebody else paid to write. Fan out further and the ratio climbs, because the same write is amortised over more readers. A compaction in the wrong place, a rewrite of a file everyone is holding, an agent restarted with a fresh context: each turns a cheap read back into an expensive write.

[ 28 · Depth ]

Eleven deep, and nobody counts it.

You see the first agent in the chain. The other ten ran out of sight.

Nothing errored on this record, at any depth. The ladder is what an error would have to climb.

The depth ladder. The deepest parent chain on this record is 11, counting the main agent as depth 1, so the ladder has 11 rungs and 10 hand-offs down it. Depth 1 is on your screen. Depth 9 is eight hand-offs away from it, and by the time an error there reaches you it has been paraphrased by every layer it passed through. The bar beside each rung is how loudly the error propagation map draws an error at that depth: loudest at depth 1 and quietest at depth 11, because that is the inverse of how likely you are to notice it unaided. 10 hand-offs between the sentence you typed and the thing that edited a file. Nobody planned an eleven level hierarchy. It assembled itself, one reasonable delegation at a time. 57 of 160 subagents were hired by another subagent, so about a third of the fleet was hired by something that was itself hired. Errors on this record, at every depth: 0. No agent failed.

[ Zero ]

Zero bytes, tested rather than asserted.

In this local reference run, the number of bytes that left the machine was zero.

Every local-first product says nothing leaves your machine. The sentence costs nothing to write, which is exactly why it persuades nobody who has been burned.

So here is the number instead. Not "minimal", not "only anonymous diagnostics", but zero, on the record beside the tokens and the dollars.

Two doors do exist, and you open both yourself: security draws what opens each. The check is yours to run, on your own machine, with your own tools.

[ Method ]

How the record was taken, and what is staged.

One machine, one night, the same reading the product's own analytics pages were built against.

The record

34 sessions on one machine, captured by hooks and completed from the transcripts on disk. It is the reading the product's own analytics pages were built against.

What is measured

Every count, every token, every dollar and every depth on this site. They live in one file, and if a drawing disagrees with that file the drawing is wrong.

What is staged

The clock. This site replays the record against a night that opens at 22:00, so every wall clock time you see is the replay's and not the record's. Individual session names, directories and per-session figures are staged for the same reason. Where a drawing stages anything, it says so under its caption.

What is not here

No unverified adoption counter or anonymous benchmark. The page reports one bounded reference workload and does not generalise it into a productivity score.