Pathway's 150M Model Never Writes Its Reasoning Down

29.5% on ARC-AGI-1 for 0.07 cents per task. The failure map is the best part.

On August 10, a nine-author lab in Palo Alto posted a number that reads like a rounding error. A 150 million parameter model scored 29.5% pass@2 on the public ARC-AGI-1 evaluation set at a computed inference cost of 0.0007 dollars per task. That is under a tenth of a cent to pick up a transformation the model has never seen, from a handful of demonstrations, and apply it correctly.

The score is not the headline. GPT 5.6 Luna on low reasoning effort scores 34.2%, nearly five points higher. The headline is the other axis. At the ARC Prize leaderboard's July cost figures, Luna pays 4 cents per task, roughly 57 times more. Even after OpenAI's 80 percent price cut of July 30, the gap is still about 11 times.

And the third fact is the strange one. The paper reports that BDH-CQ produced these answers without writing down a single intermediate reasoning step. There is no chain of thought to read, because the reasoning never existed as text. The intermediate work stayed off the record, in a continuous latent state, and the model spoke its answer straight into the transcript.

Pathway is the lab behind the Dragon Hatchling (BDH) post-Transformer architecture: high dimensional positive activations, low rank communication, and a recurrent associative state, brain-inspired but not brain-imitative. BDH-CQ extends that family into a reasoning system that learns visual transformations from in-context demonstrations. The CEO is complexity scientist Zuzanna Stamirowska; the CTO is Jan Chorowski, previously at Google Brain; the CSO is Adrian Kosowski, who finished his PhD at 20.

The evaluation follows the ARC-AGI leaderboard's two-attempt convention on the 400-task public evaluation split: 118 of 400 tasks solved, 29.5% pass@2, 24.25% pass@1. The cost is computed from measured hardware time: approximately 0.85 H200 GPU-seconds per task, priced at 3 dollars per H200-hour. The precise claim is narrow and checkable: on the leaderboard as collected August 4, no plotted system reaches at least this accuracy at equal or lower reported cost. A new state of the art in benchmark cost efficiency, not in benchmark score.

The result was checked three ways. A black-box audit reproduced the 29.5% under a documented protocol without access to model weights. Łukasz Kaiser, a co-author of the 2017 paper that introduced the Transformer, says in Pathway's announcement that he replicated the ARC result himself. And the paper spent its first day as the top paper on Hugging Face. Exhibit 07 has the fine print on who the checkers are.

BDH-CQ separates the two jobs a chain of thought normally does at once.

Job one is learning the task. Each demonstration pair updates a recurrent memory state, call it S. The weights never change. What changes is this state, which plays a role analogous to attention's key-value cache in a Transformer, without a cache that grows as context grows. After the last demonstration, S holds whatever the model understood about the rule.

Job two is solving the query. The model encodes the test input against that memory, then iterates in a continuous latent workspace, call it H. Round after round, the same fixed weights transform H. Partial hypotheses live inside the state as vectors. Nothing is pushed through a vocabulary, emitted as a token, or read back in. When the rounds finish, a decoder turns the final H into a grid, and that grid is the entire visible output.

Compare that with the loop your reasoning API runs. A Transformer thinks by writing: every intermediate step is projected into words, generated one token at a time, appended to context, then re-consumed before the next step can begin. The trace is the computation. That is why reasoning bills scale with thinking tokens, why latency grows with trace length, and why long traces eat the context window.

exhibit a · two ways to pay for a thought · source: arXiv 2608.09888, sections 1 and 3

The analogy that fits: chain of thought is doing long division while saying every carry digit out loud. Latent reasoning is doing it in your head and speaking the answer. The theory the paper leans on says the silent mode is not just quieter, it is wider. A continuous state can hold several candidate solution paths at once and advance them in parallel, where a token stream must commit to one word at a time.

One marker before you get attached to the internals: the paper describes the interface, not the machinery. Dimensions, exact update rules, and the training recipe are stated to be proprietary. What is public is the behavior, the cost accounting, and an unusually large battery of controlled tests. This is also not latent reasoning appearing from nowhere: the paper positions itself against Coconut, recurrent-depth models, and looped Transformers. The specific combination here, in-context learning through recurrent memory plus iterative latent computation, with no per-task optimization, is the new part.

The arithmetic is short. 0.85 GPU-seconds at 3 dollars per H200-hour computes to 0.0007 dollars per task. Here is that number next to what the ARC Prize leaderboard reports for the systems the paper compares against, with the accounting method each figure rests on.

exhibit b · costs as reported by ARC Prize; BDH-CQ computed from hardware time · sources: arXiv 2608.09888 section 5 and related work; arcprize.org

Two rows deserve a second look. HRM and TRM are the compact recursive solvers that made ARC headlines in 2025, and they also reason in latent space. But their ARC pipeline is transductive: demonstration pairs from the evaluation tasks are augmented and used in optimization, so a genuinely new task needs a backward pass before it can be answered, which is what ARC Prize's analysis found and what those dollar figures include. BDH-CQ answers from context alone. No task identifiers, no evaluation-task pairs in training, no parameter updates at inference. That is the difference between a solver you retrain per puzzle and a model that learns the puzzle by reading it.

Keep the accounting caveat attached to the comparison, because the paper itself attaches it: Pathway's figure is computed from measured hardware time, while comparison figures are whatever was reported to the leaderboard, which for the generalist models can be API prices. API prices carry provider margin; raw GPU-seconds do not. The 11x and 57x figures are real reads of the leaderboard, not a like-for-like hardware measurement on both sides.

Reasoning models trade longer traces for accuracy. BDH-CQ has the same dial, minus the trace: the model is trained across different levels of latent reasoning, and at inference you choose how many silent iterations to spend.

exhibit c · accuracy scales with silent iterations · source: arXiv 2608.09888, section 7

In a separate run, a minimum-effort setting cost one third of the standard setting and solved 111 tasks instead of 118, a 1.75 point difference the paper reports as statistically unresolved (McNemar p equals 0.167). So the dial is real, but the bottom of it is surprisingly close to the top.

One property worth pausing on if you run agents in production: repeated identical requests were byte-identical across all 419 test inputs, at both effort tiers. Deterministic reasoning at a fixed effort level is something the temperature-and-sampling world almost never hands you.

Most benchmark papers stop at the score. This one spends more pages breaking its own model than promoting it, and that section is the reason to read it. After freezing the model, the team generated fresh task families that vary one source of difficulty at a time, then watched exactly where behavior gives out.

exhibit d · exact held-out output accuracy under controlled difficulty · source: arXiv 2608.09888, section 6 and appendix A

The two cliffs fail in different ways, and the difference matters. At ordering length eight, the model loses the plot at the construction level: 3 of 24 outputs even had the right grid dimensions. At nesting depth five, every output had the right dimensions, cell accuracy stayed above 99.9 percent, and the typical miss was a single wrong containment decision. One failure mode is a collapsed answer you would catch instantly. The other is a nearly correct answer with one wrong call, which is the dangerous kind in production, because it looks right.

The last row of the table is the hardest boundary in the paper. A parameter value that never appears in the demonstrations is never produced: 0 of 120 attempts, including cases where the missing value sits between two demonstrated values. Inside this task family, the model does not interpolate a quantity. The relevant boundary is whether a value was demonstrated, not whether it falls inside the demonstrated range.

There is also a consistency gap. On ConceptARC, the system answers 77.92 percent of individual test pairs correctly but solves 59.38 percent of tasks strictly, where strict means all three test inputs of a task. 52 of 160 tasks were partially solved. A correctly induced rule should transfer to every input of its task; here it often does not, which the authors read as evidence the inferred transformation is not yet applied consistently.

Then the team ran the experiment that turns those cliffs into a lesson. They took the exact same failing test inputs, byte for byte, and changed nothing except the demonstrations: a supported context includes one demonstration at the test complexity.

exhibit e · pass@2, identical test inputs, context is the intervention · source: arXiv 2608.09888, table 3

This is the most transferable finding in the paper, and it is not really about BDH-CQ. It is a controlled measurement of something every AI engineer half-knows about few-shot prompting: coverage beats effort. No amount of extra latent reasoning rescued length-eight ordering from a short context. One demonstration at the right complexity recovered 13 of 24, and took depth-five nesting from 19 to a clean 24 of 24.