BDH-CQ: In-Context Learning with Recurrent Latent Reasoning — part 1/3
Cleaned-text code points [0, 15992). Bibliography omitted here; source.md includes it.
# 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—less than one-tenth of a cent. 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.
## 1 Introduction
In-context learning allows a model to acquire a new skill from examples presented at inference time ( Brown et al., 2020 ) . In autoregressive language models, chain-of-thought (CoT) prompting complements this capability with a computational workspace: demonstrations specify what to do, while generated intermediate tokens support the computation required to do it ( Nye et al., 2021 ; Wei et al., 2022 ) . Reinforcement learning on verifiable problems has made this combination increasingly powerful, eliciting long reasoning traces, self-verification, and adaptive solution strategies ( DeepSeek-AI et al., 2025 ) . It also couples reasoning to serial narration. As reasoning traces have grown, so have token consumption, latency, and inference compute. Every intermediate state must be projected through a discrete vocabulary, emitted autoregressively, and consumed again before computation can continue.
Latent reasoning opens a different computational regime. Instead of verbalizing every intermediate result, a model repeatedly transforms its continuous hidden state and decodes only the answer. This removes natural-language tokens as the mandatory representation of internal computation and allows a state to preserve partial hypotheses or candidate transformations without serializing each one. Continuous-thought and recurrent-depth models show that this form of computation allows for advanced reasoning by exploring multiple solution paths in parallel ( Hao et al., 2024 ; Geiping et al., 2025 ; Saunshi et al., 2025 ) . The separation is also consistent with evidence that human conceptual reasoning and language rely partly on distinct systems ( Fedorenko and Varley, 2016 ) .
Yet latent reasoning and in-context learning have largely developed separately. Chain-of-thought reasoning language models learn flexibly from context but usually allocate additional computation through generated tokens. Compact recursive solvers reason iteratively in latent space, but their ARC pipelines learn evaluation tasks through optimization and task-specific identities ( Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ; ARC Prize Foundation, 2025 ) . They do not acquire an unseen transformation solely from demonstrations during inference.
We introduce BDH-CQ, a reasoning system that brings these capabilities together. Demonstrations of a previously unseen task update recurrent memory; the query is then solved through iterative computation in a high-dimensional latent workspace. Intermediate reasoning states are not decoded into language. BDH-CQ makes memory, adaptation, and inference part of the same computational fabric. Neither task identifiers nor evaluation-task demonstration pairs participate in training, and no parameters are updated at inference time. A 150M-parameter configuration reaches 29.5% pass@2 on ARC-AGI-1 at a computed $0.00070 per task, breaking through the previously reported cost–accuracy Pareto frontier.
We use the Abstraction and Reasoning Corpus (ARC) as both an evaluation and an experimental substrate ( Chollet, 2019 ) . ARC specifies new visual transformations through sparse demonstrations and requires exact outputs, making learning and rule consistency directly inspectable. We use the term demonstration-conditioned operator schema for the behavior that results when demonstrations bind a reusable visual operation for the current task. The controlled experiments test what such schemas can bind, how far they extrapolate, which ones compose with one another, and where their execution fails.
Our contributions are: • We introduce BDH-CQ, which combines in-context learning through evolving recurrent memory with iterative reasoning in a structured continuous latent space.
• We establish a new state-of-the-art point on the public ARC-AGI-1 cost–accuracy frontier: 29.5% pass@2 at a computed $0.00070 per task, and describe the ARC-style data mixture used to train the system.
• We map capabilities and failure modes across concept-organized transformation families, separating isolated correct outputs from consistent rule application.
• We use controlled ARC-like tasks to test what concepts the new reasoning system can learn and express from demonstrations.
We close by outlining how the same architecture can be extended through model scaling, longer training, language and mathematical reasoning, constraint satisfaction, and harder ARC tasks.
The paper first describes the system and its training and then presents the evaluation and behavioral analyses. The behavioral analysis of the evaluation sets is presented in the appendix.
## 2 ARC as a controlled, verifiable testbed for BDH-CQ’s in-context generalization
ARC was designed to study skill-acquisition efficiency : not only whether a system possesses a skill, but how much experience and prior structure it requires to acquire one ( Chollet, 2019 ) . Each task specifies a new transformation through only a handful of demonstrations. The system must infer which objects, relations, and operations matter to derive a transformation rule and apply the resulting rule to a new input. ARC therefore operationalizes the fast generalization that in-context learning is intended to provide.
This task format also makes the behavior of BDH-CQ accessible to controlled analysis. The demonstrations constitute the task specification, while the small colored grids require little factual knowledge or linguistic fluency. They can nevertheless express object relations, counting, symmetry, topology, spatial transformations, and compositions. Every answer is exactly verifiable, every failure is visually inspectable, and multiple test inputs reveal whether a rule is applied consistently rather than guessed once ( Chollet et al., 2024 ) .
Figure 1 illustrates this task. The input contains two binary panels separated by a gray column. From the demonstrations, the system must infer that the output marks the cells occupied in both panels and transfer that relation to the query. Nothing in the input names intersection, alignment, or the meaning of the output color.
ARC gives us a controlled visual language in which learning from context, latent computation, exact execution, and inference cost can be studied together.
## 3 Introducing BDH-CQ: In-context learning through recurrent memory and latent reasoning
### 3.1 BDH provenance
We have previously introduced the Dragon Hatchling (BDH), a post-Transformer sequence-model architecture built around high-dimensional positive activations, low-rank communication, and a recurrent associative state ( Kosowski et al., 2025 ) . Its GPU-oriented formulation uses BDH layers combining ReLU-low-rank transformations with linear attention in a large neuron or feature space. The design is brain-inspired but not brain-imitative. It draws on principles biology got right, namely local interaction, sparse activity, persistent state, and continual adjustment, and applies them to a modern sequence model. That work established BDH’s language, sequence-modeling, and interpretability properties.
BDH layers also support recurrent systems for constraint satisfaction. Our Sudoku system iteratively refines a visual state until it satisfies the puzzle constraints ( Pathway Research, 2025 ) . BDH-CQ extends this line into a new reasoning system that combines a structured latent workspace and recurrent computation over model depth with an interface for learning visual transformations from demonstrations. We use “BDH” for the architectural family and “BDH-CQ” for the system introduced here. The complete evaluated system includes input transformations, candidate construction, ranking, and the inference pipeline.
### 3.2 In-context learning through recurrent memory
Let a task provide demonstrations D = { ( x t , y t ) } t = 1 K D=\{(x_{t},y_{t})\}_{t=1}^{K} and query input x ⋆ x^{\star} . Rather than compressing the demonstrations into a single task vector, BDH-CQ processes their elements sequentially. At a high level, its recurrent memory evolves as S t = U θ ( S t − 1 , D t ) , S_{t}=U_{\theta}(S_{t-1},D_{t}), (1) where D t D_{t} denotes the content of the t t -th demonstration and θ \theta remains fixed. Thus, information available to later inputs depends on associations accumulated from earlier inputs and outputs. This recurrent contextual state plays a role analogous to the context-dependent associations constructed by attention, while avoiding a growing explicit key–value cache. The interpretation is generally related to attention, fast-weight memory, and linear-attention views of contextual association ( Vaswani et al., 2017 ; Ba et al., 2016 ; Katharopoulos et al., 2020 ; Geva et al., 2021 ) , with linear attention being the conceptually simplest standalone realization of linear correction rules on S S , capturing the special case S t = S t − 1 + U θ ( D t ) S_{t}=S_{t-1}+U_{\theta}(D_{t}) .
### 3.3 Recurrent latent reasoning
After the demonstrations and query have been ingested, BDH-CQ performs iterative computation in a structured latent workspace H r H_{r} . This happens after the ingestion of the K K demonstrations into memory. We summarize this process through the following equations which capture the encoding of inputs x ⋆ x^{\star} , latent reasoning, and decoding of the output y ^ \hat{y} .
H 0 \displaystyle H_{0} = E θ ( x ⋆ , S K ) , \displaystyle=E_{\theta}(x^{\star},S_{K}), (2) H r + 1 \displaystyle H_{r+1} = F θ ( H r , S K ) , r = 0 , … , R − 1 , \displaystyle=F_{\theta}(H_{r},S_{K}),\quad r=0,\ldots,R-1, (3) y ^ \displaystyle\hat{y} = G θ ( H R ) . \displaystyle=G_{\theta}(H_{R}). (4)
The contextual memory S t S_{t} and reasoning workspace H r H_{r} have different conceptual roles. S t S_{t} changes as evidence is encountered and supports in-context learning. H r H_{r} carries the ongoing computation used to answer the current query. This organization defines the system-level interface studied in this paper. Dimensions, exact update rules, and implementation details remain proprietary.
## 4 Training data and objective
### 4.1 ARC task formulation
An ARC task T i T_{i} contains K i K_{i} demonstration pairs with Q i Q_{i} test pairs, Q i ≥ 1 Q_{i}\geq 1 . T i = ( { ( x i , j , y i , j ) } j = 1 K i , { ( x i , q test , y i , q test ) } q = 1 Q i ) . T_{i}=\left(\{(x_{i,j},y_{i,j})\}_{j=1}^{K_{i}},\{(x^{\mathrm{test}}_{i,q},y^{\mathrm{test}}_{i,q})\}_{q=1}^{Q_{i}}\right). (5) During training, the model predicts outputs after preceding examples have been incorporated into recurrent context. At a high level, the objective trains the system to use preceding examples and produce exact target grids. We report the task interface and data provenance; the complete internal training recipe remains proprietary.
### 4.2 Training mixture
First, we train a 150M-parameter model on a curated collection of ARC-style data. The dataset combines privately curated examples with publicly available data from the ARC-AGI-1 training set ( Chollet, 2019 ) , RE-ARC ( Hodel, 2024 ) , ConceptARC ( Moskvichev et al., 2023 ) , ARC-Heavy ( Li et al., 2025 ) , and ARC-GEN100K ( Moffitt, 2025 ) . We apply additional augmentations to increase the variety of the training data.
## 5 Public ARC-AGI-1 evaluation
We evaluate on the 400-task public ARC-AGI-1 evaluation split ( Chollet, 2019 ; Chollet et al., 2024 ) . The default system configuration follows the ARC-AGI leaderboard’s two-attempt convention (pass@2), producing up to two ranked candidates, receiving a score if either of the candidates is correct. The reported dollar value is computed from measured hardware time for the leaderboard’s score–cost plane. Other plotted systems use the costs reported by the leaderboard, which may represent hardware estimates or API prices. We additionally report pass@1 and test-pair accuracy when analyzing behavior.
At the default point, the 150M-parameter system reaches 29.5% pass@2 in approximately 0.85 H200 GPU-seconds per task. At $3 per H200-hour this gives a computed cost of $0.00070 per task, less than one-tenth of a cent. As Figure 2 shows, this point lies beyond the previously reported Pareto frontier: no plotted system attains at least this accuracy at equal or lower reported cost. This establishes a new state of the art in ARC-AGI-1 cost efficiency. Using ARC Prize’s reported costs as of July 2026, BDH-CQ is approximately 57x cheaper than GPT 5.6 Luna (Low) which scores 34.2% at $0.040 ( ARC Prize Foundation, 2026 ) . When accounting for OpenAI’s 80% public API price reduction of GPT 5.6 Luna on July 30, 2026, which is not reflected in ARC Prize’s data as of August 6, 2026, BDH-CQ is approximately 11x cheaper than GPT 5.6 Luna (Low).
#### Independent evaluation.
An independent black-box audit conducted by co-authors from Bielik and New York University reproduced the deployed system’s 29.5% pass@2 score on the public ARC-AGI-1 evaluation set. The auditors evaluated the system under a documented protocol without access to model weights. Their report also evaluates BDH-CQ on ConceptARC and a hand-crafted evaluation set ( Remigiusz Kinas, 2026 ; Richard Zhong, 2026 ) .
## 6 Behavioral analysis on ARC-like tasks
We analyze BDH-CQ’s performance across two different sets: ConceptARC ( Moskvichev et al., 2023 ) in section 6.1 and the official public evaluation set with curated tasks matching the distribution of the public evaluation set (see Appendix).
### 6.1 Concept-organized capability profile
ConceptARC organizes tasks into 16 families, providing a structured basis for examining which visual transformations the deployed system can learn. Each family contains ten tasks and thirty test inputs. We use strict task accuracy as the primary measure: a task is counted as correct only when all three test inputs are solved. Test-pair accuracy is reported alongside it to distinguish consistent application of a transformation from success on individual inputs. We treat each concept family as a probe of whether demonstrations can bind the corresponding visual operator schema.
Performance varies substantially across concept families (Table 2 ). In the opaque-identifier replication, ExtendToBoundary , FilledNotFilled , and TopBottom2D each reach 9/10 pass@2, whereas Copy and Order reach 2/10. With only ten tasks per family, however, these counts are a profile rather than a reliable ranking: the descriptive Wilson intervals for 9/10 and 2/10 overlap broadly ( 59.6 % 59.6\% – 98.2 % 98.2\% and 5.7 % 5.7\% – 51.0 % 51.0\% , respectively).
Several families show a substantial difference between test-pair and strict-task accuracy. Copy , for example, reaches 19/30 semantic test-pair pass@2 but only 2/10 strict tasks (20/30 pairs in the opaque replication). The system can therefore produce correct outputs for many inputs in this family, but does not yet apply the inferred transformation consistently across all inputs of a task.
### 6.2 Simple operators extrapolate; ordering and nesting expose distinct boundaries