← Deep dives

Deep dives · 2026-11-20 · Advanced · By bombong

Energy-Based Reasoner (EBR): adding a 'how right is it' score to iterative reasoning

The Energy-Based Reasoner (EBR) learns an energy function that evaluates latent reasoning states and treats each iteration as one gradient descent step that lowers this energy. This gives looped models, which repeat the same block, a measure of progress and a stopping signal. On the other hand, the energy landscape must be shaped carefully, and the problem of latent states drifting into unfamiliar regions has to be dealt with as well.

Contents
Key points
  • Looped models increase reasoning depth by repeating the same block many times. However, they have no separate measure that tells them when to stop or in which direction to correct the current state.
  • EBR (2611.08977) assigns an energy score to each latent state and defines the iterative update as gradient descent on this energy. The score indicates progress, and the gradient indicates the direction of correction and when to stop.
  • Training only near the correct answers is not enough to build a good energy landscape. A wider region of the state space has to be shaped as well, using exploration-based training or contrastive learning with hard negatives.
  • Optimizing latent states can push them into regions the decoder never saw during training. In EBRM (2603.28248), this problem caused accuracy on a CNF logic task to fall from about 95% to about 56%.
  • The evidence so far comes from algorithmic tasks with verifiable answers, such as Sudoku, graph connectivity and logical formulas. Extending the approach to general language tasks requires separate validation.

Why it was needed: models iterate without knowing whether they are improving

One way to improve reasoning is 'looping'. Passing inputs through a single neural network block many times increases the effective computation depth while keeping the number of parameters the same. This is called a Loop Transformer or Recurrent Depth. Because harder problems can be given more iterations of thinking, it is also a way of scaling test-time compute. The EBR paper paper likewise views looping as an inductive bias that favors reasoning, that is, a helpful assumption built into the model architecture in advance.

The problem is that existing looped models cannot judge for themselves on what basis they are improving. The state changes with each iteration, but there is no explicit measure of how close the current state is to the correct answer. As a result, the EBR paper paper points out, it is hard to decide when to stop iterating or how to make the current state better.

Other approaches have similar gaps. According to the EBRM paper paper, a decoder that produces the answer in one pass commits to the answer immediately without iterative refinement. CoT (Chain-of-Thought) lays out intermediate steps in text, but has no single-number measure of how far the reasoning has progressed. Energy-based reasoning is an attempt to fill this gap with a 'score'.

Core idea: descending into a valley with an altimeter

Imagine looking for the lowest valley on a foggy mountain. You do not need to see your surroundings as long as you can read an altimeter and feel the slope under your feet. If you keep stepping in the downhill direction, you eventually reach a valley. When the ground under your feet becomes flat, you have reached the bottom and can stop.

In the Energy-Based Reasoner (EBR), the energy function plays the role of the altimeter. It takes the latent reasoning state the model holds internally and returns a single number expressing 'how implausible this state is'. The lower the energy, the closer the state is to a good answer. Going around the loop once is a gradient descent step downhill in the direction that reduces this energy. The EBR paper paper explains that the energy scores the state, and its gradient provides both the direction for refining the state and the signal to stop.

This analogy also naturally covers cases with multiple correct answers. If a mountain has several valleys, you reach a different one depending on where you start. In a probability distribution, a peak is called a 'mode', and in the energy landscape each valley becomes a different candidate answer.

How it works: scoring and stepping down one step at a time

Inference proceeds in the following order. First, the problem is fed into an encoder, converted into a representation in latent space, and the reasoning state is initialized. Next, the energy function scores the current state and computes the direction in which the score decreases, i.e. the gradient. The state is moved slightly in that direction, and this is repeated. When the gradient is nearly zero and there is nowhere further to descend, the process stops and the final state is decoded into an answer by the decoder. EBRM paper notes that besides plain gradient descent, Langevin dynamics can also be used for this descent. Langevin dynamics follows the gradient while adding a little noise, so the state does not get stuck in one valley and can explore others.

Training is closer to sculpting a landscape than to memorizing correct answers. The energy near correct answers must be lowered, and the energy of plausible but wrong states must be raised. EBRM paper added contrastive energy shaping with hard negatives (wrong examples easily confused with the correct answer) to supervised training of the encoder and decoder. EBR paper went further and introduced 'exploration-based training'. During training, it roams a wider part of the state space, discovers modes not yet found, and shapes the energy landscape over that wider range of states as well.

There is a reason for this design. During inference, the model passes through states it never saw directly during training. If the landscape is well shaped only right next to the correct answers, starting even slightly farther away can send the state sliding somewhere wrong. If the landscape is shaped broadly, the gradient is more likely to point in a useful direction wherever the process starts.

EBR inference loopProblem input → Encoder; Encoder → Latent reasoning state(Initialize); Latent reasoning state → Energy function; Energy function → Gradient computation; Gradient computation → State update; State update → Latent reasoning state(Repeat); Gradient computation → Stopping decision; Stopping decision → Decoder; Decoder → AnswerProblem inputEncoderLatent reasoningstateEnergy functionScores the stateGradientcomputationState updateOne gradient descentstepStopping decisionGradient≈0DecoderAnswerInitializeRepeat
EBR inference loop The top row converts the problem into a latent state and scores it with the energy. The loop that corrects the state along the gradient repeats, and when the gradient is nearly zero, the decoder produces the answer.

What was traded off: differences from ordinary looped models

An ordinary looped model directly learns an update rule for 'how to produce the next state'. EBR learns a score for 'how good a state is' and derives the update rule from the gradient of that score. This detour makes it possible to check progress numerically at every iteration. Because the process can stop when the gradient becomes small, it becomes easier to adjust the amount of computation, ending early on easy problems and thinking longer on hard ones. The inference compute savings reported in the EBR paper paper are connected to this structure.

There are costs. First, the gradient of the energy must be computed at every step, so each step can be heavier than a simple forward pass. Second, because the training objective is to shape the entire landscape, it is trickier than training only to get the answer right. How negatives are chosen and how wide the exploration range is strongly affect performance. Third, because the latent state is optimized freely, there is a risk that it drifts into regions unfamiliar to the decoder. This problem is covered in detail under EBRM in 'How the research developed' below.

The difference is clearer in comparison with CoT. CoT leaves the intermediate process as human-readable text, which makes it easy to interpret, but it has no measure of progress. In energy-based reasoning the intermediate process is a latent vector and hard to read, but a score is left at every step. The two can be seen as placing interpretability in different places. Combined with symbolic knowledge, as in CRAFT paper, the approach can also be used to improve interpretability.

Three iterative reasoning approaches

CoTIntermediate steps in text

  • Human-readable
  • No numeric progress measure

Ordinary looped modelLearns the update rule directly

  • Extends depth by repeating a block
  • Hard to decide when to stop

EBRLearns a score; updates via the gradient

  • Checks progress with energy at every step
  • Gradient is the stopping signal
  • Landscape training is tricky; risk of drift

공통 None answers in one pass; all refine the answer over multiple steps

A comparison of what each learns and how it checks progress.

How the research developed: what each of four studies added

The four papers in the source material are better seen as studies that approach the same idea from different angles than as a direct line of succession. In chronological order:

CRAFT paper, from July 2025, addressed visual affordance, the problem of finding objects in a scene that enable an action such as 'cutting'. It refines its predictions by iteratively reconciling commonsense knowledge from ConceptNet and language models with visual evidence seen by CLIP inside an energy-based reasoning loop. The authors reported that this approach improves both accuracy and the transparency of the decision process. It is an example of using an energy loop as 'a device for reconciling different sources of evidence'.

EBRM paper, from March 2026, formalized reasoning as gradient-based optimization over a multi-step latent trajectory. The energy is split into three terms: whether each step fits the input, whether transitions between steps are consistent, and whether the trajectory is smooth. A major contribution of this work is identifying a failure mode. On a CNF formula satisfiability problem, using latent planning caused accuracy to fall from about 95% to about 56%. The cause was distribution mismatch. The decoder had been trained on encoder outputs, but at evaluation it received states optimized by the planner, i.e. states that had drifted into latent regions never seen during training. The authors proposed training the decoder on both paths and latent anchoring, which holds latent states in place, as remedies, and also proposed a six-way ablation protocol.

RW-EBR paper, from June 2026, attached a Modern Hopfield-style trajectory memory to IRED, an energy-based diffusion model. It retrieves records of solving similar problems and uses them as starting points, a so-called warm start. The core of this work is its diagnostic method rather than performance. A five-way comparison (oracle, best constant, per-query random, shuffled and aligned) separates out 'where the gain comes from'. On graph connectivity (connectivity-2), the gap between aligned and shuffled values reached +35pp in balanced accuracy. What produced the gain was per-graph alignment, not bias shifts or randomness. However, the authors also reported negative results: the actual deployment pipeline fell short of the acceptance criteria, and on Sudoku the work stalled at the key-quality stage.

EBR paper, from November 2026, redefined the looped model itself as gradient descent on an energy function and added exploration-based training. On four algorithmic reasoning benchmarks it matched or outperformed existing recurrent reasoning models. On Sudoku-Extreme it reached 99.9% accuracy while using 345 times less inference compute than the next-best model, with similar training compute. On benchmarks with multiple correct answers, it achieved top-level coverage in finding different valid answers while keeping the accuracy of a single sampled answer at nearly 100%.

Limitations and open issues: when to use it and what to watch out for

The scope of the evidence comes first. All four papers ran experiments on tasks with clear structure and verifiable answers, such as Sudoku, graph connectivity, CNF formulas, synthetic tasks and visual affordance. These sources alone cannot say whether the same gains appear on general language tasks such as understanding long texts or answering open-ended questions. The 345x figure is also a comparison with the next-best model on Sudoku-Extreme, not with all reasoning models.

The most common pitfall is latent state drift. As EBRM paper shows, even if the energy decreases steadily, accuracy can actually drop if the decoder cannot read the state properly. 'The energy went down' and 'the answer is correct' are not the same thing. In practice, you should decode at each step and separately track how much the latent state drifts.

The second pitfall is misidentifying the source of a gain. RW-EBR paper stresses that even if a warm start looks good, you cannot tell whether the real cause is a bias shift, the effect of random initialization or genuine reuse of information unless you separate them. It also showed that an effect seen at the diagnostic stage may fall short of the criteria in a deployable form.

In short, the approach is worth considering for verifiable puzzle-type or algorithmic problems that may have multiple correct answers, when you want to match the amount of computation to problem difficulty. Conversely, for work where people need to read the intermediate process, or for tasks with vague verification criteria, it is safer not to assume that the advantages of this approach carry over.

Pre-adoption checklist

Task fit

  • Can answers be verified?
  • Can there be multiple correct answers?
  • Do people need to read the intermediate process?

Experimental design

  • Is latent drift tracked with per-step decoding?
  • Are energy reduction and accuracy examined separately?
  • Have initialization and warm-start effects been isolated with ablations?
  • Has it been re-validated in deployment form?
Items to check when experimenting with or adopting energy-based reasoning.

Further study

If you are reading about this for the first time, start with EBR paper. It states the core claim, 'treat the looped model's update as energy gradient descent', most concisely, and also explains why exploration-based training is needed.

Next, read EBRM paper to see where this approach breaks down. Its design splitting the energy into three terms, the distribution mismatch failure mode and the six-way ablation protocol are worth using directly as references when designing your own experiments.

If you are interested in experimental methodology, look at the five-way ablation design in RW-EBR paper. It can serve as a framework for testing claims that 'adding something made it better', such as warm starts or retrieval augmentation. If you are curious about applications that combine energy loops with symbolic knowledge and vision models, CRAFT paper is a short introduction.

Related terms

Loop Transformer Recurrent Depth Gradient descent Test-time compute CoT Diffusion model Reasoning model Loss function

References

Foundational papers

Written by AI from the listed references and reviewed. Please check the original sources for details.