BDH-CQ: Recurrent Latent Reasoning for ARC

• BDH-CQ is a visual reasoning model that stores demonstrations in recurrent memory and iteratively solves queries in a continuous latent workspace before decoding the final grid.
• The 150-million-parameter model achieved 29.5% ARC-AGI-1 pass@2, or 118 of 400 tasks, at an estimated cost of approximately $0.00070 per task.
• Controlled evaluations show strong performance on contextual mappings, boundary propagation, and copying, but weaknesses in extrapolation, operation composition, segmentation, and consistent rule application across queries.

BDH-CQ is a visual reasoning model that combines in-context learning with recurrent latent reasoning for abstract visual tasks, particularly the Abstraction and Reasoning Corpus (ARC). Demonstrations are written into a recurrent contextual memory, a query is encoded with that memory, and the model performs iterative computation in a continuous high-dimensional latent workspace before decoding only the final output grid. A 150-million-parameter configuration achieved 29.5% ARC-AGI-1 pass@2 at an estimated cost of approximately $0.00070 per task (Engdahl et al., 10 Aug 2026).

1. Problem setting and motivation

An ARC task provides a small set of input–output grid demonstrations and one or more test inputs. The transformation is not named explicitly; it must be inferred from the examples and applied exactly to the test case. Relevant transformations can involve object identification, spatial relations, reflection, symmetry, counting, ordering, copying, translation, containment, panel operations, and compositions of several operations.

For a task with demonstrations $D=\{(x_t,y_t)\}_{t=1}^{K}$and a test input$x^\star$, BDH-CQ must infer a task-specific transformation and generate the corresponding output grid. ARC is suitable for evaluating in-context generalization because the demonstrations specify the task, outputs are exactly verifiable, and multiple test inputs reveal whether a model applies one inferred rule consistently rather than producing an isolated correct output.

BDH-CQ addresses a distinction between contextual adaptation and additional computation. Standard transformer in-context learning retains demonstrations in a token context or attention cache and performs a fixed forward computation. Verbal chain-of-thought performs additional computation through autoregressive text generation. BDH-CQ instead uses recurrent memory for demonstration-driven adaptation and repeated continuous latent-state updates for query solving. Intermediate hypotheses are not projected into a vocabulary or verbalized.

The intended conjunction is that recurrent memory supplies rapid task adaptation, while recurrent latent computation supplies additional inference depth after adaptation. The approach is not a symbolic program executor in the conventional sense. The paper characterizes the inferred behavior as a demonstration-conditioned operator schema: demonstrations bind a reusable visual operation for the current task, while the operation remains represented and executed internally rather than being extracted as an explicit symbolic rule (Engdahl et al., 10 Aug 2026).

2. Architecture and recurrent computation

BDH-CQ extends BDH, or Dragon Hatchling, a post-Transformer sequence architecture based on high-dimensional positive activations, ReLU and low-rank transformations, low-rank communication among latent features or neurons, linear-attention-like interactions, and a recurrent associative state. The architecture is inspired by local interaction, sparse activity, persistent state, and continual adjustment, but is not presented as a biological model.

The model separates computation into contextual memory, query reasoning, and input/output interfaces. For a sequence of demonstrations $D_t=(x_t,y_t)$, the contextual state evolves conceptually as

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

where $\theta$ remains fixed during inference. After $K$ demonstrations,

$$S_K=U_\theta\left(U_\theta\left(\cdots U_\theta(S_0,D_1),D_2\cdots\right),D_K\right).$$

This sequential update allows later demonstrations to interact with associations established by earlier ones. A simple illustrative special case is

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

although this is not the complete BDH-CQ implementation.

The query is initialized from both the test input and the final contextual memory:

$H_0=E_\theta(x^\star,S_K).$

The latent reasoning workspace is then recurrently updated:

$H_{r+1}=F_\theta(H_r,S_K), \qquad r=0,\ldots,R-1.$

After $x^\star$0 iterations, the output grid is decoded as

$x^\star$1

The abstract computation is therefore

$x^\star$2

The contextual memory $x^\star$3 represents task information accumulated from demonstrations, whereas $x^\star$4 is the query-specific workspace. The same contextual schema can be used to process multiple test inputs, although behavioral experiments show that BDH-CQ does not always apply an inferred transformation consistently across all queries in a task.

The evaluated system also includes input transformations, candidate construction, candidate ranking, and an inference pipeline that produces up to two candidates. The exact candidate-generation and ranking functions, internal dimensions, and recurrent update equations are not disclosed.

3. Latent reasoning and training

Latent reasoning denotes repeated transformation of continuous internal representations without decoding intermediate states into natural language. The intermediate states are $x^\star$5; only $x^\star$6 is decoded into an answer grid.

Compared with verbal chain-of-thought, BDH-CQ uses continuous hidden vectors rather than natural-language tokens, recurrent latent updates rather than autoregressive serialization, and no external decoding of intermediate states. The approach avoids vocabulary projection, token decoding, and additional context processing for every reasoning step. The paper argues that high-dimensional latent states can preserve multiple partial interpretations or candidate transformations without forcing them into a discrete linguistic form.

The principal model contains approximately 150 million parameters. Training uses a curated ARC-style mixture containing private curated examples, ARC-AGI-1 training data, RE-ARC, ConceptARC, ARC-Heavy, ARC-GEN100K, and additional augmentations. Task identifiers are not used, ARC-AGI-1 evaluation-task demonstration pairs are not used for training, and parameters are not updated at inference time.

The full training recipe is not disclosed. Specifically, the paper does not provide the optimizer, learning-rate schedule, batch size, number of epochs or update steps, exact augmentation distribution, grid tokenization and embedding details, exact number and dimensions of latent features, or complete recurrent update equations. Consequently, the reported systems result is not fully reproducible from the published description.

BDH-CQ includes three latent-reasoning effort levels:

Effort	pass@2	Cost relative to HIGH
LOW	21%	22% lower
MEDIUM	27%	11% lower
HIGH	29.5%	Baseline

The numerical values of $x^\star$7 associated with LOW, MEDIUM, and HIGH are not provided. A separate minimum-effort configuration cost $x^\star$8 per task, compared with $x^\star$9 for standard effort, and achieved 111/400 rather than 118/400 pass@2. The paired comparison was not statistically decisive: 105 tasks were solved by both configurations, 13 by the standard configuration only, and 6 by the minimum-effort configuration only; the two-sided exact McNemar test yielded $D_t=(x_t,y_t)$0. Repeated identical requests were byte-identical in both effort settings.

4. ARC-AGI-1 performance and cost

The public ARC-AGI-1 evaluation split contains 400 tasks and 419 test pairs. Under pass@2, the system produces up to two ranked candidates, and a task is counted as solved if either candidate exactly matches the required output under the benchmark protocol.

The reported results are:

Dataset or condition	Tasks	pass@1	pass@2	Pair pass@2
ARC-AGI-1 public	400	97/400 = 24.25%	118/400 = 29.50%	130/419 = 31.03%
ConceptARC, semantic IDs	160	73/160 = 45.63%	95/160 = 59.38%	374/480 = 77.92%
ConceptARC, opaque IDs	160	72/160 = 45.00%	96/160 = 60.00%	374/480 = 77.92%

The default model uses approximately 0.85 H200 GPU-seconds per task. At a stated cost of %%%%2$x^\star$2%%%%23}{3600\ \mathrm{s}}\approx $D_t=(x_t,y_t)$3$D_t=(x_t,y_t)$40.00070 per task.

The authors claim that this operating point lies beyond the previously reported ARC-AGI-1 cost–accuracy Pareto frontier: no plotted prior system reaches at least 29.5% accuracy at equal or lower cost. The paper compares it with GPT 5.6 Luna (Low), reported at 34.2% and $0.040 according to cited leaderboard data. Under that accounting, BDH-CQ is approximately 57 times cheaper; after a later public API price reduction not reflected in the cited leaderboard snapshot, the reported ratio becomes approximately 11 times.

The cost comparison is not necessarily homogeneous. BDH-CQ’s cost is computed from measured H200 time, whereas other systems may use API prices or hardware estimates. The paper also reports a black-box audit by co-authors associated with Bielik AI and NYU that reproduced the deployed system’s 29.5% pass@2 score. This constitutes supportive replication but not unrelated third-party replication.

5. Behavioral capabilities and controlled evaluations

ConceptARC contains 16 concept families, with ten tasks and thirty test pairs per family. Under semantic identifiers, the strongest pass@2 task-level results included FilledNotFilled and TopBottom2D at 9/10, ExtendToBoundary and CleanUp at 8/10, while Copy and Order reached 2/10 and InsideOutside and SameDifferent reached 4/10. Because each family contains only ten tasks, these estimates have broad uncertainty.

The difference between pair-level and task-level accuracy is substantial. In the semantic ConceptARC evaluation, 13 tasks had zero correct test pairs, 15 had one, 37 had two, and 95 had all three. Thus, 52 tasks had partial success without complete task success. This indicates that BDH-CQ can sometimes produce a correct output without applying one stable transformation consistently across every query in a task.

Replacing semantic task identifiers with cryptographically opaque labels and mixing concept families within batches produced nearly unchanged results: 95/160 semantic tasks versus 96/160 opaque tasks, with 374/480 test pairs correct in both conditions. This makes the combined identifier-and-batch manipulation an unlikely explanation for the aggregate score, but it does not independently exclude prior exposure during training, checkpoint-selection effects, benchmark leakage, or effects of the two interventions separately. First candidates agreed in 442/480 cases, complete ordered candidate lists in 276/480 cases, and attempt counts in 455/480 cases. In the opaque replication, all 75 single-candidate records were already correct at rank one, so pass@2 does not necessarily represent two independent stochastic attempts.

Controlled experiments demonstrated strong performance for some forms of contextual binding and extrapolation. A dense contextual mapping with a newly defined color permutation was solved on 96/96 held-out outputs at rank one while the number of simultaneous bindings increased from two to eight.

Other controlled results were operation-dependent:

Family	Result
Boundary propagation	48/48 correct across held-out distances 2–8
Copying	48/48 correct as target sites increased from 1 to 4
Ordering	Nearly saturated through length 5; 29/36 at length 6, 8/24 at length 7, and 1/24 at length 8
Nesting	Nearly saturated through depth 4; 29/36 at depth 5

Ordering at length eight usually produced incorrect output dimensions, with only 3/24 having correct dimensions. Nesting at depth five generally preserved dimensions and structure; mean best-candidate cell accuracy exceeded 99.9%, with errors often involving one containment decision. This suggests that ordering stresses global output construction, whereas nesting failures are more localized relational errors.

Demonstration coverage materially affected performance. For ordering at length eight, short demonstrations yielded 0/24 pass@1 and pass@2, whereas demonstrations containing one example at the target complexity yielded 12/24 pass@1 and 13/24 pass@2. For nesting at depth five, short demonstrations yielded 15/24 pass@1 and 19/24 pass@2, while supported demonstrations yielded 16/24 and 24/24. The results support an interpretation in which some apparent reasoning failures are extrapolation failures: performance improves when demonstrations cover the complexity required at inference time.

Composition was not uniformly robust. Across 72 held-out outputs per condition, relocation, reflection, rotation, and a demonstration-defined color swap achieved the following results:

Operation	Alone	Composed with relocation
Relocation	72/72	—
Reflection	72/72	47/72
Rotation	72/72	72/72
Color swap	26/72	0/72

Color swapping was representation-sensitive: it worked in the original fixed-layout motif family but reached only 1/24 in each shuffled family. The findings therefore indicate that composition depends on both the operation and its representation. Rotation composed robustly, reflection composed partially, and color swapping was unreliable outside an easier fixed-layout setting.

Additional structural interventions showed substantial effects from conditional selection, unseen parameters, panel structure, support-chain depth, and segmentation. Conditional rule selection declined from 100.0% to 56.7%; adding a third panel reduced performance from 65.0% to 2.5%; support-chain performance declined to 27.5% at the longest tested dependency depth; and a parameter absent from demonstrations reduced performance from 30.0% to 0.0%. These results indicate that difficulty is not determined solely by object count or the number of operations.

6. Failure modes, limitations, and significance

Among incorrect predictions, output dimensions were correct for 89.2% of generated-set failures and 89.7% of public-set failures. Palette correctness was 72.9% and 78.0%, respectively. Median cell error among shape-correct failures was 4.0% on generated data and 8.3% on public data. Verbatim input reproduction occurred in 8.4% and 4.6%, while insufficient target-edit coverage occurred in 15.5% and 7.8%.

These results indicate substantial partial recovery, but the latent architecture does not expose an interpretable reasoning trace. A near miss may reflect incomplete execution of a correct rule, an overly narrow or incorrect inferred rule, segmentation failure, candidate-construction or decoding error, or a latent hypothesis that preserves much of the target structure without being correct.

Several limitations constrain interpretation. The implementation is proprietary, and exact update rules, dimensions, optimizer details, and the complete training procedure are unavailable. The training mixture includes private data and several ARC-derived datasets, so exposure to related transformations or near-neighbor structures cannot be fully assessed. Generated-task behavioral experiments contain small samples, often 40 tasks per condition or ten tasks per ConceptARC family, and some generated tasks may be inconsistent with their demonstrations.

The cost–accuracy comparison is affected by differing accounting conventions across systems. Pass@2 attempts are not necessarily independent. The reported black-box audit was conducted by affiliated researchers rather than an unrelated organization. The demonstrated ARC result comes from a 150-million-parameter model; although the paper reports early Transformer-like scaling behavior from 1B to 600B in pretraining, it does not provide an ARC scaling curve showing how latent-reasoning performance changes with model size.

The strongest evidence supports the claims that BDH-CQ can update recurrent memory from demonstrations, solve queries through latent recurrence, improve performance with increased latent effort, bind dense contextual mappings, extrapolate certain simple operators, and exhibit operation-specific weaknesses. More interpretive claims include that recurrent memory is the specific mechanism responsible for in-context learning, that latent states preserve multiple useful reasoning paths, and that particular failures are caused by segmentation, execution depth, or rule induction rather than decoding or candidate ranking.

BDH-CQ’s principal significance is architectural and methodological. It demonstrates a separation between task adaptation and verbal reasoning: demonstrations can establish a task-conditioned operator schema in recurrent memory, while additional computation occurs in a continuous latent workspace and only the final grid is emitted. The reported results support cost-efficient recurrent latent computation for exact visual reasoning, while also showing that current performance remains sensitive to extrapolation, representation, conditional rule selection, segmentation, dependency depth, and consistent execution.