BDH-CQ: In-Context Learning with Recurrent Latent Reasoning

Abstract: 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.

• The paper introduces BDH-CQ, a 150M-parameter recurrent model that stores demonstrations in contextual memory and solves queries through continuous latent iterations without verbalized chain-of-thought.
• BDH-CQ achieves 29.5% ARC-AGI-1 pass@2 and 24.25% pass@1 at a reported cost of $0.00070 per task, establishing a strong accuracy–cost trade-off rather than the highest standalone accuracy.
• Controlled experiments show robust extrapolation for propagation, copying, and dense mappings, while ordering, nesting, conditional rule selection, unseen parameter values, and composition remain important limitations.

BDH-CQ: In-Context Learning with Recurrent Latent Reasoning

Research objective and central claim

“BDH-CQ: In-Context Learning with Recurrent Latent Reasoning” (2608.09888) investigates whether in-context learning and iterative reasoning can be integrated without representing intermediate computation as a sequence of natural-language tokens. The proposed system, BDH-CQ, processes task demonstrations into a recurrent memory, then solves a held-out query through repeated computation in a continuous latent workspace. Only the final grid is decoded.

The paper’s central claim is both architectural and empirical: a compact recurrent model can acquire previously unseen visual transformations from demonstrations at inference time, perform additional latent computation without verbalized chain-of-thought, and achieve a favorable accuracy–cost trade-off. On the 400-task public ARC-AGI-1 evaluation set, the 150M-parameter system obtains 29.5% pass@2 at a computed cost of \$0.00070 per task, using approximately 0.85 H200 GPU-seconds. This operating point is reported to exceed the previously established cost–accuracy Pareto frontier (2608.09888).

The result should be interpreted primarily as a systems and capability demonstration rather than as evidence that latent reasoning uniformly solves ARC. The behavioral experiments reveal substantial heterogeneity: some operators extrapolate across increased structural complexity, whereas ordering, conditional rule selection, parameterization by unseen values, and certain compositions remain difficult.

ARC as an in-context generalization testbed

ARC is particularly appropriate for the study because its tasks define transformations through a small number of input–output demonstrations. The system must infer a task-specific operator schema and apply it exactly to one or more held-out inputs. The format suppresses dependence on factual knowledge and linguistic fluency while exposing failures in object identification, relational abstraction, compositionality, and systematic generalization.

A typical ARC task is visually compact but computationally underdetermined from any individual example. In the illustrated task, demonstrations establish a relation between two binary panels, and the query requires applying that relation to new configurations. The task does not explicitly name the relevant operation, such as intersection or alignment; the model must infer it from the examples.

Figure 1: An ARC-AGI-1 task in which the transformation must be inferred from sparse demonstrations and applied exactly to a held-out query.

ARC also permits a distinction between isolated test-pair correctness and strict task correctness. A system may produce a correct output for one query while failing to apply the same inferred transformation to the remaining queries in that task. This distinction is important for evaluating whether the model has induced a reusable operator rather than generated locally plausible outputs.

Architecture: recurrent contextual memory and latent computation

BDH-CQ extends the Dragon Hatchling architecture, which is characterized by high-dimensional positive activations, low-rank communication, linear-attention-like updates, and recurrent associative state. The paper does not disclose the full update equations or implementation details, but describes two functionally distinct state variables.

First, demonstrations are ingested sequentially into a recurrent memory. For demonstrations $D_t$, the memory evolves according to a learned update of the form

$S_t = U_\theta(S_{t-1}, D_t).$

This mechanism differs from simply pooling demonstrations into a fixed task embedding. The recurrent state is updated after each example and can preserve associations between inputs and outputs across the demonstration sequence. It therefore serves as an inference-time adaptation substrate: the parameters remain frozen, but the contextual state changes as task evidence is consumed.

Second, after the demonstrations have been incorporated, the query is encoded together with the resulting memory and processed through recurrent latent iterations:

$$H_0 = E_\theta(x^\star,S_K), \qquad H_{r+1}=F_\theta(H_r,S_K).$$

The final latent state is decoded into the predicted output grid. The division between $S_K$ and $H_r$ is conceptually significant. The former stores task-conditioned information accumulated from demonstrations; the latter is an active computational workspace for solving the query. This separation gives BDH-CQ a structure analogous to fast adaptation followed by task execution, but without gradient updates or explicit natural-language reasoning traces.

The architecture therefore targets a different computational regime from standard chain-of-thought prompting. In a verbal CoT system, intermediate states are serialized into discrete tokens, generated autoregressively, and re-encoded as subsequent context. BDH-CQ retains those states in continuous activations. The intended benefits are lower token overhead, higher representational bandwidth, and the possibility of maintaining multiple partial hypotheses without explicitly enumerating them.

The paper’s claims are narrower than a claim that latent representations are inherently superior. Continuous states can support parallel or superposed computation, but they also reduce interpretability and make it difficult to determine whether a failure reflects incorrect rule induction, incomplete execution, or decoding error. The controlled ARC experiments are consequently essential: they provide behavioral evidence about what the latent system actually learns.

ARC-AGI-1 performance and cost efficiency

The primary benchmark result is 118 solved tasks out of 400 under pass@2, corresponding to 29.5%. Pass@1 is 24.25%, with 97 solved tasks. The difference indicates that the second candidate contributes measurable coverage, although the paper cautions that pass@2 is not always equivalent to two independent stochastic attempts. In the ConceptARC replication, all 75 single-candidate records were already correct at rank one, showing that candidate delivery and attempt generation can be structured rather than purely sampled.

The cost result is the paper’s strongest systems claim. At \$0.00070 per task, BDH-CQ is reported to be approximately 57 times cheaper than GPT 5.6 Luna (Low) at the leaderboard’s stated \$0.040 cost, although the ratio falls to approximately 11 times after accounting for a subsequent public API price reduction not reflected in the leaderboard data used for comparison. These comparisons depend on heterogeneous cost accounting conventions: BDH-CQ uses measured hardware time and an assumed \$3 per H200-hour rate, whereas other systems may use estimated hardware costs or API prices.

Figure 2: BDH-CQ’s 29.5% ARC-AGI-1 pass@2 operating point lies beyond the previously reported cost–accuracy Pareto frontier.

The result is therefore best understood as a cost-efficiency point, not as a state-of-the-art accuracy result in isolation. Systems with higher accuracy remain available at substantially greater cost. The significance lies in the combination of a small parameter count, inference-time adaptation, recurrent latent computation, and exact-task performance at very low marginal expense.

An independent black-box audit by collaborators from Bielik and New York University reportedly reproduced the deployed system’s 29.5% pass@2 score. This supports the reliability of the headline number, although it does not resolve questions about training-data exposure, checkpoint selection, proprietary implementation details, or the degree to which generated training mixtures overlap with evaluation concepts.

ConceptARC capability profile

ConceptARC provides a more granular account of BDH-CQ’s capabilities by organizing tasks into 16 transformation families. The paper emphasizes strict task accuracy, requiring all three test inputs within a task to be solved. Under semantic identifiers, BDH-CQ reaches 59.38% strict-task pass@2 and 77.92% test-pair pass@2. The 18.5 percentage-point gap is substantial: 52 of 160 tasks contain one or two correct test pairs but are not solved consistently as complete tasks.

This partial-transfer behavior challenges a simple rule-induction interpretation. If demonstrations bind a stable operator schema, the schema should apply to all held-out inputs under the same task specification. Instead, BDH-CQ often produces locally correct outputs without maintaining task-level consistency. The result suggests that the model may construct candidate transformations or partial procedures whose execution is sensitive to the particular query instance.

Performance is strongest on families such as FilledNotFilled, TopBottom2D, and ExtendToBoundary, and weakest on Copy and Order. Copy achieves 19/30 semantic test-pair successes but only 2/10 strict tasks, illustrating the difference between recognizing a transformation in some instances and applying it systematically across a task. Order is difficult both in ConceptARC and in the controlled scaling experiments.

The authors also test whether semantic task identifiers or concept-grouped batch contexts are responsible for performance. Replacing identifiers with cryptographically opaque labels and mixing concept areas within batches leaves aggregate results effectively unchanged: 374/480 test pairs are solved under both conditions, while strict-task pass@2 changes from 95/160 to 96/160.

Figure 3: ConceptARC performance is largely stable under the combined intervention of opaque identifiers and concept-mixed batching, while test-pair and strict-task accuracy remain substantially separated.

This replication weakens the explanation that the model relies directly on request-side semantic labels or batch organization. It does not, however, establish that the benchmark is free of training contamination or checkpoint-selection effects. Nor does it separately identify the effects of identifier opacity and batch composition, because both interventions are applied together.

Controlled generalization and the role of demonstration coverage

The paper’s most informative experiments freeze the model and evaluate newly generated ARC-like tasks in which one structural variable is increased while the underlying rule remains fixed. The four families manipulate propagation distance, the number of copies, sequence length for ordering, and nesting depth.

Figure 4: Controlled tasks vary propagation distance, copy multiplicity, ordering length, and containment depth while preserving the associated transformation rules.

Propagation and copying generalize robustly within the tested ranges. Propagation remains correct on 48/48 held-out outputs at both pass@1 and pass@2 as distance increases from the demonstrated range to distances 2–8. Copying likewise remains correct on 48/48 outputs as the number of target sites increases from one to four. These results indicate that BDH-CQ can bind a local operation and extend it to additional spatial instances without an immediate capacity ceiling.

Ordering and nesting expose different limits. Ordering is nearly saturated through five objects, but pass@2 accuracy declines to 29/36 outputs at length six, 8/24 at length seven, and 1/24 at length eight. At length eight, only 3/24 outputs have the correct dimensions, indicating a global output-construction failure rather than a small local mistake. Nesting remains strong through depth four but falls to 29/36 at depth five. In contrast to ordering, all depth-five outputs have correct dimensions, and mean best-candidate cell accuracy exceeds 99.9%; errors usually involve one containment decision.

Figure 5: Propagation and copying extrapolate across the tested ranges, whereas ordering and nesting exhibit sharply different transition regimes.

These results distinguish at least two failure mechanisms. Ordering appears constrained by the ability to construct and serialize a globally ordered output. Nesting is more often limited by extrapolation of relational depth: the model preserves the output structure but misclassifies one containment relation.

Matched-support experiments show that demonstration coverage is a major determinant of performance. Adding a demonstration at the target complexity raises depth-five nesting from 19/24 to 24/24 exact outputs at pass@2. For length-eight ordering, support improves performance from 0/24 to 13/24, but does not eliminate the deficit. The contrast indicates that the nesting failure is largely an extrapolation problem, while long ordering also imposes an execution bottleneck.

The finding has direct implications for in-context learning. Demonstrations do not merely identify a transformation category; they establish the range over which the model can reliably instantiate it. A model may possess an operator in a qualitative sense while failing when its parameterization exceeds the support represented in context.

Dense mappings and compositionality

BDH-CQ performs particularly well when the task consists of learning a dense, demonstration-defined mapping. In a color-permutation experiment, the system solves all 96 held-out outputs at rank one as the number of simultaneous bindings increases from two to eight. This is strong evidence that the recurrent memory can encode and retrieve multiple task-specific associations introduced exclusively at inference time.

Compositionality is less uniform. In a motif experiment, relocation, reflection, and rotation are each solved independently on all 72 held-out outputs. Rotation composes with relocation perfectly, also reaching 72/72. Reflection composed with relocation reaches 47/72, while color swap is solved in isolation on only 26/72 pooled outputs and never succeeds when composed with relocation.

Figure 6: Motif experiments compare atomic transformations with their compositions, revealing operation-dependent compositionality.

The color-swap results are especially informative because the difficulty is partly representation-dependent. In the original motif family, the fixed layout makes the swap easier to infer; in two shuffled families, performance falls to 1/24 per family even without composition. Thus, the failure cannot be attributed solely to composition. The model’s ability to compose operations depends on whether each constituent operation is robustly represented and whether the motif distribution provides stable cues for identifying it.

This result qualifies broad claims about compositional generalization. BDH-CQ can compose some spatial operations, but composition is not an invariant property of the architecture. It depends on operator identifiability, representation regularity, and the interaction between transformation stages.

Reasoning effort and inference cost

The paper evaluates three latent reasoning-effort settings. Increasing effort improves pass@2 while increasing cost:

• Low: 21% pass@2 and 22% cost reduction relative to high effort.
• Medium: 27% pass@2 and 11% cost reduction.
• High: 29.5% pass@2 at the reference cost.

The reported trade-off demonstrates that recurrent latent computation functions as a controllable test-time compute budget rather than as a fixed architectural overhead.

Figure 7: Increasing latent reasoning effort improves pass@2 while producing a predictable increase in inference cost.

A separate minimum-effort comparison reduces cost from \$0.00265246 to \$0.00088399 per task, approximately one third of standard effort, while reducing pass@2 from 118/400 to 111/400. The paired difference is not statistically resolved by the reported McNemar test ($p=0.167$), so the data do not establish a significant accuracy loss under that particular comparison.

Repeated identical requests are byte-identical at both effort levels. This repeatability indicates that the deployed inference pipeline is deterministic, or sufficiently constrained that repeated calls do not generate independent candidate trajectories. Consequently, increasing nominal attempts or reasoning effort should not automatically be interpreted as stochastic search.

Training mixture, reproducibility, and limitations

The 150M-parameter model is trained on a mixture of privately curated and public ARC-style data, including ARC-AGI-1 training tasks, RE-ARC, ConceptARC, ARC-Heavy, and ARC-GEN100K, with additional augmentations. The paper reports the interface and data provenance but withholds the complete training recipe and proprietary architectural details.

This limits independent reproduction and complicates attribution. The headline score could reflect the architecture, the training mixture, the augmentation strategy, the inference pipeline, candidate ranking, or interactions among them. The paper’s controlled post-freeze experiments reduce some ambiguity about behavioral mechanisms, but they do not isolate the contributions of each training source or component.

The generated evaluation analyses have related limitations. Mechanic-specific solve rates vary from 68.6% for flood fill to 2.9% for gravity and stacking, but the tasks were authored by GPT-5.6 and may differ in construction quality and difficulty. Hand-written comparisons show large discrepancies for some mechanics, including gravity and counting. The authors appropriately treat these results as properties of the generated distribution rather than intrinsic rankings of visual operations.

Other controlled ladders identify strong deficits in conditional rule selection, unseen parameter values, panel union, and support-chain depth. For example, selecting between two rules based on a varying cue reduces accuracy from 100% in a control condition to 56.7%; changing from two to three panels in a union task reduces accuracy from 65.0% to 2.5%; and support-chain accuracy declines from 80.0% to 27.5% as dependency depth increases. These measurements are useful diagnostic evidence, but each ladder is tied to a particular puzzle family and should not be generalized automatically across all ARC mechanics.

Theoretical and practical implications

Theoretically, BDH-CQ supports a view of in-context learning as recurrent state modification followed by iterative computation. This formulation separates task acquisition from query execution without requiring parameter updates. It also provides a concrete setting in which latent reasoning can be evaluated behaviorally: controlled changes in demonstration coverage and transformation structure reveal whether the system extrapolates, composes, or fails.

The results suggest that latent reasoning should not be characterized by a single scalar “reasoning ability.” BDH-CQ exhibits distinct profiles for contextual binding, local propagation, multiplicity, relational depth, ordering, conditional selection, and composition. These dimensions can dissociate sharply. For example, the model achieves perfect performance on dense color mappings and propagation ladders while failing almost completely on unsupported length-eight ordering.

Practically, the cost profile makes the architecture relevant to high-volume inference workloads in which exact outputs can be automatically verified. Low-cost recurrent latent computation could support proposal generation, constraint solving, program induction, and candidate enumeration, particularly when natural-language rationales are not required. The absence of decoded intermediate reasoning is also advantageous when token bandwidth, latency, or output-format constraints dominate.

The principal practical limitation is observability. Latent states do not provide an immediately inspectable proof or program. For safety-critical or scientific applications, future systems will need auxiliary verification mechanisms, external interpreters, uncertainty estimates, or hybrid modes that decode intermediate steps selectively. The paper’s own conclusion points toward such a combination: continuous internal computation for efficiency, supplemented by verbalized reasoning when communication, tool use, or auditability is required.

Future developments are likely to involve scaling both model size and recurrent depth, improving training curricula for extrapolation, and introducing explicit mechanisms for structured operator composition. Demonstration selection may become an important control variable: examples could be chosen to cover the anticipated range of relational depth, sequence length, or parameter values. External verifiers and search procedures could also compensate for the current distinction between correct local outputs and consistent task-level execution.

Conclusion

BDH-CQ demonstrates a specific and technically substantive integration of inference-time contextual adaptation with recurrent latent computation. Its 150M-parameter model reaches 29.5% ARC-AGI-1 pass@2 at a reported \$0.00070 per task, establishing a strong cost-efficiency result rather than the highest absolute benchmark accuracy. The controlled experiments show that recurrent memory can bind dense mappings and support robust extrapolation for propagation and copying, while ordering, nesting, conditional selection, unseen parameter values, and operation composition expose structured limitations.

The broader contribution is methodological as much as architectural. By separating contextual memory from latent query computation and evaluating both through controlled ARC interventions, the paper provides evidence that latent reasoning can be studied as a set of distinct computational capabilities. Further progress will depend on scaling, improved coverage-aware curricula, systematic composition mechanisms, and hybrid latent–verbal interfaces that combine computational efficiency with interpretability and verification.