Change how intermediate steps are generated, revised, or searched—for example, by refining several steps in parallel. These are related approaches: some still produce written chains of thought.
For example: A diffusion model refines representations of a solution over several rounds, rather than committing to each word in left-to-right order. The final reasoning can still be readable text.
Diffusion of Thought changes how a chain of thought is generated: it refines the solution through denoising rather than committing to words strictly from left to right. This changes the generation schedule, not necessarily the visibility of the reasoning. The resulting chain can still be text, unlike methods that only emit the final answer.
Sources: Diffusion of Thought · Deng et al. (2024), §3
Paper details: Diffusion of Thoughts: Chain-of-Thought Reasoning in Diffusion Language Models · From Explicit CoT to Implicit CoT: Learning to Internalize CoT Step by Step
Dates usually refer to the first arXiv submission. Search or filter these papers →
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.
Encodes continuous data such as images as vectors, then generates those vectors with diffusion inside a causal transformer. This is related work on multimodal generation, rather than a method trained directly on reasoning steps.
Feeds posterior expectations back into a language model so intermediate generation can remain continuous instead of sampling discrete tokens.
Applies Jacobi-style iteration to update continuous reasoning states in parallel rather than strictly one step at a time.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. This combines retrieval with parallel textual reasoning rather than removing the text trace.
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.
Extracts reasoning-guiding token chains and prioritizes them during diffusion-model training to improve denoising speed and accuracy. This is a related text-generating approach, not reasoning without a written trace.
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.
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.
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.
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.
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.
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.
Extends integrated-gradient attribution across layers and denoising steps to examine which inputs influence a diffusion model's developing response. Includes multi-hop graph reasoning; the authors present attribution as a complement to, not a replacement for, causal intervention.
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.
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.
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.
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 tests of whether the answer actually uses those thoughts.
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.
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.
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.
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.
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.
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.
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.