Reasoning without writing every intermediate step, also called implicit CoT or latent chain-of-thought. Search by title, author, or topic; read in date order or sort by newest papers.
Literature checked through November 3, 2026 · Recent additions · Suggest a paper
Deng and colleagues first proposed this approach in Implicit Chain of Thought Reasoning via Knowledge Distillation (2023). It defines reasoning through continuous hidden states without emitting intermediate steps in §2.3, then presents distillation as one implementation. From Explicit CoT to Implicit CoT: Learning to Internalize CoT Step by Step (2024) introduces stepwise internalization.
New to the field? Start with five papers, then explore the full list below.
“Internal mechanisms” covers experiments on how model components affect an answer. “Hidden-state probes” test what information can be read from internal states. Papers can have several labels.
Showing 342 papers
Gives a recurrent language model extra hidden-state updates by inserting special tokens after each word. Tests whether these updates improve next-word prediction.
Date source: AITP presentation date. Linked arXiv version: May 14, 2024.
Introduces pause tokens that give a language model additional computational positions before it must produce an answer.
Adds a learned planning token before each written reasoning step, then uses that token to guide the step.
Runs shared transformer blocks repeatedly, keeping earlier passes available to attention. A learned router chooses how many passes each token receives.
Uses mechanistic analysis to identify internal components involved in multi-step reasoning and test their causal roles.
First proposes implicit chain-of-thought reasoning: language models carry out intermediate reasoning in continuous hidden states rather than generate it as text. Defines this setting separately from its implementation, which distills an explicit-CoT teacher's hidden states into an emulator and a student that produces the answer.
Related terms: implicit CoT, latent reasoning, latent chain-of-thought, latent CoT.
Trains a vision-language model on answers and reasoning steps from executed visual programs. Separate answer and rationale objectives let the model answer image questions without generating the intermediate program or rationale at inference.
Refines intermediate reasoning representations over several rounds of denoising. A multi-pass version can revisit earlier parts of the reasoning as it refines the solution.
Reverse-engineers a transformer trained on symbolic multi-step reasoning to characterize its learned internal algorithm.
Localizes internal representations involved in compositional reasoning and tests whether targeted interventions can repair failures.
Probes whether language models internally compose facts across hops before producing an answer, separating internal computation from verbal explanation.
Trains on ordinary text by generating written rationales before predicting what comes next. Learns from how much those rationales improve subsequent token predictions.
Studies whether meaningless filler-token positions can provide transformers with additional hidden computation without carrying readable reasoning content.
Uses a curriculum that progressively removes intermediate reasoning steps during fine-tuning, teaching a model to internalize an explicit chain of thought.
Related terms: implicit CoT, latent reasoning, latent chain-of-thought, latent CoT.
Mechanistically studies transformers that learn implicit reasoning after grokking, focusing on how internal algorithms support out-of-distribution generalization.
Finds evidence for parallel internal processes during multi-hop reasoning rather than a single serial written-style chain.
Uses outputs from a slower deliberative process as training data for a faster model, studying when System-2-like behavior can be compressed into direct prediction.
Studies the internal computation behind grade-school mathematics, including when models learn robust procedures or rely on data shortcuts.
Trains one model to compress written reasoning into special-token representations, then trains another to answer using those representations.
Searches hidden activations for directions that encode intermediate reasoning progress and tests how those directions affect behavior.
Randomizes which reasoning steps remain visible during training so one model can interpolate between direct and explicit reasoning.
Uses the sequence of hidden states produced during inference to estimate whether an answer is correct, without extra training or labeled correctness examples.
Tests whether successful implicit reasoning reflects an internal step-by-step procedure and documents where that interpretation fails.
Uses linear probes and activation patching on multi-step arithmetic to test when answers are computed. Finds that the tested models form intermediate answers during written CoT and that those generated steps causally affect the final answer.
Feeds a model's last hidden state back as its next input, enabling recurrent reasoning in continuous space before returning to language.
Encodes continuous data such as images as vectors, then generates those vectors with diffusion inside a causal transformer.
Compresses verbose reasoning traces into shorter dense representations and evaluates the trade-off between reasoning quality and generated length.
Compresses visible reasoning into hidden thinking states to reduce generated reasoning length while preserving task performance.
Interleaves latent and textual tokens so a model can combine compressed internal computation with readable reasoning steps.
Pretrains a depth-recurrent language model whose computation can be extended at inference time, separating test-time compute from generated token length.
Connects implicit language models to recurrent computation and analyzes the trade-off between parallel training and expressive sequential depth.
Trains a looped transformer to predict the tokens of a reasoning step in parallel at each iteration. Uses its longer reasoning traces to train an autoregressive model, testing length generalization on arithmetic and dynamic-programming tasks.
Interleaves continuous concept representations with text during pretraining so language models learn to compute over concepts as well as tokens.
Routes selected tokens through extra computation while reusing model parameters. Marks successive thinking steps so the model can distinguish one pass from the next.
Compresses segments of a generated reasoning chain into dense states while retaining a stepwise inference process.
Analyzes the expressive power of transformers that repeatedly apply shared layers, treating recurrent depth as a form of internal reasoning.
Uses self-distillation to align continuous internal reasoning states with explicit chain-of-thought behavior while reducing visible reasoning tokens.
Tests whether apparent implicit multi-step reasoning reflects compositional algorithms or learned shortcuts, emphasizing failure modes under distribution shift.
Selects diverse worked solutions from multiple teachers, then trains a student on full solutions, compressed solutions, and finally answers alone. The intermediate compression stage uses the student’s responses to guide how a teacher shortens its explanations.
Separates execution, reflection, and transition steps in written CoT using hidden representations. Adds a steering vector at thought boundaries to adjust how often the model reflects or changes direction, then measures accuracy and token use.
Encodes the answer in the language of the model's first response token, forcing a choice before any written explanation. Also tests whether successful answers could come from simple heuristics.
Adds hidden decoding tokens during pretraining, then discards their key/value cache entries after use. Keeps the original tokens' entries to preserve longer-range context.
Trains speech language models to transcribe a question, translate it into English, form an English response, and answer in the original language. Progressively shortens the intermediate text while retaining sentence openings, reducing the amount of reasoning text generated.
Adds trainable dummy tokens to a pretrained transformer so attention can use them for extra computation during decoding. The tokens can be inserted in different positions at inference time.
Optimizes latent states for individual problems at test time using policy gradients rather than searching over written reasoning traces.
Skips layers and compares shallow and deep models to examine what extra layers compute. In the models studied, later layers mostly make smaller refinements rather than adding new reasoning steps.
Presents evidence that transformer layers schedule intermediate subtasks internally.
Feeds posterior expectations back into a language model so intermediate generation can remain continuous instead of sampling discrete tokens.
Dynamically compresses portions of a reasoning chain into latent states according to the problem and intermediate context.
Surveys latent chain-of-thought methods and maintains a bibliography of token-wise, structural, representational, and analytical work.
Studies the data requirements for learning implicit multi-hop reasoning and identifies sharp limitations in low-data regimes.
Uses reinforcement learning to choose and train a mixture of latent and written reasoning steps.
Splits teacher rationales into chunks, then trains a student to skip chunks whose removal preserves the answer. The model retains key written steps while internalizing transitional or summary chunks.
Learns dynamic shortcuts between language and latent states to skip portions of an otherwise explicit reasoning trajectory.
Compares explicit CoT with looped hidden-state computation on parallel and probabilistic tasks. The ICML 2026 version extends the analysis to continuous thought and approximate sampling.
Pretrains language models with repeated continuous-space pondering steps before token prediction.
Analyzes and demonstrates how continuous intermediate states can explore several candidate reasoning paths in parallel.
Distills an autoregressive textual reasoner into a model that carries the intermediate process through silent internal states.
Uses latent visual tokens as an internal imagery channel for multimodal reasoning without rendering every intermediate state.
Repeats transformer layers with shared parameters in several reuse patterns. Compares how added computation affects memorization and reasoning at a fixed parameter count, using synthetic tasks and language-model benchmarks.
Applies Jacobi-style iteration to update continuous reasoning states in parallel rather than strictly one step at a time.
Uses coupled recurrent modules operating at different timescales to perform iterative internal computation on difficult reasoning tasks.
Probes a depth-recurrent transformer to test what its repeated hidden-state computation represents and whether it behaves like a latent chain of thought.
Surveys latent-reasoning methods, evaluation, and applications and accompanies a maintained research bibliography.
Adapts the depth of pretrained language models at test time by selectively skipping or repeating layers.
Learns token-level routing across recursive depths so different positions can receive different amounts of internal computation.
Uses synthetic continuous reasoning trajectories to train language models to allocate internal reasoning adaptively.
Probes soft-token reasoning and finds that tested models often follow the highest-probability component rather than exploring several paths at once. Introduces stochastic soft thinking, including Gumbel-Softmax sampling, to reduce this greedy behavior.
Organizes implicit-reasoning research across model mechanisms, training methods, evaluation, and applications.
Trains a small transformer module to produce continuous thought vectors for a frozen language model. Aligns those vectors with the question and important solution steps; the language model then generates a written explanation and answer.
Trains continuous intermediate states with explicit supervision so reasoning can proceed without emitting a full textual trace.
Uses a variational autoencoder to compress textual reasoning steps into blocks of continuous states. A diffusion model repeatedly revises each block before generating the next, then produces a textual answer; diversity guidance encourages alternative reasoning trajectories.
Uses one small network to repeatedly update a reasoning state and a proposed answer. Trains these updates with deep supervision and a learned halting score, evaluating the approach on Sudoku, mazes, and ARC-AGI puzzles.
Studies how repeated attention changes optimization through a model of loss-landscape geometry. Proposes SHIFT, which starts with one attention pass and adds shared-weight repetitions after learning stalls, and tests the schedule on synthetic sequence tasks.
Models latent reasoning as a sequence of superposed token distributions and trains the process with supervised fine-tuning.
Compresses textual reasoning into semantically aligned implicit tokens intended to preserve useful intermediate computation with fewer generated steps.
Scales looped language models that reuse layers across recurrent depth and studies how performance changes with additional internal computation.
Adds recurrent depth to pretrained language models and trains them to use repeated internal computation without pretraining from scratch.
Uses dynamic looping to vary internal depth with problem difficulty and studies the resulting reasoning and efficiency trade-offs.
Interprets recursive state updates as changes to a model's answer distribution. Trains intermediate updates toward progressively less corrupted puzzle solutions, testing whether recursion improves the answer at each step.
Learns a stopping policy for continuous latent reasoning so the model can allocate a variable number of internal steps.
Trains a small projector to replace parts of a written reasoning trace with continuous embeddings. Reinforcement learning teaches the language model when to use these latent steps for plot-hole detection and story generation.
Tests COCONUT with latent-state interventions and deliberately biased examples on MMLU and HotpotQA. Finds weak sensitivity to latent-state steering and dependence on dataset shortcuts.
Separates an internal planning process from verbalization and studies whether the latent plan supports effective downstream reasoning.
Analyzes how skipping intermediate steps weakens learning signals in a simplified parity-task model. Introduces NatBool-DAG to test logical dependencies and ALiCoT, which supervises learned token states with intermediate logical labels or explicit-CoT representations.
Uses reinforcement learning to train an active latent-planning process rather than only imitating supervised reasoning traces.
Tests segment-removal curricula, a segment-based Coconut adaptation, and shorter teacher targets on competition math. Training on the teacher’s post-think explanation gives a better accuracy–token trade-off than the tested internalization curricula.
Date source: Author-hosted preprint upload date.
Uses mechanistic interventions on sequential tasks to test whether latent chain-of-thought models actually execute stepwise internal procedures.
Characterizes tasks that latent chain-of-thought can express and identifies theoretical and empirical limits of the approach.
Builds a library of activation edits from successful and failed reasoning traces, then selects edits during generation. Uses short lookahead checks to steer ongoing written reasoning, rather than replacing the trace with a sequence of hidden-state steps.
Supervises intermediate thinking states that bridge textual reasoning traces and latent computation.
Treats intermediate latent steps as variables that can be replaced and recomputed. Tests Coconut and CODI to determine which steps affect answers, how changes propagate, and when the model commits to one answer.
Trains a shared transformer stack on long and short computation paths, conditioning each pass on its location and step size. A consistency loss aligns shorter paths with the longest path so one model can run under different depth budgets.
Routes intermediate computation between latent and discrete representations to trade off reasoning quality, readability, and token cost.
Measures how late in a transformer’s layers each token prediction settles, then uses this signal to score a reasoning trace. Tests early rejection of low-scoring samples on math and science questions, measuring savings in generated tokens.
Compares depth growing and weight-tied loops using matched model budgets and interventions on intermediate layers. Finds related patterns of repeated computation and improves reasoning by adding middle-block loops to depth-grown models during inference or continued training.
Tests latent reasoning on GSM8K and ProsQA by removing steps, perturbing hidden states, and sampling continuations. Finds that stronger supervision reduces shortcut use but narrows sampled solutions, and studies changes to Coconut training that increase its reliance on latent steps.
Uses differentiable masks to allocate a variable number of recurrent pondering steps to different token positions.
Trains on synthetic traces that rank document pages and extract relevant evidence, then uses low-strength model merging to internalize the trained reasoning behavior. Compares answering with and without written reasoning on long visual documents.
Trains transformers to answer multi-hop knowledge queries without writing intermediate steps. Tests whether repeated shared layers help combine unfamiliar facts and solve longer chains, and examines when extra inference loops help or cause overthinking.
Analyzes how hidden states and attention change across repeated transformer layers. Finds that recurrent blocks often repeat the stages seen in feedforward models, while input injection and normalization affect whether those stages remain stable at greater depth.
Studies when transformer layers combine family relationships to answer multi-hop questions. Uses logit-lens probes and causal activation patching to compare depth use before and after task fine-tuning.
Stabilizes looped language models by constraining how earlier states enter the next pass and sampling training depth separately for each sequence. Studies how to divide training compute between data and recurrence, and how additional inference loops reach a performance plateau.
Post-trains a single model to internalize the computation of a multi-agent debate rather than emitting the debate as text.
Trains a video-language model to answer through a bounded sequence of continuous hidden states. First aligns these states with features from generated thought videos, then trains with answer-only supervision; inference uses the latent sequence without generating intermediate videos.
Replaces written reasoning steps with reusable discrete tokens learned from their functional roles. The model generates these tokens with optional short textual results before answering, and prunes textual results according to their effect on answer prediction.
Provides theoretical and empirical results on when transformers trained with a curriculum learn to internalize explicit reasoning steps.
Uses probes, ablations, and targeted edits to study how continuous reasoning states affect answers. Builds interventions from learned semantic mappings and geometric constraints, improving the evaluated models by editing their latent states without updating base-model weights.
Replaces a mobile agent’s written observations, rationale and predicted next screen with continuous thought slots. Parallel refinement updates these slots, while next-frame feature prediction provides training supervision before action decoding.
Distills a teacher's written reasoning into fewer continuous steps by matching hidden-state means and covariances in a shared low-rank subspace. Adds a separate alignment loss where latent reasoning hands off to answer generation.
Compares Coconut and CODI with controls lacking their proposed reasoning recurrence or curriculum. Finds that decodable patterns can also appear in controls, while interventions reveal varying causal use of latent states concentrated in low-dimensional directions.
Trains switchable hidden-state recurrence with on-policy reinforcement learning and analyzes how the internal loop contributes to reasoning.
Stabilizes repeated transformer layers and stops looping when the hidden state converges, allowing the model to spend different amounts of computation on different problems.
Scales each residual update inversely with the number of shared-weight loops, while keeping the learning rate independent of that loop count. Derives the scaling rule and tests whether hyperparameters transfer across loop counts and model depths during language-model pretraining.
Uses information-theoretic analysis to study which supervision signals make latent chain-of-thought training effective.
Trains a no-think student with on-policy feedback from a copy that sees a prefix of the reasoning trace. Withholding more of the trace from the student teaches it to answer with fewer or no written reasoning steps.
Probes whether the first hidden state of a reasoning trace predicts a model’s eventual refusal or compliance. Compares this early signal with partial-trace continuations and thinking-enabled versus direct responses to test whether written deliberation changes safety decisions.
Varies which feed-forward units are active across loops of a shared transformer and strengthens nonlinear attention. Studies how this affects hidden-state rank, depth scaling, and the computation needed for reasoning.
Date source: ACL Anthology release date.
LOTUS repeatedly refines blocks of continuous reasoning states in parallel, training each position to predict a token from a worked solution. It generates answers from those states and studies accuracy, latency and how much of the reasoning can be read back.
Feeds both token embeddings and hidden states back through repeated transformer layers to connect successive steps of multi-hop reasoning.
Jointly trains latent states for answer prediction and for decoding back into readable reasoning, using one model rather than a separate post-hoc explanation decoder.
Studies how models use filler tokens to compute without writing intermediate steps. Reads intermediate values from hidden states and swaps cached states between examples to test their effect on answers, then evaluates an unsupervised decoder on fact retrieval, arithmetic and string tasks.
Tests how answers respond to changed inputs and altered hidden reasoning states throughout training. These responses can change even while accuracy remains high.
Carries a cached middle-layer state from one token position into an earlier layer at the next position, providing localized temporal recurrence that can also be retrofitted into pretrained transformers.
Introduces direct latent supervision through averaged trace embeddings and finds that both direct and indirect continuous-CoT training degrade sharply on tasks with substantially longer reasoning traces.
Tests whether fixed filler tokens improve reasoning without exposing intermediate steps in text. Finds task- and model-dependent effects, studies their internal mechanisms, and reports limits of training models to exploit them.
At test time, adjusts extra hidden states inside the transformer using feedback on generated answers, while keeping the model’s weights fixed.
Trains each transformer loop to anticipate a different future token, using token embeddings to guide its hidden state.
Compares monitoring from explicit traces, latent-state probes, and latent verbalizations, finding that monitorability depends strongly on task structure and level of internal access.
Studies when extra transformer loops improve an answer or make it worse. Gives a condition under which further loops cannot change the answer, and trains models toward this stable behavior.
Studies which transformer components should recur and introduces MixerLoop, which repeats the sequence mixer while applying the dense feed-forward component once.
Compares behavior under neutral, explicit-CoT, and no-CoT prompts using linguistic and internal-state measurements. Scores resemblance to CoT behavior and uses calibration controls to identify confounds.
Uses state interventions, probes, and feature ablations to study how hierarchical recurrent models solve Sudoku, mazes, and ARC tasks. Compares hierarchical and single-state recurrence, and distinguishes information that can be read from a state from information that causally affects an answer.
Tests when a hierarchical reasoner should revise the internal plan guiding its lower-level computation. Compares learned revision schedules with fixed schedules, separating whether a controller responds to its state from whether that response improves decisions.
Uses a task-specific proposer and small recurrent auxiliary network to iteratively refine continuous thoughts that a frozen language model then decodes.
Loops the middle half of a mixture-of-experts transformer twice while matching an unlooped baseline on computation, parameter count, and KV-cache size. Studies how the comparison changes with model scale and examines the attention patterns produced by revisiting layers.
Turns a diffusion denoiser into a recurrent puzzle solver by adding a persistent hidden state and removing timestep conditioning. Separates the role of denoising during training from the role of repeated updates and noise at inference.
Tracks information that can be decoded from, and altered within, repeated transformer layers. Finds that Ouro reconstructs this information each loop, while Huginn carries it forward.
Lets looped layers attend to their own earlier iteration states and learns a halting head that allocates recurrent depth per input.
Moves pause-token computation into a parallel, weight-shared prediction stream, providing additional internal compute without increasing generated sequence length or key/value-cache length.
Places pause tokens at reasoning-step boundaries and masks their training loss. Studies how this affects learning new tasks while retaining earlier capabilities, including during reinforcement learning.
Studies recurrent reasoning trajectories as dynamical systems on puzzles and mathematical logic. Links long solution times in the tested models to transient trapping near unstable states associated with nearly correct solutions.
Trains recurrent reasoners against a distribution of targets near each correct solution, using an adversarial objective instead of a single point target. Evaluates generalization and stability on maze, chess, and Sudoku tasks.
Aligns continuous thoughts with written reasoning through shared, learnable prototypes, allowing several text steps to supervise several latent states. A positional alignment constraint is gradually relaxed during training.
Starts diffusion-model reinforcement learning with teacher-written reasoning partially filled into the output, then gradually removes that guidance. Tests whether this curriculum improves exploration on mathematics and tool-use tasks; inference still produces textual reasoning.
Learns a router that chooses how many recurrent passes each token receives, and keeps separate key/value caches for each pass.
Trains a diffusion language model to carry a fixed number of continuous register states between generated chunks. The model still writes text within each chunk, but clears earlier text and continues from the prompt and retained registers.
Studies updates that initially increase support for a reference answer but overshoot when applied in full. Uses curvature along each update to explain failures and identify smaller useful steps.
Drafts future tokens from early loops while later loops verify current tokens, overlapping the work without training an extra model. Final verification preserves the full model's decoding behavior.
Compresses teacher-written retrieval steps into learned discrete slot codes. Predicts how many slots a query and user history need, then generates the slots and an item identifier without writing a natural-language rationale.
Date source: Author-hosted preprint upload date.
Studies how growing a model during training, reusing layers, and modifying the connections between repeated blocks affect language-model scaling. Compares shared and unshared weights and operators that normalize or reintroduce earlier representations.
Adds a small gated memory to a looped transformer and compares it with storing the full history of recurrent states. Uses a cellular-automaton task and language modeling to test whether memory remains useful as computation grows.
Trains on progressively harder problems so that a model learns continuous intermediate thoughts without explicit reasoning-step supervision. Analyzes parity learning theoretically and tests graph reachability and arithmetic.
Encodes teacher reasoning steps from text, images, point clouds, and robot states into a shared continuous representation. A jointly trained diffusion reasoner generates these states at inference, evaluated on visual question answering and robotic manipulation.
Aligns continuous thoughts with a codebook of knowledge-base relations and classes, using schema traces derived from correct logical forms. Feeds the aligned codes into later reasoning steps before generating an executable query.
Uses an expert-derived causal dependency matrix to guide gradient-based revision of diffusion reasoning states. The aim is to preserve logical dependencies while revising several intermediate positions during parallel generation.
Inserts a hidden-state refinement step between consecutive text tokens in a recurrent transformer. Compares this extra thinking time with adding physical layers or transformer loops under matched computation budgets.
Tests whether changing continuous reasoning states changes the model's later text output. Finds weaker steering effects than in explicit chain-of-thought, despite comparable changes to the hidden representations.
Uses intermediate loop depths to propose tokens that later loops verify. Arranges speculation across recurrent depths so that more of the draft and verification work can run together.
Uses differences between early- and late-loop predictions to adjust token sampling at inference time, without retraining the model.
Triggers graph retrieval when new entities become identifiable in a partially denoised draft, then uses graph propagation to provide multi-hop evidence for subsequent updates. Combines retrieval with parallel textual reasoning.
Uses the history of diffusion hidden states to detect answers that become stable but remain wrong. A planner selects targeted repair branches and verifies continuations, testing whether these internal trajectories support better repair decisions than confidence or a single snapshot.
Studies when a recurrent language model settles on which context tokens to attend to. Reuses that selected working set in later loops while still recomputing attention weights and hidden-state updates.
Extracts token chains from written reasoning and prioritizes them during diffusion-model training to improve denoising speed and accuracy.
Adapts continuous diffusion to mathematics and code using intermediate-feature supervision and a global representation from a frozen autoregressive teacher. It denoises continuous response representations and decodes all response tokens only at the end.
Lets agents perform hidden-state reasoning and pass working memory through the key-value cache of one selected transformer layer. Reuses that layer as the entry point for subsequent reasoning updates, avoiding earlier layers and decoding only the final agent's response into text.
LIRSeg generates a fixed sequence of learned special tokens before a target description and bounding box used for segmentation. Spatial alignment grounds the tokens' hidden states in relevant image regions, followed by training with segmentation rewards.
Analyzes tasks for which a fixed-depth transformer needs an informative chain of thought to exceed a task-specific accuracy limit. Combines circuit-based results with experiments that replace, erase, or shuffle reasoning tokens, including comparisons with filler tokens.
Compares how two looped-transformer training schemes solve multi-step tasks beyond their training length. Uses hidden-state interventions to identify how intermediate information moves through each model and where that process breaks down.
Combines recurrent ARC reasoning with compact task memories and synthetic examples generated from puzzle rules. Studies the balance between memory capacity, recurrent depth and training horizon, and adapts to unseen puzzles by updating task-specific memory while keeping shared weights fixed.
Adds a diffusion head that samples the next continuous thought from a distribution rather than predicting one fixed vector. Feeds each sampled thought back into an autoregressive reasoner, supporting variable-length latent traces and multiple reasoning paths.
Learns a distribution over continuous reasoning trajectories before producing a retrieval embedding. A lightweight decoder provides reconstruction supervision and a semantic reward for reinforcement learning, evaluated on image, video, and visual-document retrieval.
Regularizes fine-tuning of looped language models by randomly masking adapter updates at selected loops. The shared backbone still runs at every loop; the method targets adapter updates that otherwise become concentrated at particular depths.
Distills a teacher's interleaved visual and textual reasoning into a student that no longer generates intermediate visual representations. The student still writes a textual chain of thought; what is internalized is the visual portion of the reasoning.
Post-trains a looped reinforcement-learning policy to make useful decisions at several recurrent depths. Combines its original objective with distillation between neighboring depths, then uses agreement across depths to decide when to stop.
Uses shallower-loop queries with values from deeper loops to improve draft-token predictions in a looped language model. Studies the different rates at which queries, keys, and values develop, and uses that difference for self-speculative decoding.
Compares process-reward guidance with independent sampling and final-answer reranking at matched forward-pass budgets. In the tested diffusion models, early pruning removes promising candidates and intermediate-state scorers can be poor final judges; the generated solutions remain textual.
CEDR learns compact representations from several teacher layers, denoises them at different rates, and trains a smaller prompt encoder to replace the teacher at inference. It generates complete mathematical and coding solutions through continuous refinement before text decoding.
Trains an iteration controller to give extra transformer loops only to tokens whose predictions benefit from them. Compares reasoning accuracy as both output length and internal computation increase.
Builds a looped mixture-of-experts model by pooling experts across layers and revisiting them. Shares experts and routing across passes while giving each pass its own attention parameters.
Checks whether tokens committed earlier in diffusion decoding become less plausible as context fills in. CoDR remasks and regenerates those positions, testing targeted revision against extra-compute controls on reasoning and code tasks.
Studies when simultaneously committing several predicted tokens breaks their reasoning dependencies. RPD combines stability across final layers with confidence and uncertainty in preceding positions to defer unsupported predictions while retaining parallel text generation.
Compares loop layouts and ways of passing information between loops in language models. Examines when recurrence helps reasoning and when it helps less on knowledge-dependent tasks.
Adjusts the size of each hidden-state update based on whether recent updates make consistent progress or fluctuate. Tests the resulting scheduler with and without additional training.
Separates hidden-state updates into attracting and rotating components to reduce errors from running a recurrent reasoner for more steps. Tests a tensor-based implementation on logical and multi-hop reasoning tasks.
Treats each recurrent hidden-state update as an optimization step and derives loop designs from this view. Introduces OperLoop, combining adaptive step sizes and weight decay.
Uses a shared transformer block to refine a reinforcement-learning policy's internal state before choosing an action. Learns to vary the number of loops with the current state, and studies adaptive computation in puzzles and robotic-control tasks.
Extends shared-module and whole-model looping to vision-language models, repeatedly updating a joint visual-language state. Trains from scratch through language and multimodal stages and evaluates visual understanding and reasoning.
Uses a fixed, revisable output and model confidence to search over candidate solutions with a frozen fine-tuned diffusion checkpoint. Evaluates logic and scheduling problems where global constraints can make irrevocable left-to-right commitments costly.
Learns when to perform another internal reasoning step, recall stored evidence or intermediate states, or emit a token. Trains these choices by branching over alternative actions and measuring their effects on the next emitted token.
Uses graph-walk tasks to study how a looped transformer performs different computations with the same weights. Tests whether changing the state entering a loop can select its computation, using steering and activation-patching experiments.
Compares recursive reasoning models under a common training and evaluation setup. Isolates the effects of gradient propagation, batch size, state updates, and hierarchical structure on algorithmic tasks and generalization.
Fits scaling laws that jointly account for recurrent depth, expert sparsity, model size, and training data in looped mixture-of-experts models. Uses them to study how to allocate resources under compute and memory constraints.
Changes how outcome rewards weight decisions at different denoising states during diffusion-model reinforcement learning. Derives the effect for binary rewards and uses matched-scale controls to test whether the schedule improves mathematical accuracy and reasoning-trace diversity.
Gives training recipes for looped language models both from scratch and by converting pretrained models. Uses controlled data and compute comparisons to separate the benefit of recurrence from the training setup.
Splits the recurrent residual into groups and rotates each group separately, aiming to preserve information across repeated transformer loops. Evaluates state tracking and language modeling.
Studies how to train mixture-of-experts transformers with more than two recurrent passes. Combines stabilized residual updates, reintroduced input information, and loop-specific routing to support deeper reuse of the shared model.
Extends integrated-gradient attribution across layers and denoising steps to examine which inputs influence a diffusion model's developing response. Includes experiments on multi-hop graph reasoning.
Compares a looped model's final prediction with predictions from earlier loops to improve decoding without additional training. Tests contrastive variants using either output logits or hidden states on mathematical reasoning and code generation.
Keeps a continuous state throughout denoising while reading out tokens at each step and feeding them back into the next state update. Tests whether this coupling preserves dependencies during parallel generation on Sudoku, Countdown, and language modeling.
Shares a long-context KV memory written by the first loop across later loops, which also keep a short local memory. Studies this architecture during pretraining and examines how shared memory changes representations and gradient flow.
Sigma denoises learned continuous token embeddings in blocks, starting from autoregressive pretrained weights. Studies how guidance and temperature affect mathematical reasoning, coding, output diversity, and performance when fewer refinement steps are used.
Tests how recurrent depth affects the ability to monitor a language model through its written chain of thought. Finds task-dependent changes under stress tests, while matched comparisons do not show a general monitorability disadvantage for looped architectures.
Selects token commitments that most reduce uncertainty over the remaining output. Self-distillation reinforces these pivots from successful diffusion trajectories and discourages selected pivots from failed ones, rather than supervising every token equally.
Adds a shared recurrent block between an audio encoder and language model. A question-conditioned halting mechanism chooses how many refinement passes to apply, with deeper computation learned for tasks requiring finer acoustic distinctions.
Processes selected video clips sequentially while persistent think tokens accumulate evidence for a fixed-size retrieval embedding. Intermediate retrieval supervision and self-distillation train partial-video readouts; the output is an embedding rather than a generated reasoning trace.
Compresses symbolic reasoning into latent codes and trains a flow model to refine a block of noise into a thought before decoding the answer. Studies training choices, self-training on verified thoughts, and whether those thoughts affect the answer.
Uses near-fixed-point recurrent states to reduce the cost of training, key/value caching, and prefill. Learns how to sample loop depths and changes how the input is reintroduced on each loop.
Compresses images of written derivations into continuous states, training both the answers they support and the reasoning that can be recovered from them. Gradually shifts from generating latent blocks in parallel to generating them in sequence.
Tests how answer scoring changes measurements of early-answer stability in Huginn and Ouro. Shows that choosing which questions to answer early and deciding what counts as an answer change must be evaluated separately; lower revision risk did not establish better accuracy or stopping decisions.
Date source: Journal publication date.
Passes each token's final decoder state to the next token, alongside a causal encoder representation. Tests whether this growing computation path supports state tracking on sequences longer than those seen during training.
Refines an internal state across loops to choose among typed answer options without generating a written reasoning trace. Supervises decisions at multiple depths and evaluates how prediction quality changes with the available computation budget.
Keeps separate short- and long-term matrix memories and lets a transformer update both through bidirectional reads and writes. Tests this recurrent architecture on algorithmic, in-context learning, and reasoning tasks.
Lets tokens leave a looped language model at different depths by reusing their final key-value cache entries in later loops. Adds an exit-depth training objective and ragged-cache training to make variable-depth computation practical.
Adds noise to conditioning tokens during training instead of keeping the prompt clean. Tests improvements in Sudoku and N-Queens generalization and solution diversity, while reporting that the gains do not transfer to every language-generation task.
Compares continuous flow and discrete diffusion models at matched sizes and denoising steps. A theoretical account and intermediate-state interventions examine whether retaining information about several candidates helps solve mazes and Sudoku before final discretization.
PaTh uses a small recursive network to refine learned image-state tokens inside each denoising step and steer a frozen diffusion model through adapters. It learns visual puzzles from reconstruction targets without symbolic solutions or an external verifier.
Trains an intermediate loop using a deeper loop of the same language model as its teacher on student-generated outputs. A dynamic variant refreshes the teacher during training, turning additional recurrent computation into a source of supervision.
Evaluates harmful-query and jailbreak behavior at different recurrent depths of looped language models. Proposes depth-specific control, state sharing, and joint supervision to align safety behavior across depths.
Predicts by averaging over the long-run distribution of recurrent hidden states instead of reading a single final state. This lets the model use changing hidden states without requiring them to settle at one fixed point.
Compresses each completed block of generated reasoning into the key/value cache of learned pause tokens, then discards the block's original cache. Later tokens attend to the compact replacement.
Adds a learned running summary of previous recurrent states so that each update can retain useful earlier work. Uses content-based weighting and temporal decay with constant aggregation memory, and tests whether puzzle-solving improves over much longer inference runs.
Trains one language model to operate at different loop counts by mixing depths during training and conditioning each pass on its index and budget. A learned gate controls each recurrent update.
ChemDiffAgent denoises interleaved textual reasoning and tool-use trajectories, letting tool decisions depend on context across the trajectory. A chemistry benchmark and matched-budget comparisons test this alternative to left-to-right agent generation.
Identifies spatial-coordinate directions in multimodal model activations and tests them through causal interventions. Separating perception from viewpoint transformation reveals cases where a model represents object locations but fails to perform the required spatial computation.
Trains a looped language model at a fixed depth first, then introduces varying depths only near the end of training. Compares the resulting training cost and performance across inference depths with varying depth throughout training.
Analyzes how many extra loops a model trained on graph connectivity can safely run. Derives a finite range where added depth solves harder graphs before further loops create false connections.
Evaluates a depth-recurrent model on Sudoku-like worlds with different rule combinations. Compares symbolic rule descriptions with solved examples when the test world contains new puzzles, new combinations, or unfamiliar rule instances.
Trains an anchor generator to choose a short text fragment and its position in a frozen diffusion model's output. These visible control tokens guide subsequent denoising, with rewards for correct answers and satisfied constraints.
Studies how reducing recurrent depth changes refusal behavior in two looped language-model families. Uses probes and interventions to distinguish recognizing a harmful request from refusing it, and tests safety training across randomly selected depths.
Surveys models that reuse transformer layers across repeated hidden-state updates. Compares their architecture, training and inference choices, separating parameter-matched results from compute-matched results.
Date source: Author repository PDF release.
Trains a language model to score labels supplied at inference in one forward pass, without generating a reasoning trace. Distills label distributions from repeated teacher reasoning and studies routing uncertain decisions back to explicit reasoning.
Separately perturbs the answer state and the reasoning state of a recursive puzzle solver to study where extra search is useful. Uses the model's halting prediction to trigger restarts that resample the answer state.
Predicts from the question how many continuous reasoning updates to perform. Evaluates total cost including latent updates, special tokens, and any written continuation rather than counting latent steps alone.
Inspects eight looped language models for state convergence, token decisions, readout quality, attention behavior, and sensitivity to injected noise. Finds differences between models that receive the prompt once and those that reintroduce it at each loop.
Searches for layers to repeat to make a stronger teacher from the current model, then distills its predictions into the original student. Repeats search and distillation as the student improves.
Studies how oscillations can slow convergence in recurrent reasoning models. Proposes an architecture whose rotational state changes are separated from the representation used for reasoning, and tests convergence on puzzle-solving tasks.
Searches over input conditions to change a recursive reasoner's update rule without retraining it. Tests whether these alternative updates can redirect a trajectory away from an incorrect solution, rather than only adding more steps or perturbing its state.
Trains a critic to score intermediate continuous token representations, enabling reward gradients through the denoising trajectory before final discrete decoding. Evaluates this post-training approach on four reasoning tasks.
Analyzes the Continuous Thought Machine's repeated updates during image classification. Finds that its hidden states follow moving fixed points and that much of its attention schedule is shared across images.
Branches rollouts from uncertain intermediate states and reuses their shared textual prefixes. Local outcome comparisons assign credit to reasoning segments, testing whether more targeted exploration improves diffusion-model reasoning with fewer generated training tokens.
Trains a small encoder to turn a frozen model's hidden states into successive blocks of continuous thoughts. After this latent prefix, the frozen model writes its remaining reasoning and answer; the encoder learns through distillation and answer-correctness rewards.
Separates computing an answer, preserving it through additional loops, and keeping its hidden state usable for later steps. On state-machine and maze tasks, shows that training can improve one ability without securing the others.
Distills multiple written reasoning paths for each question into a flow model over fixed-length latent sequences, including mixtures of complete rationales. Generates all latent slots together, then uses a frozen language model to decode answers from sampled rationale contexts.
Uses chain deletion, content replacement, probes, and trajectory analysis across 21 model-task configurations. Separates what continuous states encode from whether the model uses their content, finding that dependence on the chain varies with task and training recipe.
Trains a small drafter to predict several future tokens from early-loop hidden states. Later loops decide which speculative branches to continue, and full-depth verification determines the final output.
Prunes layers from a pretrained vision-language model, then loops the remaining middle block with a learned adapter. Uses text training, projector realignment, and visual instruction tuning to recover performance; on TinyLLaVA, the resulting model improves reasoning benchmarks with fewer language-model parameters.
Adds a small, content-addressed memory to a looped transformer, rebuilding causal prefix summaries between shared-layer passes. Tests whether this extra information path improves next-byte prediction under matched parameter and training budgets.
Compresses written reasoning into separator-token states by gradually reducing attention to the intervening text. Distills those states into a continuous reasoning path that learns when to stop and generate an answer.
Compares where to place shared layers, how to reintroduce the input, and how to organize recurrent states in looped language models. Uses matched dense-model comparisons and a mixture-of-experts study to separate these design choices.
Projects hidden states into vocabulary directions to track how internal information changes across layers and written reasoning steps. Uses these trajectories to detect unfaithful chains of thought and test transfer across tasks and models.
Repeatedly updates hidden reasoning and answer states from image features and a spatial-language prompt using a shared transformer. Decodes the refined answer state into a convex region mask and compares it with a single-step model.
Trains looped and untied transformers to follow paths through a shuffled permutation graph without writing intermediate hops. Uses probes and activation patching to test when intermediate nodes become available and whether later computation uses them.
Tests models that choose among options in one forward pass without generating reasoning text. Separates retrieval from combining state updates and examines how similar distractor records and stale summaries affect decisions.
Feeds the previous token’s deep hidden state into earlier layers for the next token. A shared middle block and parallel Jacobi updates train this recurrence without serializing all training tokens.
Processes a latent slot and a prediction slot together, carrying the previous token's hidden state into the current prediction. Uses parallel iterative updates during training while preserving autoregressive text generation at inference.
Studies hidden-state directions that predict correctness during written arithmetic search traces. Compares linear probes, activation differences, and optimized steering vectors, finding that readable correctness signals do not yield consistent improvements when used to steer generation.
Trains models to select the next step of a proof without writing intermediate reasoning, gradually increasing required lookahead and the number of attribute labels. Studies how training compute, model size, initialization, and curriculum steps affect learned lookahead and transfer to other reasoning tasks.
Combines a diffusion language model with a probabilistic circuit that models dependencies among tokens proposed together. Learns context-dependent token coupling and uses it to decide which discrete tokens to commit in parallel on math and code tasks.
Measures how many forward passes diffusion language models spend per output token across tasks and languages. Relates this cost to output copying and novelty, and tests whether answer-decoding speed can improve voting over sampled math answers.
Changes resampling in diffusion-model search to preserve more distinct candidate histories, combining unequal-weight resampling with a floor on low weights. Tests the effect on candidate coverage and final-answer accuracy under several answer-selection rules.
Measures how forward loop counts and truncated backpropagation affect language-model pretraining across model sizes and data budgets. Fits scaling laws to compare full backpropagation through fewer loops with truncated alternatives at matched compute.
Selects confident tokens near the centers of masked spans, allowing diffusion language models to fill separate spans in parallel. Studies how this ordering trades generation quality against decoding speed on math, code and instruction-following tasks.
Uses one denoiser to revise all tokens in a complete draft in parallel and score the revised draft in context. Repeated refinement keeps the lowest-energy candidate, with experiments on arithmetic, Sudoku and maze solving.
Adds a persistent intermediate state to nested updates in HRM, TRM and URM, then compares the variants on ARC-AGI-1. Finds no consistent advantage under the tested training budgets and separates token accuracy from exact puzzle solving.
Pairs action-word predictions with hidden-state predictions of future visual and tactile observations. Uses these intermediate representations to guide robot manipulation, with separate supervision for action labels and future sensory information.
Replaces intermediate generated images with learned latent-token blocks while retaining the written reasoning between them. Self-distills successful text-image traces into a unified multimodal model, reserving image generation for the final output.
Jointly fine-tunes looped and hierarchical recurrent language models on nine clinical text datasets and tests transfer to four more. Compares direct-answer performance with standard transformers while noting that the model families also differ in pretraining.
Trains each loop of a language model to represent the state after one more operation, while keeping hidden-state norms stable. Combines this supervision with learned stopping and prefix self-distillation to test generalization to longer state-tracking problems without generating intermediate tokens.
Runs a causal encoder once, then repeatedly applies a shared decoder that attends to fixed encoder context and its evolving hidden states. Evaluates this division of work against fully looped and standard language models during pretraining.
Uses controlled prompt changes and interventions to separate information present in hidden states from what a probe can read and what a model actually uses. Tests copied digits and unwritten arithmetic intermediates in a looped model and a standard transformer.
Studies when predicting the next hidden state preserves information needed for next-token prediction. Gives conditions and counterexamples showing why good one-step predictions need not yield reliable multi-step hidden-state rollouts.
Represents each unfinished output position as a set of possible tokens. Denoising removes or restores candidates before choosing a final token, testing how this intermediate representation affects Sudoku, Boxoban, graph coloring and language modeling.
Introduces parallel translated and culturally localized math problems for Modern Standard Arabic and five dialects. Uses residual-state comparisons and activation patching to study how localization changes internal processing and answer accuracy.
Measures how much of the weight gradient is dropped when looped language models backpropagate through only their final iterations. Tracks how this changes during fine-tuning and tests whether the measurement predicts the resulting training loss.
Predicts which masked positions should be filled first, then predicts their tokens with a hierarchy-aware diffusion model. Tests this ordering on text generation and Sudoku, where earlier solved cells can help determine later ones.
Learns probability distributions over continuous reasoning steps from written reasoning traces, with parallel teacher-forced training. A mixture of latent strategies lets the model sample different solution paths before producing an answer.
Repeats a shared block inside each denoising step of a uniform diffusion language model. Studies how training-time loop counts and adaptive stopping affect language modeling quality, training cost and downstream accuracy.
Holds a model response fixed while changing the prompt, then learns hidden-state edits that reproduce the change in token probabilities. Uses these edits and activation patching to show how suggestions can influence reasoning through question and filler-token states without being mentioned in the written response.
LoopLook repeatedly refines visual features in response to a question, with a learned stopping rule and token-wise mixing of intermediate states. Adapts the vision encoder while keeping the language model frozen; the extra computation occurs before ordinary answer generation.
Tests inserting blank filler, repeated or rephrased sentences, and generated explanations at different points in a prompt. Tracks both corrected and newly broken answers across seven models and three datasets, showing why average accuracy alone can hide unreliable gains.
Compares dense, progressively grown and looped Transformers on in-context learning. Attention-head tracing and ablation link stronger context use in grown and looped models to greater reliance on induction heads.
Tests normalization between passes through a looped transformer. Removing it from pretrained Ouro models breaks predictions, while small models trained without it generalize better across loop counts, showing why the computation used during training and inference must agree.
Trains a small controller to insert, delete or remask parts of a text draft, while a frozen diffusion language model fills the gaps. Tests whether these targeted edits improve mathematical answers and code; intermediate reasoning remains explicit text.
Compares the stopping probabilities predicted by halting heads with the iterations actually executed. Useful early exits require training every iteration to predict tokens and a strong penalty favoring early stopping; batches that wait for their slowest token erase most of the advantage.
Trains one mixture-of-experts model with five inference budgets by repeating selected layers. Samples a budget during pretraining and preserves all five paths through instruction tuning and reinforcement learning, allowing callers to trade extra computation for stronger predictions without switching models.
Tests how image-quality scores depend on written reasoning and its hidden states before and after reinforcement learning. Chain swaps, filler controls and activation steering separate information that can be read from a state from information that affects the score.
Adds an LSTM-style gated memory across transformer loops and shares one KV cache across the recurrent core. Aligns cache entries from two training passes with a consistency loss to reduce the mismatch during autoregressive decoding.
Keeps model weights fixed and optimizes continuous input blocks before and during explicit reasoning. A sustained-uncertainty signal triggers a new block, which is updated using confidence scores from short trial continuations.
Date source: ACL Anthology release date.
Predicts separate continuous guide states for reasoning and answering from the question, trained against pooled embeddings of the corresponding text. Inserts these states around an explicit chain of thought during decoding.
Date source: ACL Anthology release date.
Trains a flow model to follow continuous states derived from prefixes of worked solutions. At inference, it integrates a trajectory from noise using the question and decodes the final state into an answer.
Date source: ACL Anthology release date.
Replaces, removes and perturbs latent sequences in a chemical reasoning model. Swapping sequences between molecules often preserves task scores, and a fixed prefix can match input-dependent latent sequences.
Batches later transformer loops across generated positions to accelerate reinforcement-learning rollouts. Replays the rollout schedule to recover its exact token log probabilities while using a dense pass for gradients, and evaluates the resulting training system on math problems.
Tests a cache policy that retains every loop’s keys and values for recent positions and shares the deepest loop’s cache elsewhere. Across three looped language models, recent-position windows fail to provide a reliable repair; convergence across loops and which positions share matter more.
Transplants attention queries from later loops into earlier ones to test how Ouro retrieves two-hop answers. Controlled swaps support bridge-conditioned retrieval on synthetic questions, with weaker results on natural questions and differences between candidate ranking and generated answers.
Corrupts token embeddings with Brownian motion on a sphere and trains a model to recover clean tokens. Controlled comparisons separate the effect of the corruption process from the sampling method on Sudoku, math problems and text generation.
Estimates a token’s contribution by how much revealing it improves predictions at other masked positions. Uses part-of-speech groups to select denoising states and assign reinforcement-learning credit, improving a diffusion language model on math problems.
Measures how quickly tokens settle during diffusion decoding and relates this to variation across repeated answers. Tests whether features from one denoising run predict agreement among independent runs, separating output stability from correctness.
Gives each token a persistent state alongside the output of a shared transformer backbone. Learned gates control what the state retains across loops, and separate readouts feed it into later loops and the final prediction.
Predicts inputs to later transformer loops so several depths can run in parallel, then corrects their outputs as earlier results arrive. Trains the predictor, corrector and shared backbone together with next-token prediction and measures the accuracy-latency trade-off.
Constructs diffusion decoding schedules that reveal tokens useful for predicting the remaining positions. Distills these schedules into the model while keeping the target responses fixed, and tests faster parallel decoding on math and code tasks.
Trains a unified multimodal diffusion model using an autoregressive view for teacher supervision and a consistency loss for blockwise decoding. Evaluates visual math and logic alongside image generation and editing.
Aligns a diffusion model’s low-budget hidden states with its own longer-budget trajectories. Distilling states at committed positions reduces early fixation on wrong answer tokens in math and code tasks.
Compares short and long backpropagation windows in looped language models at matched token and training-time budgets. Extra updates favor shorter windows at small budgets, but that advantage shrinks as training grows.
Speeds up looped language models by copying candidate token spans from the context, screening them at a shallow depth, and verifying them through the remaining loops. Overlaps verification with new proposals and evaluates the approach on code and mathematical reasoning.
Investigates two-hop factual reasoning in a GPT-2-like model trained from scratch. Aligns the positions of atomic facts with the second hop of composite queries, then tests whether the model can answer unseen combinations without written intermediate steps.
Learns which position a diffusion language model should reveal next while keeping the model fixed. A small policy adjusts confidence-based decoding to favor local continuation, distant starting points, or filling gaps, using whole-answer rewards from reasoning and code tasks.
Derives learning and decoding-error bounds for masked diffusion under an assumption that distant tokens have rapidly decreasing influence. Studies how spacing out tokens revealed together trades parallelism against dependence, and identifies limits of the assumption for natural language.
Calibrates diffusion-language-model cache quantization on intermediate masked states that match the decoding process. Keeps selected keys in high precision to preserve attention choices while quantizing the remaining keys and values.
Samples continuous reasoning paths before producing an answer. Trains the paths with explicit-chain supervision, hidden-state distillation, and a balance objective that compares how much intermediate states support the correct answer.
Compares which transformer blocks to repeat, how to give each repetition its own small adapter, and how to run loops in parallel during decoding. Separates the effects of state handoffs and shared attention caches across model sizes and compute budgets.
Converts autoregressive instruction models into diffusion language models by enabling bidirectional attention and training query/value adapters on masked responses. Keeps the backbone and output head fixed, then fills several answer positions per decoding step.
Pretrains a shallow transformer, grows it by copying layers and optimizer states, then adds shared-weight repetitions of its middle block. Uses the compute saved early in training to match a dense baseline in parameters, training tokens, and total training FLOPs.
Measures how quantizing different loop-specific keys and values changes predictions in Ouro and Huginn. Tests sensitivity-based error estimates and bit allocations, distinguishing typical-sequence behavior from large errors concentrated in a few sequences.
Interleaves continuous hidden-state reasoning with written tool calls and observations. Learns from explicit tool-use traces through reconstruction and self-distillation, and chooses when to call a tool or answer after each reasoning block.
Compares learned and untrained stopping rules on a frozen looped language model. Changing how the stopping threshold is chosen reverses which method saves more loops. Finds no demonstrated advantage for a trained probe over a simple KL-based rule; savings are estimated from stored loop traces.
Reuses one transformer block to refine a multi-view geometric state. Trains stable, corrective updates so reconstruction can continue when new images arrive, with stopping based on changes in the hidden state.
Allocates cache precision separately for each loop and layer, shares selected caches across loops, and reads low-attention values at lower precision to reduce the memory and latency of looped language models.
Samples candidate tokens before choosing which positions to commit in parallel. Uses the probabilities of the actual sampled tokens, plus spacing between positions, to control the reliability of each committed set.
Trains a looped transformer using the lowest-loss prediction along its recurrent trajectory. Different depths can produce different valid solutions, which are evaluated on puzzles and code generation.
Ranks and prunes parallel thought–image diffusion trajectories using their stability, uncertainty and text–image agreement. An external verifier contributes more once intermediate previews become reliable.
Chooses which masked positions to fill by comparing predictions with and without the image. Committing visually supported tokens earlier reduces hallucination during multimodal diffusion decoding.
Measures inference bottlenecks in looped language models and improves cache packing, kernel fusion and prefix reuse. Separates changes that preserve exact outputs from changes to batching, randomness or numerical computation.
Combines shared transformer layers with attention over recent residual states across recurrent depths. Evaluates the design in controlled pretraining and releases models trained on open language, math and code data.
Compresses byte sequences into a hierarchy while preserving exact byte information in a separate stream. A shared memory module refines the deepest hidden representation before a causal decoder restores byte-level predictions.
Compresses related key–value cache entries across loops with shared vector codes, then adjusts the codebooks to match the original model’s outputs. Implements the compressed cache in a serving system.
Measures how numerical errors accumulate across speculative verification blocks. Trains a draft model to trigger rejection near decisions in a written reasoning trace, restarting verification where cache entries are computed with higher precision.
Learns when to write an intermediate token and when to feed a hidden state back into the model. Retains important words from each reasoning step as training anchors, then trains the mixed text-and-state policy with answer and length rewards.
Compares shared-layer recurrent transformers with standard models under limited language data, with and without image features. Separates parameter and compute comparisons and measures how data composition and visual input affect linguistic performance.
Trains a standalone diffusion model to draft several tokens at once, then prunes it using verification acceptance as the criterion. Prepares continuation branches while the target model checks the current draft, reusing a branch when its prefix matches.
Reuses a fixed memory bank while decoder layers repeat their reads. Each token writes its local cache once, allowing different recurrent-depth budgets without increasing the stored cache size.
Uses fewer recurrent steps for prompt tokens while retaining more computation for prompt endpoints and generated tokens. Removes finished positions from later loop calls and adjusts prompt depth as the serving queue grows.
Treats residual connections as memory across depth. Loopback keeps the original input separate, decays earlier block updates, and learns attention weights over those updates to control their contribution during repeated transformer passes.
Refines a continuous state before generating recommendation identifiers, anchoring that state to semantic codebook clusters during training. Distills a teacher with item-neighborhood information and allocates more recurrent steps to early identifier levels.
Repeats a shared middle block before scoring answer options, using smaller residual updates when the loop budget grows. Trains one model across several budgets and learns a request-level rule for choosing the amount of computation.
Trains diffusion language models with policy updates conditioned on completed prefix blocks. Applies importance weights and clipping to individual tokens within each block, avoiding the unstable product of all token ratios.
Derives the error from filling several masked positions independently in an exactly solvable Markov-chain model. Uses the dependence between tokens to calculate decoding schedules that reduce this error.
Measures how committing one token changes confidence in other tokens, then uses those interactions to choose which positions to fill together. Shares cached states and model calls between the probes and the main decoder.
Drafts several successive unmasking events and checks their tentative states in a batch. Corrects rejected proposals to preserve the distribution of an event-driven diffusion sampler while reducing sequential model calls.
Routes each sequence through shallow experts repeatedly, using the current hidden state and depth to choose experts. Trains expert-specific stopping signals alongside the language model so computation can end at different depths.
Refines puzzle-solving states by descending a learned energy function. Trains convergence to track answer correctness and supervises the best-matching trajectories when a problem has several valid solutions.
Adds learned thought tokens between a user’s item history and the next-item prediction. Trains their hidden states to represent keywords from past items, then processes all thought tokens in one prompt pass without generating a written reasoning trace.
Try another search, reset the filters, or suggest a missing paper.
Earlier work on repeated computation, deciding when to stop, and learning algorithms.
Introduces learned, input-dependent computation time for recurrent networks.
PDF ↗ · Details & citationsApplies recurrence across transformer depth and supports dynamic halting.
PDF ↗ · Details & citationsRepresents effectively infinite depth through a learned fixed point.
PDF ↗ · Details & citationsStudies recurrent computation as a route to algorithmic length generalization.
PDF ↗ · Details & citationsLearns a probabilistic halting policy for adaptive internal computation.
PDF ↗ · Details & citationsTests whether transformers learn recursive procedures and generalize beyond training depth.
PDF ↗ · Details & citationsShows how looped transformer depth can support learning iterative algorithms.
PDF ↗ · Details & citationsBuilds iterative algorithmic structure into transformer computation.
PDF ↗ · Details & citations