We introduce BDH-CQ, a reasoning model that combines in-context learning with recurrent latent reasoning. 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. We evaluate the model on the public ARC-AGI-1 evaluation set and use controlled ARC-like interventions to study what it learns from demonstrations, how consistently it applies an inferred transformation, and which concepts remain difficult. A 150M-parameter configuration reaches 29.5% pass@2 at a computed inference cost of \$0.0007 per task. This operating point breaks through the previously reported ARC-AGI-1 cost-accuracy Pareto frontier, establishing a new state of the art in benchmark cost efficiency.
Alex: Welcome to another episode of ResearchPod. Today we're looking at a paper about a model called BDH-CQ. The central question it asks is surprisingly practical: can a system learn a new task from just a handful of examples, and then solve it without writing out every step of its thinking?
Sam: Why would writing out every step be a problem?
Alex: Because most AI systems today do their reasoning by generating lots of words before they land on a final answer. That gives them room to work through a problem, but it also makes them slower and more expensive to run. BDH-CQ tries a different approach: it keeps the working-out part hidden inside the model, like a scratchpad it never has to read aloud.
Sam: So the model is still thinking, just not in words?
Alex: Exactly. Think of it like a student who solves a maths problem in their head instead of writing every step on paper. The model updates a hidden workspace over and over, using the examples it has seen, until it has a confident answer. The paper calls this a latent reasoning workspace — "latent" just means hidden, not spoken.
Sam: And what kind of puzzles are they using to test this?
Alex: They use something called ARC — the Abstraction and Reasoning Corpus. These are small grid puzzles. Each one shows you a few examples of an input grid and its matching output grid, and your job is to figure out the rule and apply it to a new grid. So if the examples all show a pattern shifting one square to the right, you have to do the same thing to the test grid.
Sam: That sounds like a clean way to check whether the model actually understood the rule, rather than just guessing.
Alex: Precisely. And that is exactly why the paper uses them. A lucky guess might get one output right, but if the model truly learned the rule, it should apply it consistently across every new case it sees. The paper checks both things: whether the model gets individual outputs right, and whether it follows the same rule across an entire task.
Sam: So what did they find?
Alex: Performance varied quite a bit depending on the type of visual change involved. When the task was something simple — like moving a shape to a new position, or copying a pattern to several spots — the model handled it well and stayed consistent. But when tasks required keeping several objects in a specific order, or tracking one pattern nested inside another, accuracy dropped.
Sam: Why would ordering or nesting be harder?
Alex: Because they require the model to juggle multiple relationships at once. Moving a shape is a single, local change. But ordering means keeping track of which object comes first, second, third — and getting any one of those wrong breaks the whole output. Nesting means preserving a relationship where one pattern sits inside another, and the model sometimes gets the structure right but makes one wrong inside-or-outside call. So these are two different kinds of failure, not just one general weakness.
Sam: That distinction seems useful — knowing how a model fails, not just that it fails.
Alex: It is. And the paper goes one step further: when the authors gave the model demonstration examples that matched the complexity of the test task more closely, performance improved. That points to a clear mechanism. The hidden workspace can carry a rich mapping from the examples, but it still depends on having seen the right level of structure in those examples.
Sam: So the examples themselves shape what the model can do.
Alex: Yes. The model is not just memorising the examples — it is using them to build an internal pattern that it then applies to the new puzzle. Better examples mean a better internal pattern.
Sam: Okay, and the cost side of this?
Alex: That is where the paper makes its most concrete claim. On the standard public ARC benchmark, the smaller version of the model — about 150 million parameters, which is quite compact by modern standards — reached a score of roughly 29.5% on a measure called pass@2. And it did that at a cost of less than one tenth of a cent per puzzle.
Sam: Is that cheap?
Alex: The authors say it sits beyond the previously reported cost-versus-accuracy frontier, meaning no other system they compared against matched that level of accuracy at the same or lower cost. So yes, by the comparisons in the paper, it is notably efficient.
Sam: And the paper also shows that you can spend more internal computation to get better accuracy?
Alex: Right. The system can run its hidden reasoning for more steps when needed, and that extra effort does improve results — but it also raises the cost. So the trade-off is built into the design. The idea is to use just enough hidden thinking to solve the puzzle, rather than paying for long written reasoning every time.
Sam: So it is not that the model is cheap because it is doing less work. It is cheap because the work it does is more compact.
Alex: That is a good way to put it. The efficiency comes from keeping the reasoning internal and continuous, rather than spelling it out word by word.
Sam: What does the paper say about where this goes next?
Alex: The authors point toward testing this kind of internal reasoning on harder visual tasks — ones with more complex composition — and potentially other domains where careful, multi-step refinement matters. They also suggest that future systems could mix internal computation with verbal reasoning when it is genuinely useful, for instance when a model needs to explain itself or check its own work.
Sam: So the vision is not silent reasoning forever — it is knowing when to think quietly and when to speak.
Alex: Exactly. And that is probably the most measured way to read this paper's contribution. It is not claiming the problem of visual reasoning is solved. It is showing that latent, hidden reasoning can be made compact and practical, that the failures it produces are structured and informative rather than random, and that there is a meaningful efficiency gain to be had — with clear room still to improve.
Sam: A compact system, careful behavioural tests, and a strong efficiency result, with the limits visible rather than papered over.
Alex: That is the sober summary. Thanks for listening to ResearchPod.