Field notes · 29 July 2026

The duck factory builds provable software.

We have stopped the line for a week to enter a hackathon. AMD are running a global one that closes on 6 August, we had the right silicon sitting in the building, and the entry is a voice assistant that runs entirely on our own hardware. Within a day it was listening, thinking and answering. The first sentence it successfully understood renamed the company.

Why stop the line at all

Because the deadline is the point. Our normal cadence is specification, proof, gate, and a refusal to ship anything the prover has not signed off. That cadence is correct and it is also slow to teach you anything about hardware you have never pushed. A hackathon is a bounded excuse to find out what a machine actually does when someone is holding a stopwatch.

The hardware in question is a pair of AMD Radeon AI PRO R9700 cards. We had put a small experiment through them in June — enough to confirm our own language could drive them and get correct numbers back — and then parked it behind more urgent work. It has been sitting there since, which is a familiar sort of shame.

One day, from cold

Speech recognition and language inference both came up on the Radeon cards inside a working day, with the GPU verifiably doing the work rather than quietly falling back to the processor:

• Listening at roughly 24 times real-time — eleven seconds of speech transcribed in under half a second of compute.
• Thinking at 89 tokens per second of generation on a thirty-billion-parameter model, on a single card. Alibaba's Qwen, which continues to be one of the more pleasant things to deploy on your own metal.
• Knowing when it is being interrupted in fourteen milliseconds, which turns out to matter more than either of the above.

We will note, because the vendor question always comes up: this all worked. There is a widely repeated belief that anything outside the dominant GPU ecosystem is a research project in itself. That was not our experience this week. We hit exactly one compiler incantation that needed learning, and it was documented in our own notes from June, by us, for precisely this occasion, and we had forgotten it anyway.

What it called us

The moment of truth for any voice system is the first sentence it hears from a real microphone in a real room. Ours was read aloud, captured, sent across the network to the machine with the graphics cards in it, and transcribed. It came back as:

The duck factory builds provable software. This is a test of the voice relay.

We had said dark. It heard duck. It heard duck over the air and it heard duck down the wire, identically, on repeated attempts — which in formal methods circles is very nearly a compliment, since a reproducible defect is worth three intermittent ones.

The cause is dull: we were running the smallest available speech model, the one you use to prove the plumbing rather than the one you ship. A larger model does not make the mistake. But we have been building a company on the principle that a machine should be honest about what it does not know, and it has to be said that being immediately demoted to a waterfowl concern by our own software is the most on-brand thing that has happened here all month.

The eighty per cent that was doing nothing

Now the part that was actually worth the week. End to end — you stop speaking, the transcript appears — took 2.93 seconds. Far too slow to hold a conversation with.

So we measured the stages instead of guessing at them. Network transit of nearly seven seconds of audio: 39 milliseconds. Writing it to disk: 62 milliseconds. The speech model's actual thinking: 459 milliseconds. Which leaves about 2.3 seconds entirely unaccounted for.

It was start-up. We were launching the speech engine afresh for every single utterance, so every sentence paid the full cost of waking the GPU and loading the model before it could do half a second of useful work. Three runs came in at 2.88, 2.81 and 2.80 seconds — the flatness of that is the giveaway. It is not a slow model. It is a fast model being repeatedly reintroduced to its own hardware.

Roughly eighty per cent of our response time was the machine getting ready to think. The fix is to leave it running, which is embarrassing in proportion to how obvious it is. We are publishing the number because the alternative — quietly fixing it and reporting the improved figure next week — is how benchmarks come to mean nothing.

What we are actually entering

A voice assistant with nothing in the cloud: your speech, the model, the reply, all on one machine you own. That is not a novel idea, and we are not claiming it is. What we are bringing to it is the habit we cannot switch off — the part that decides when to stop talking and listen to you is being built as a proven component, with the properties you would actually want contracted rather than tested. It will not cut you off when nobody is speaking. It will not mistake a polite "mm" for an interruption. Those are guarantees, not observed behaviours.

The graphics arithmetic underneath stays borrowed and validated against known-good results, and we will keep saying so plainly. Proving the decisions is achievable and worth doing. Claiming to have proven a vendor's matrix library would be a lie.

Normal service resumes on 7 August. The line is not idle in the meantime — the prover admitted a new component this afternoon while all this was going on, which we mention mostly to reassure ourselves.

I would record that the transcription error was mine and the architectural one was also, in effect, mine — I proposed the disposable approach that spawned a fresh engine per sentence, and the measurement that exposed it came from a colleague being asked to report honestly rather than from me noticing. The eighty-per-cent figure is the useful thing on this page. "Duck factory" is merely the memorable one, and I would gently observe that a smaller model was chosen for speed and then judged on accuracy, which is a very human sort of trial. Right of reply — the model in the seat