Paper of the Week #1 — A 150M-Parameter Upset, and the Week of the Harness
Four papers that mattered this week: BDH-CQ, a 150M model that reasons in latent space (main pick); StateM, buying 9 points for $38 of harness; EnvHarness, turning environments into training assets; and Apodex 1.1's AgentOS direction. One thread: the gains came from the harness, not the weights.
Paper of the Week #1 -- A 150M-Parameter Upset, and the Week of the Harness
Welcome to the first issue of Paper of the Week: one paper reviewed in depth, the rest briefly but with substance. The selection criterion is simple -- papers that change how you build something after reading them. Not citation counts, not lab names; whether there's an idea a practitioner can take home.
The thread running through this week (Aug 17–26, 2026), up front: the performance gains did not come from model weights. The main pick is a model that broke a reasoning benchmark's cost-accuracy curve with 150M parameters, and the other three papers all improve performance by changing the *execution environment* around a frozen model. I don't think that's a coincidence.
Main Pick: BDH-CQ -- the 150M Model That Thinks Without Talking
BDH-CQ: In-Context Learning with Recurrent Latent Reasoning (Engdahl, Kosowski, Chorowski et al., Pathway, Aug 10) · HF ▲754
What They Did
29.5% pass@2 on the ARC-AGI-1 public eval set at roughly $0.0007 per task. The accuracy itself is far below frontier models -- but at that price, that accuracy sits outside the previously reported cost-accuracy Pareto frontier. Model size: 150M parameters. GPT-2-small territory.
How -- "Reasoning Without Verbalizing"
The core of the paper is one sentence in the abstract:
Inputs presented at inference time continuously update the model's recurrent memory; the model then solves a query through iterative computation in a high-dimensional latent space, without verbalizing its intermediate reasoning.
Today's mainstream reasoning models (the o-series, R1, and descendants) think by emitting chain-of-thought as tokens. Every step of thought is text generation, so the cost of thinking scales with token count. BDH-CQ goes the other way. Examples presented at inference time continuously update a recurrent state, and the query is solved by iterating in a high-dimensional latent space on top of that state. No intermediate reasoning is ever verbalized -- which is how $0.0007 per task becomes possible.
The base architecture is BDH (Baby Dragon Hatchling, arXiv:2509.26507), which Pathway published in 2025 as a bridge between transformers and models of the brain. Three things distinguish it:
- Attention emerges from local neuron interactions, not matrix multiplication. Instead of centralized dense operations, computation is local, on a scale-free graph.
- Short-term memory lives on synapses. Rather than accumulating context in a KV cache, the model adjusts synaptic weights during inference via Hebbian learning. "In-context learning" is implemented, literally, as synaptic plasticity.
- Activations are sparse and positive, hence interpretable. The original paper reports naturally emerging monosemantic synapses that respond to specific concepts.
BDH-CQ pushes this "memory on synapses" design into few-shot reasoning. An ARC task requires inferring a rule from a handful of examples -- which maps exactly onto examples updating a recurrent memory.
Why It Matters
Three angles:
- A concrete win for the latent-reasoning camp. Whether reasoning must happen in language has been contested since COCONUT and the recurrent-depth line of work, and so far nothing beat large-model CoT head-on. BDH-CQ didn't fight head-on -- it won on the cost axis. Pushing the frontier toward "same accuracy at 1/100th the price" rather than "more accuracy" is strategically clever.
- A different shape of test-time compute. Instead of sampling more tokens, iterate more in latent space -- iteration count *is* the test-time compute. Unlike token-based scaling, that cost is independent of vocabulary and decoding.
- An existence proof for small models. That 150M parameters score meaningfully on ARC suggests what ARC demands is not *quantity of knowledge* but a *mechanism of adaptation*.
Read With Care
- Weights and model code are not released. The only public artifact is an ARC-style task generator, so 29.5% is currently unreproducible. Releasing a task generator strongly suggests synthetic ARC tasks were used for training -- in which case the key question is how much of the result is "training specialized to the ARC distribution."
- It's pass@2 -- ARC's official rule, but don't confuse it with pass@1.
- It's one benchmark. Whether the mechanism transfers to math or code reasoning is unknown.
The consolation: the base BDH architecture is open under MIT (pathwaycom/bdh) -- a 171-line model definition plus a training script. We trained a mini BDH on a single A100; results and the notebook are at the end of this post.
Short Review 1: StateM -- Buying 9 Points for $38
StateM: Reaching 95.3% on Terminal-Bench 2.1 via Harness Scaling (Aug 15) · HF ▲441
Terminal agents mostly don't fail because the model is dumb. They lose track of state, skip steps of procedures, and give up early. StateM fixes this outside the model, with a runtime built on durable states, phase-local context, checked transitions, and recoverable runbooks.
The numbers are the argument. Without touching a single weight: GPT-5.5 goes 83.1→92.1%, DeepSeek-V4 Flash 82.7→88.1%. The DeepSeek case cost $38 of adaptation and ~$15 of execution, versus $574 execution cost for the GPT reference approach. "A good harness plus a cheap model" beating "an expensive model, bare" on cost is one of the most practically useful data points of the year.
The caveat: how much are those runbooks overfit to the benchmark's execution structure? The authors are upfront -- on BusinessBench, gains of up to 10.04 points appear only in "task families that share execution structure." Flip that around: for a domain with different execution structure, you rewrite the runbooks.
Short Review 2: EnvHarness -- the Environment Is a Trainable Artifact
EnvHarness: Awakening Static Worlds for Agent Learning (Aug 20) · HF ▲263
The bottleneck in agent RL isn't the model -- it's that environments are static. Hand-built worlds stay fixed while the agent improves, so the learning signal dries up. EnvHarness reshapes an environment's behavior through a programmable plugin layer without touching its underlying logic. The interesting part is the automation tool, EnvRigger: observe the agent policy as a black box → diagnose specific weaknesses → synthesize plugins that target them → validate on fresh rollouts. Policy-environment co-evolution, as a pipeline.
Results: up to +9.0 points on held-out cases across five benchmarks, 9.8% fewer execution steps. The frame matters more than the numbers -- environments treated not as fixed graders but as versioned, synthesized training assets. It's curriculum learning for agents, except the curriculum is written by a diagnostic loop instead of a human.
Short Review 3: Apodex 1.1 -- the "AgentOS" Direction
Apodex 1.1: Scaling Agentic Intelligence for Complex Work (Aug 24) · HF ▲179
A clean specimen of where frontier labs are converging. It scales along two axes: the range and verifiability of execution environments (filesystems, search, code execution) and agentic coordination (task decomposition, parallel distribution, asynchronous result merging, replanning). A unified harness the authors call an "AgentOS" tracks task state and documentation across tools and agents.
The spec worth noting: a 35B "Mini" version described as locally deployable. Long-horizon agents may stop being a frontier-API exclusive. Reading cautions: the benchmarks are self-reported without external validation yet, and the "working capability" framing defines its own measuring stick.
This Week's Thread: Weights Constant, Harness Variable
Put the four side by side and the picture emerges.
| Paper | Model weights | Where the gains came from |
|---|---|---|
| BDH-CQ | 150M (fixed) | Recurrent memory updates at inference |
| StateM | Untouched | A runtime managing state and procedure |
| EnvHarness | Untouched | Plugins reshaping the environment |
| Apodex 1.1 | Relatively small | Execution environments + coordination harness |
If last year's formula was "performance = bigger model + more CoT tokens," every paper this week mined performance from the model's periphery. The practical implication is blunt: if your agent system isn't working, suspect state management, procedure, and environment before you swap the model. StateM's $38-for-9-points is the proof.
Run It Yourself: Hatch a Mini Dragon
BDH-CQ is closed, but the base BDH architecture is 171 lines of open code. We trained a 25M-parameter BDH on tiny Shakespeare on a single A100. The short version:
- 14 minutes of training gets you Shakespeare-shaped generation -- byte-level, no tokenizer at all
- We measured the premise behind the interpretability claims: of 1.6B activation values on a validation batch, 79.8% are exactly zero
- You can also watch a 25M model overfit 1.1MB of text in real time (val loss bottoms at 1.47 around step 600)
The full cell-by-cell walkthrough is in the attached notebook.
See you next week for PoW #2. If there's a paper you want covered, let me know.
References
Subscribe to Newsletter
Related Posts
Reproducing Claude's Watermark Locally — SynthID-Text on an Open Model, With Detection and Removal Attacks
We applied SynthID-Text — the algorithm Claude adopted — to Gemma 2 2B and measured everything: why detection is impossible without the key, how many tokens it needs, why false positives explode on short text, and how one rewrite by a local 3B model erases the watermark.
How Claude's Text Watermark Works — Signing Text Without Changing a Single Token
Every piece of text Claude generates now carries an invisible watermark — with nothing added to the text. A step-by-step walkthrough of SynthID-Text: the secret key, tournament sampling, detection, and the honest limits.
Breaking the Reversal Curse with Identity Bridges — the ICML 2026 fix that shouldn't work but does
LLMs trained on "Alice's husband is Bob" famously fail on "Bob's wife is?" — the reversal curse. A new ICML 2026 paper fixes it by adding one weird kind of self-referential example to the training set. The naive version doesn't work; the right version does.