The Typist and the Developer

Our little game — RealKeep, the living-world RPG this whole journey keeps reaching into — runs on one graphics card. When a player says something to the ferryman, a language model writes the reply, one word-piece at a time, like a typist who cannot start the next word before finishing this one. When a player walks somewhere new, a picture model paints the scene — and it does not paint the way the typist types. It starts with a canvas of pure noise and develops it, the whole image at once, pass after pass, like a darkroom print coming up out of the chemicals. Sixteen passes for a quick sketch. Thirty-two for a keepsake.

Both of these live on the same card. Every reply and every picture in the game comes off one piece of silicon, often at the same moment. This piece is about what happens in that moment — measured, not guessed — and about a small mystery: when the typist and the developer work at once, one of them barely slows. The other falls off a cliff.

The typist

A language model writes autoregressively: it produces one token — a word-piece, part five spent a whole morning on them — then feeds everything written so far back through itself to produce the next. There is no writing token five hundred before token four hundred ninety-nine. The loop is the machine.

Part one of this journey measured what that loop costs on our own hardware on 2026-08-18: the model we tested read at 5,415 tokens per second and wrote at 135 — forty to one, because reading is parallel and writing is a queue. Tonight's bench, on the current serving card and the game's shipped chat model, clocked the writing loop at 207.7 tokens per second (median of five, spread 207.5–207.7 — a spread of a tenth of one per cent; the card was quiet, and the spread says so).

Two honest footnotes on that number, both of them callbacks. First: this model does not run "end to end" per token — it is the mixture-of-experts part two anatomized, 25.8 billion parameters on the payroll with about 3.8 billion waking for each token. The queue is real; the whole staff is not in it. Second: part two published this same model writing at 208.0 tokens per second on this card, five days before tonight's independent 207.7 — two benches, one number. When a measurement replicates itself without being asked, you are allowed to start trusting it.

The important physical fact about the typist: each step is small. One token's worth of work, then another, then another. The card is never asked for one giant effort — it is asked for two hundred quick ones a second, each wanting an answer now.

The developer

The picture model could not be more different. A diffusion model is handed a canvas of random noise, the whole thing, and asked: make this slightly less noisy, in the direction of "a lamplit salt-shed at dusk." It does — every pixel at once, one enormous pass through the network. Then it is asked again. The close-up earlier this week priced a single one of those passes and watched what each additional one buys. The sketch tier this particular world configures — the cove's ruled hi-bit lane, sixteen passes on a 512-pixel-square canvas; the engine's shipped default is a different lane, 768 pixels at twelve, as the close-up records — developed a picture tonight in 1.54 seconds (median of five, 1.54–1.67).

The important physical fact about the developer: each step is huge. Where the typist asks the card for two hundred small favors a second, the developer asks for sixteen enormous ones in a second and a half. Same card, same silicon — two completely different shapes of work.

Hence the title: one machine types, the other develops photographs. The darkroom is not a decoration — "how many passes through the chemicals" is genuinely the right mental model, and you have already seen what a picture looks like when you pull it out early.

One card, both jobs, at once

Here is the estate context that makes this measurable instead of theoretical. The card that serves the game tonight — the 96 GB class, the estate's serving box — runs the chat seat and the painter, live. (That card is where the game is served from, not what it needs: the rig piece, published yesterday, measured this same game's art on a 2021 consumer card at under a second a sketch — on the four-pass klein lane, a different and far quicker tier than the sixteen-pass one benched here.) A player talking to the ferryman while another player's sketch develops is not a thought experiment; it is a Tuesday.

So we registered a small bench (the registration is on the shelf beside this piece, written before any measured call, with a dated addendum owning a schedule slip: the whole run took 35 seconds, on 2026-08-26, against the game's live serving instance — the same model object that answers players — and the game's own sketch graph, nothing staged):

Read the last two rows twice, because they are the finding. This is compute contention — both machines resident, both working, fighting over the silicon this millisecond (the other kind, residency contention, is who gets to live in memory at all; it has its own section below). When both machines work the same card:

• The developer barely slows — 1.54 seconds alone, 1.82 beside a full token stream. Eighteen per cent.
• The typist falls off a cliff — 207 tokens per second alone, 52 beside a developing picture. Three quarters of its speed, gone.

Why the lopsidedness? We should say plainly that the rows measure what, not why — the why is our interpretation, and more than one mechanism could produce it: how the driver time-slices two workloads, who saturates the memory bus, how a shared power budget settles. The reading that fits the shapes best: a diffusion pass is a handful of operations so large they occupy the card wholesale, and the typist's small requests queue behind them; going the other way, small steps slip into the gaps around big ones far more easily than big ones fit around anything. And one more number says the card is genuinely sharing rather than thrashing: under contention the developer kept 85 per cent of its solo speed and the typist 25 per cent — about 110 per cent of one card's serial output, delivered simultaneously. The card is not failing at two jobs. It is doing one and a tenth jobs, and the typist is the one donating the slack.

For a player, the arithmetic is gentler than the cliff suggests, for two reasons: replies are short, and the window they can collide with is short too. The bench's own three-sentence replies ran 58 tokens — roughly 0.3 seconds alone, 1.1 seconds at the contended rate — and the contended rate only applies during the 1.8 seconds a sketch is actually developing. Worst realistic case: a reply arrives most of a second later than it would have, and only if it collides with a picture head-on. The game also stacks the deck deliberately — the engine's render lane develops one picture at a time, and a player-facing picture outranks background work — so the collision window is as narrow as the code can make it.

The character who moved one door over

Contention has two species, and this estate has met both. Here is the history with its receipts, because a reader who has followed the journey may think they know it.

For most of its life this game served from a 24 GB rig. Four residents had to share that card: the typist, the developer, the embedder that files the world's memories, and the small vision seat that reads a player's photograph. They did not fit by accident. The operators spent weeks of bake-offs on that rig choosing a set that would all live in 24 GB at once, and found it: the twelve-billion-parameter gemma4 build for the chat seat, the nomic embedder, the two-billion-parameter vision seat, and a rotating cast of painter checkpoints — a set chosen to fit, with the vision seat still riding an unload-before-you-paint discipline, because a card that small has no accounting shared between the two runtimes.

The July notes record the alternative they measured and rejected: the same twelve-billion model in a heavier build, which fit alone but starved the painter. The painter's first picture after an idle spell then took about fifty-four seconds, hauled back into memory before it could develop anything, and the vision seat had no slot at all. That is residency contention — who gets to live on the card — and on a small card it strikes on every hand-off, even when the machines politely take turns. The achievement of the 24 GB era was engineering most of it away by selection and scheduling the rest. A set that co-resides is a set that never pays a reload; a seat that steps out before the painter arrives is the next-best thing, and the game still ships it. (The operators' own bake-off records put the line at 24 GB — the full stack runs whole there, with a little headroom, a posture the voice trials carry receipts for — and, in their experience, at 16 GB or less the set has to swap. That second half is their report from the bake-offs, not a number this shelf has published, and it is stated here as exactly that.)

And the estate had met the other species before tonight, too. The voice trials published it in one sentence — a concurrent render cut a chat seat's throughput by more than half, 89 to 41 tokens per second — and, being the careful page it is, published no rig, model or date beside the figure, and a rule with it: compare within a run, never across. So this piece will not. That is the game the RealKeep site describes, all of it running local, and it is the game the rig piece put on hardware a normal person owns.

Tonight, on the 96 GB class, the set is heavier on both sides: the chat seat is now the 25.8-billion-parameter mixture-of-experts, not the twelve-billion build, and the painter is the hi-bit FLUX lane rather than the SDXL-class stack of the 24 GB era. It co-resides with room to spare. Free memory sat at exactly 16.17 GiB before and after every burst, and the chat model's "load" time after a render burst was two milliseconds — a bookkeeping entry, not a reload. Residency contention, for this heavier set, is gone.

Compute contention is not — and here the piece has to be careful. Two published measurements now show the same shape: a chat seat losing more than half its speed while a picture develops beside it. The earlier one lost 54 per cent; tonight's lost 75. What repeats is the shape, not the size — at least four things differ between those two readings (the card, the chat model, the painter and the method), and the earlier page stamps none of them on its figure, which is exactly why the voice trials' own rule stands: no delta across record sets is a finding. Whether a bigger, faster painter takes bigger bites of the silicon per pass, so that the typist waits behind heavier work, is a plausible reading and a hypothesis for a bench that holds three of the four still — not a finding of this one.

And the residency character did not leave the building either. One day earlier, on this same card, we measured a different pair — two paint models, the incumbent and a candidate — and they still cannot co-reside: memory alternated between 32.7 and 16.2 GiB free as each evicted the other, 2.9 seconds a swap, every swap. Co-residence is a property of a set of workloads, not of a card. The small rig held the set the game needs because the operators chose it with care; the big card holds a heavier set with slack, and the moment you want two developers the eviction story resumes as if it never stopped.

So the bigger card is faster, and that is the least interesting thing about it. What it did not buy was coexistence: the small rig already had that, hard-won. What the memory buys is slack: room for a heavier chat seat, and for the sets you did not plan for. What it does not buy, on tonight's evidence, is a typist that keeps its pace while the developer works.

What we did not measure, said out loud

The registration named its honesty checks before the run, and the rows pass them — but the spreads deserve their own sentence each. The solo token rows are almost eerily tight: a tenth of one per cent between the fastest and slowest of five. The contended token row is the opposite, and the table says so — 40.7 to 75.6 tokens per second, a 1.9× range around a median of 52, with the five samples falling into two clusters rather than scattering evenly. That is the shape you would expect if contention arrives in bursts rather than as a steady tax: a reply that lands between two diffusion passes is not paying what a reply that lands inside one pays. The median is the honest middle of a row that genuinely bounces, and we print the ends so you can see it bounce. The render rows sit between the two — 8.4 per cent on the solo row, 6.1 on the contended one, comfortably inside the ±15 the registration allowed. Every render completed; the excluded-failures list is empty; five samples per row is a mini-bench sized to one question. The run happened beside live traffic, disclosed as such; we did not instrument how much traffic there was, so we will not characterize it. And the registration's declared window was wrong — the run landed hours later and took 35 seconds rather than the half hour we padded for; the addendum on the shelf owns the slip, dated.

Every number in this piece that did not come from tonight's rows carries its provenance. Part two's 208.0 tokens per second is its own published measurement, run 2026-08-21 in a declared maintenance window with no contention — which is what makes tonight's 207.7, taken beside live traffic, a replication rather than a repeat. The rig piece's "under a second a sketch" is its figure for a 2021 consumer card on the four-pass lane, not a number this bench took. The voice trials' 89-to-41 render-cut (published on that page with no rig, model or date beside it — which is why this piece re-quotes it as a shape and never as a delta); the two-painter eviction pair (2.9 seconds a swap, memory alternating 32.7 and 16.2 GiB) comes from the klein bake-off's residency probe of 2026-08-25, whose reading ships in this piece's kit; part one's 5,415-reading / 135-writing (a different model — a 27-billion-parameter dense build against tonight's mixture-of-experts — measured 2026-08-18 — cited as the journey's first sighting of the queue, not as tonight's speed), and July's fifty-four-second painter wake-up (the operators' co-residence notes from the 24 GB rig — the heavier build of the same model they measured and rejected, published on the voice-trials page). Every fresh number came from the runtimes' own counters — the language runtime's token and duration fields, the painter's own execution timestamps — never from a wall clock watching from outside.

What to take with you

Five things, in the piece's own words:

• Two machines, two shapes of work. The typist writes one token at a time — two hundred quick favors a second, each wanting an answer now. The developer writes every pixel at once and rewrites them all sixteen times — a handful of enormous passes in a second and a half. Same card, same silicon, nothing else alike.
• When both work at once, the cliff is lopsided. Alone, 207.7 tokens a second and 1.54 seconds a sketch. Together, the sketch takes 1.82 seconds and the typist drops to 52 tokens a second — the developer barely slows, the typist loses three quarters of its speed, and the card is doing about a tenth more than one job's worth of work while it happens.
• For a player, that is under a second, and only on a collision. A three-sentence reply is 58 tokens: three tenths of a second alone, just over a second at the contended rate — and the contended rate lasts only as long as a sketch is developing. The engine narrows the window on purpose: one picture at a time, player-facing work first.
• Contention comes in two species, and the estate has met both. Residency contention is who gets to live in memory; the 24 GB rig beat most of it by choosing a set that fit — four residents, weeks of bake-offs, playtest after playtest — and scheduled the rest, stepping the vision seat out before every render. Compute contention is who gets the silicon this millisecond; the voice trials published its shape before this piece measured its size.
• The bigger card bought slack, not a gentler typist. On the 96 GB class a heavier set — a bigger chat model, a bigger painter — co-resides with room to spare and pays no reload; the compute cliff is still there, and two paint models still evict each other. Co-residence is a property of a set of workloads, not of a card.

How to check our work

The registration — questions, rows, self-refutation checks, and its one dated addendum — is beside this piece, with the raw rows as they landed: every sample, every counter, the re-grab readings, the memory readings, and the empty exclusion list. (The published rows carry a provenance header added at publication — card class, model, graph, steps, canvas — because the raw file named none of them and a row without its provenance is a number without a path back.) The sketch graph is the game's shipped one at this world's configured tier; the chat call is the game's shipped shape against its live serving instance. If you have a card and both runtimes, the whole bench is an afternoon: measure each machine alone, then make them share, and watch which one flinches. And if your card is small enough that your pair cannot co-reside — say hello to the old character for us. He is real, he is patient, and he charges by the swap.

The rest of the seminar

This is part six of the machines' journey — after Reading is fast, writing is slow, Everyone on the payroll, three at the table, The compressed photograph, The free speed wasn't free, and How a Vision Model Sees. It is the piece where the journey's two halves finally meet on one card: the typist the first four parts took apart, and the developer the close-up priced pass by pass. It leans on the voice trials for the small card's numbers and on the rig piece for what the game actually needs — which is less than the card it is served from.

The whole shelf holds the benches behind the claims we publish, failures included. If there is a piece of the machinery you want opened next, say so — the suggestion box is read.

Glossary. Autoregressive — writing one token at a time, each conditioned on all the ones before it; the reason a language model's output arrives as a stream. Diffusion — generating an image by starting from noise and repeatedly denoising the whole canvas toward the prompt; the number of passes is the step count. Token — the word-piece a language model actually reads and writes; part five is the close-up. Mixture-of-experts — a model that wakes only a fraction of its parameters per token; part two is the anatomy. Residency — which models' weights are sitting in the card's memory right now; a model that isn't resident pays a load before it can work. Compute contention — two workloads wanting the same silicon in the same moment; it costs fractions of a second, and only while both are working. Residency contention — two workloads wanting the same memory, so one must be evicted and reloaded before it can work; it costs whole seconds, and strikes on every hand-off, even when the machines take polite turns. This piece measured both.