C-Voting: Confidence-Based Test-Time Voting without Explicit Energy Functions
Authors: Kenji Kubo
Shunsuke Kamiya
Masanori Koyama
Kohei Hayashi
Yusuke Iwasawa
Yutaka Matsuo
Venue: ICLR 2026 Poster (2026)
Keywords: reasoning
test-time scaling
voting
recurrent models
Primary area: unsupervised, self-supervised, semi-supervised, and supervised representation learning
TL;DR: We introduce confidence-based voting (C-voting), a simple test-time strategy that boosts recurrent models’ reasoning reasoning ability.

Abstract: Neural network models with latent recurrent processing, where identical layers are recursively applied to the latent state, have gained attention as promising models for performing reasoning tasks.
A strength of such models is that they enable test-time scaling, where the models can enhance their performance in the test phase without additional training. 
Models such as the Hierarchical Reasoning Model (HRM) and Artificial Kuramoto Oscillatory Neurons (AKOrN) can facilitate deeper reasoning by increasing the number of recurrent steps, thereby enabling the completion of challenging tasks, including Sudoku, Maze solving, and AGI benchmarks. 
In this work, we introduce confidence-based voting (C-voting), a test-time scaling strategy designed for recurrent models with multiple latent candidate trajectories. 
Initializing the latent state with multiple candidates using random variables, C-voting selects the one maximizing the average of top-1 probabilities of the predictions, reflecting the model’s confidence. 
Additionally, it yields $4.9\\%$ higher accuracy on Sudoku-hard than the energy-based voting strategy, which is specific to models with explicit energy functions.
An essential advantage of C‑voting is its applicability: it can be applied to recurrent models without requiring an explicit energy function. 
Finally, we introduce a simple attention-based recurrent model with randomized initial values named ItrSA++, and demonstrate that when combined with C-voting, it outperforms HRM on Sudoku-extreme ($95.2\\%$ vs. $55.0\\%$) and Maze ($78.6\\%$ vs. $74.5\\%$) tasks.

Published as a conference paper at ICLR 2026
C-VOTING: CONFIDENCE-BASER TEST-TIME VOTING WITHOUT EXPLICIT ENERGY FUNCTIONS
Kenji Kubo; Shunsuke Kamiya, Masanori Koyama, Kohei Hayashi, Yusuke Iwasawa & Yutaka Matsuo Graduate School of Engineering. The University of Tokyo
ABSTRACT
Neural network models with latent recurrent processing, where identical layers are recursively applied to the latent state, have gained attention as promising mod- els for performing reasoning tasks. strength of such models is that they en- able test-time scaling, where the models can enhance their performance in the test phase without additional training. Models such as the Hierarchical Reason- ing Model (HRM) and Artificial Kuramoto Oscillatory Neurons (AKOrN) can facilitate deeper reasoning by increasing the number of recurrent steps, thereby enabling the completion of challenging tasks, including Sudoku, Maze solving, and AGI benchmarks. In this work, we introduce confidence- based voting (C- voting), test-time scaling strategy designed for recurrent models with multiple latent candidate trajectories. Initializing the latent state with multiple candidates using random variables, C-voting selects the one maximizing the average of top-1 probabilities of the predictions, reflecting the model's confidence. Additionally, it yields 4.9% higher accuracy on Sudoku-hare hard than the energy-based voting strat- egy, which is specific to models with explicit energy functions. An essential advantage of C-voting is its applicability: can be applied to recurrent mod- els without requiring explicit energy function. Finally, we introduce simple attention recurrent model with randomized initial values named ItrSA++, and demonstrate that when combined with C-voting, it outperforms HRM on Sudoku-extrenn (95.2% vs. 55.0%) and Maze (78.6% vs. 74.5%) tasks.
INTRODUCTION
In recent years, reasoning has been recognized crucial for achieving Artificial General Intelligence (AGI). Recurrent models, which repeat identical layers, have emerged as a promising approach to achieve the goal. A key advantage of recurrent models that their performance can be enhanced at test time without additional training, technique known test-time scaling. The test-time scaling typically realized in two ways: (1) increasing the number of inference recurrence steps, and (2) selecting "good" trajectory from multiple candidates with random sampling, or voting. The method of increasing inference steps (1) has been investigated in (Anil et al., 2022) and other studies. The method of selecting "good" trajectories (2) has recently attracted attention in large language models
(LLMs), particularly in the context of self-connistency (Wang et al. 2023) as well as search and
decoding strategies (aao et al. 2023 Zhou et al. 2022).
Recent recurrent models, such as the Hierarchical Reasoning Model (HRM) Wang et al. 2025) and the Artificial Kuramoto Oscillatory Neurons (AKOrN) (Miyato al. 2025 have become capable of solving complex tasks, including Sudoku and Maze by utilizing test-time scaling. Sudoku and Maze are regarded as benchmarks for reasoning because they require consistent logical inference under complex constraints. These are challenging tasks for conventional models, including lead- ing LLMs as reported in (Wang et al. 2025). HRM mainly relies on increasing recurrence depth, whereas AKOrN introduces energy-based voting (E-voting) in addition to increasing the depth. E- voting samples multiple initial latent states and selects the final trajectory with the lowest energy, yielding large performance gains in Sudoku. It enables further improvement even in cases where performance improvement from increasing the number of recurrent steps is saturated. Specifically,
mannjj.kuh@@chhha....cm

---

Published as a conference paper at ICLR 2026
Sampla
-
.23
AB
Sudoku-hard
Sudoku-extreme
Maze-hard
Recurrent Model
C
89.5%
94.4%
95.2%
7..5%.
78.6%
Doard Accuracy (%
Board Accurary (96)
80-
Board Accuracy 196
(0) Z
(k) Y
:2) 2
30-55.0%
Rosdout Softznax
C-vuting
20
Sclect
AKOIN
ItrSA++
ItrSA++
C-voting
C-voting
(a) Overview
(b) Performance summary
Figure 1: (a): The overview confidence-basee based voting (C-voting). The candidates of the latent state initialized by random variables, and the recurrent model updates the latent states from t 0 to / = T using input æ. Calculating probabilities from the final states, C-voting selects the most confident prediction. (b): The performance comparisons of ItrSA+ with C-voting other state-of-the-art models. The proposed method outperforms in Sudoku-hard, Sudoku-extreme, and Maze-hard tasks.
it has been reported that using 4096 candidates resulted in an approximately 40% increase in the board accuracy (Miyato al. 2025p. Although highly effective, it has the limitation that it cannot be used unless the energy function is explicitly defined. In most promising reasoning models, such as HRM and recurrent transformers (Geiping et al. 2025), the energy is not explicitly defined, mak- ing it impossible to use E-voting. This limitation raises natural questions: (RQ1) Can we facilitate model-agnostic test-time voting strategy without explicit energy functions, and (RQ2) Does there ex- ist simple, lightweight recurrent architecture matching surpassing state-of-the-a performance with C-voting?
In this work, we propose confidence-based voting (C-voting), novel voting strategy at test time, which enhances performance on broader range of recurrent models. C-voting only requires the recurrent models to start from randomly sampled initial values, and does not require explicit energy functions. The model initializes the latent states with random variables, updates them applying an identical model repeatedly, and performs inferences. With these sampled trajectories, the rule of C-voting is very simple: take the most confident one (Figure I(a).. We measure the confidence of a trajectory through the average top-1 probability that the trajectory finally provides. We experimen- tally find that C-voting offers better performance than E-voting in the case of Sudoku-solving with AKOrN.
C-voting can be applied not only to existing models, but also to newly designed, more powerful recurrent models. an example, we introduce ItrAA++, a simple recurrent model with randomized initial values. It outperforms HRM on Sudoku-extreme (95.2% vs. 55.0%) and Maze-hard tasks (78.6% vs. 74.5%), and AKOrN on Sudoku-hard task (94.4% vs. 89.5%) as shown in Figure 1(b) The model only requires about 3 million parameters, which is about one-ninth the number of param- eters HRM, and comparable to that of AKOrN. We also demonstrate that C-voting can be applied to HRM with C-voting. This represents that C-voting is simple and portable test-time voting strat- egy that enables recurrent models to achieve sfate-of the-art performance with significantly fewer parameters.
2 PRELIMINARIES
2.1 RECURRENT MODELS WITH RANDOMIZED INITIALIZATION
Recent works show that recurrent models, which apply identical layers iteratively, are a powerful and promising framework for variety of complex reasoning tasks (Dehghani et al. 2019 Anil al.
2

---

Published as a conference paper at ICLR 2026
2022 Geiping al., 2025; Jaegle al. 2022]] Gladstone et al. 2025 Wang al. 2025 Miyato
et al. 2025| Saunshi et al. 2025 Darlow et al. 2025). Concretely, these recurrent models typically have the form of
2,,41 fzz,,, #;;
(1)
where f is a neural network, 2i, E R the latent state at layer t(E N), 2; E RLXC the i-th input (e.g., image, Sudoku board with blanks) embedded in the latent space, and f the parameters. I. E N the number of tokens, and C' E the embedding dimensions. For models that solve tasks with complex reasoning, such Sudoku or Maze tasks, f oftentimes set to have Transformer-based architecture (Vaswani et al. 2017 Dehghani et al. 2019 Saunshi el al. 2025). Note that the network f(::;)) identical for every hence equation dynamical system.
can be thought of as time-invariant nonlinear
The behavior of the latent dynamics equation depends on the initialization of 21,0, which possibly improves deteriorates the model's performance. One strategy is to sample 2;,0 from probability distribution, e.g., a standard Gaussian distribution. Such randomized initialization can lead the model to learn path independence, or the convergence to the same final steady state (Anil et al.) 2022]. which helps the model to generalize better than initializing the dynamics with a fixed value, e.g., Zg,0 = O.
After repeating equation from / = 0 to ( 7 (T E N), the final latent state 2,, passed to the readout module. In classification problems such as Sudoku, the readout module produces logits, which are subsequently converted to class probabilities by the softmax function or its variant.
Recurrent models with randomized initialization are beneficial not only in parameter efficiency but also in that they allow test-time scaling. Test-time scaling is a phenomenon where the model en- hances its performance without further training, and is observed in number of recurrent models Gladstone et al., 2025 Geiping et al. 2025 Miyato et al. 2025 Hu et al. (025). Test-time scaling be realized in the following two ways: one is to run
iterations inference than in training;
the second is to select from the trajectories. which are initialized randomly, the "best" one based on a pre-determined criterion.
Although the term "test-time scaling" typically refers only to the concept of extending iterative steps, which has been studied extensively (Anil et al.) 2022 Geiping al., 2025 here we place our focus on the other concept, that is, selecting one trajectory from the sampled ones. We consider that this "sample choose", or voring strategy, is significant as extending iterative steps, as the voting strategy can compensate for the next two shortcomings of iterative step extension. First, the performance of recurrent model cannot grow monotonously with extending iterative steps: the per- formance saturate. Second, extending the iterative steps in the test phase requires long iterative computations and cannot be parallelized. The voting strategy works well with parallel computing and can enhance the performance even when it is saturated. Therefore, voting can enhance the reasoning ability to the point where the step extension cannot be solely reached.
RELATED WORK
3.1 RECURRENT MODELS WITH RANDOMIZED INITIALIZATION
As representative examples of the recurrent models with randomized initial values, we focus on HRM (Wang al. 2025) and AKOrN (Miyato et al. 2025 as they demonstrate outstanding per- formance in logical tasks such as Sudoku and Maze.
HRM HRM (Wang al. 2025) is a recurrent model that is gaining attention for its strong rea- soning abilities for the relatively small size (*= 27 million parameters), reaching SoTA in Sudoku- extreme, Maze-hard, and ARC-AGI challenges (Chollet) 2019) Chollet et al.) 2005).. The latent dynamics is two-fold model that has higher and lower order processing given as follows:
L 2,1+1 = f/ (21:0)
H 00)) 2,,0
[ H (2 #h: 0H)
i (mod 7)
(2)
.H 2i,+1
otherwise
3

---

Published as a conference paper at ICLR 2026
where 7 is update cycle for higher-level layers. The superseripts H and L respectively represent higher and lower order processings. This two-fold structure was first proposed as the main break- through but later shown to have limited effect on the performance (Team 2025). HRM makes use of other techniques to boost its performance, such as one-step gradient approximation (taking its origin from Deep Equilibrium Model (Bai et al. 2019)) or adaptive computational time (ACT).
N AKOrN MMyyato et al., 2025 is another recurrent model that shows SoTA performance in the Sudoku-hard task (Palm et 2018). AKOrN utilizes the C-dimensional Kuramoto oscilla- 2019) as the latent dynamics and given as:
tors (Kuramoto 1975
Lipton et al.
A (( + Projz... (ax J (z(,))),
(3)
2 = IT (zi, + 7)21)))
(4)
Here, all rows of 2i are confined on the unit hypersphere (thus have norm one). Q RIC BLxC is a linear map that rotates each token on the hypersphere, and thus represented as set of skew-symmetric matrices. J IR, + L is the connectivity strength between each token pair, and implemented using self-attention. The projection onto the tangent space Proj and normalization onto the hypersphere II are applied token-wise.
3.2 TEST-TIME SCALING WITH B-VOTING
E-voting is a test-time voting strategy introduced in (Miyato et al. 2025). E-voting can be applied to the recurrent model equipped with energy (scalar) function -ie., the recurrent models where a scalar function E' ; IR LXC + IR exists, such that
(5) This dynamics proceeds in the direction which the energy (expectedly) decreases when a is small enough. For example, AKOrN has closed-form energy functior[] whereas energy-based trans- former (Gladstone et al.] 2025) explicitly models an energy using a Transformer-based architecture. As the model learns the dynamics to decrease the energy function, a smaller energy value is ex- pected to reflect higher accuracy. E-voting is based on this assumption, and proceeds as follows. We first sample initial states 2₁,0 for K E N times from a probability distribution, which we denote by {2,,0 ]R([L,K]- We then select the sample with the lowest energy at the final step t = T, i.e.,
1 fzzz. xy 0) Zi, aV V2 0), R...
k = arg min E( 0).
(k)
(6)
This voting strategy is effective in the Sudoku- solving task; in fact, AKOrN achieves about a 40% improvement with E-voting.
Although E-voting is an effective voting strategy, it is not available in many models since the energy function is not explicitly obtained. For example, in recurrent models with residual connection
2 ž₁,1 + g (Z
g has to be written as the gradient of some scalar function, which does not exist in general.
4 CONFIDENCE-BASER VOTING
We describe the detailed procedure of the proposed voting method, C-voting. C-voting, as the name indicates, is simple voting strategy applicable test time. Concretely, C-voting applies the following steps to the trained model. We first sample initial states 2,, for K e N times from a probability distribution, which we denote by {=100 ke[[,, From these sampled initial states, we update the latent state with a neural network f by equation Reading out the final state 2 as logits, we obtain the probability of the class j at the position of k-th candidate as
P2 (2)
Softmax (Readout(2(1)) (A)
(8)
..
Note that equation 5 does not strictly hold when J in equation 3 asymmetric. Nevertheless, E-voting shown be effective for AKOrN in such case.
4

---

Published as a conference paper at ICLR 2026
where the softmax function is applied in the dimension of classes. The position | indicates the location at which the probability computed, e.g., a cell in Sudoku. Then, the top-1 probability at the position I is
P( max P3. (3.(
The average of top-1 probabilities over all positions reflects the confidence of the model. Therefore, define the model's 's confidence for the i-th input and the k-th candidate
Σ LEC
(10)
C
where L denotes the of positions be predicted. e-g., indices of blank cells in Sudoku, and |-| denotes the number of elements in the set. We select the index of the most confident candidate by
k = arg max (t
(11)
Thus, the prediction with the C-voting for input i at position is obtained by
11 = arg max Pa.(2; (
(12)
the model is well calibrated, the following approximation holds
Pr[y., 02.1
1
(=
(k)
(13)
where (() arg max, (=.(= Using equation 13 we obtain the index of the candidate that
maximizes average accuracy across all positions by
arg max
Pr|m
(k) = 11. [+(2
arg max
Σ P= = =
(14)
C
A
IEL
IEC
Note that the average accuracy across all positions may not be the same as the objectives. Neverthe- less, it would be good proxy for them.
ITRSA++
As introduced in subsection 2.1 recurrent models, such as AKOrN and HRM, incorporate various techniques that may be redundant with C-voting. To verify if higher performance can be achieved with simpler and optimized model for C-voting, we introduce ItrSA++, a simple recurrent model to be applied. The design principles of ItrSA++
which C-voting employed to mix random initialization with input, similar to Perceiver (Jaegle et al., 2021). As in (Geiping et al. 2025). linear layer was also tested, but experiments showed that cross-attention per- formed better. (2) Rather than recurrent transformers, we adopt recurrent attention layers to maintain simple architecture. Experiments showed that periodically inserting SwiGLU (Shazeer 2020) out- performs, so we adopt it. (3) The normalization method was determined experimentally. As noted Geiping al.) (2025), normalization has significant impact on the performance. Appendix D confirms these design choices.
follows: (1) Cross- Cross-attention
Concretely, ItrSA++ defined as follows. At first, we embed the input æ; using an embedding layer and apply normalization.
emb Norm NormattnnFmmeediinn (Embedding((::))
(15)
Hereafter, RMSNorm (Zhang & Sennrich, 2019) for the normalization. The initial latent state sampled from a standard normal distribution. To mix the information of the input and the latent state, we cross-attention follows;
Σ,t Norman (2i,) CrossAttn(q= Norm (2 zmmb
x cmbb
(16)
5

---

Published as a conference paper at ICLR 2026
After mixing the information, apply the self-attention layer S E N times.
2 = Normam + (FrTAtn((ormmn(2....)) 2i,1,0 = Ei,t,
(17)
At the end of the iterative self-attention, we apply SwiGLU (Shazeer 2020) and obtain
1 Normmip (1), (Normu
(18)
By repeating block composed of equation T6 equuatontonn 17 and equation [8] times, we obtain the final latent state Z,,. The readout module consists of normalization and linear layer, defined by
logit; = Wo Normour(Zx.7...
(19)
We use Geaa Attention Mechanism (Miyato et al. 2024) as the position embedding.
6 EXPERIMENTS
6.1 BENCHMARKS
Sudoku is a logical puzzle in which the digits are placed in 9 x 9 cells. The cells must be filled with digits to satisfy the following constraints: no digit appears more than once in any row, any column, and any of the nine clues, and players fill in the digits referencing these clues. The difficulty of the Sudoku depends on the number of given digits and their placement. We adopt three kinds of datasets: Sudoku, Sudoku- hard, and Sudoku-extreme extreme datasets. Sudoku and Sudoku-hare datasets identical to those defined in (Miyato et al. 2025). Sudoku dataset (Wang et al.) 2019) consists of 10,000 boards with (31-42) given digits. The first 9,000 samples are extracted for training, and the remaining 1,000 samples are extracted for validation. On the other hand, the Sudoku-hard dataset (Palm et al. (2018) contains (17-34) given digits, which is much fewer than the Sudoku dataset. Sudoku-extrent [Wang et al. 2025) and is challenging dataset. It is composed of Sudoku problems from multiple datasets. We use 1,000 samples for training and 1,000 samples for testing and apply the same data augmentation for Sudoku-extre extremm datasets as in (Wang et al. 2025).
3 sub-grids. Several cells are filled with digits in advance as
introduced in
Maze-hard also logical puzzle in which the players find the optimal path given 30 x 30 cells with passable and impassable cells, start cell, and goal cell. We use the same dataset as in (Wang) al. 2025). which contains 1,000 samples in both the training and test datasets.
For the metric of the model performance, we use the board accuracy, which is defined as the propor- tion test instances for which the model produces an entirely correct board, i.e., all cells satisfy the given constraints without any errors.
6.2 C-VOTING VS. E-VOTING IN AKORN
To compare the performance of C-voting and E-voting, we conduct test-time scaling experiments using AKOrN. For the inference, use C-voting instead of B-voting and run E-voting on the same pre-trained model. Note that no modification is needed to integrate C-voting into AKOrN.
Figure 2 shows that the board accuracy under C-voting outperforms that of E-voting the number of random samples increases. For Sudoku-hard test in |Fiuure 2(a) we use the Sudoku dataset for training and the Sudoku-hare dataset for inference during testing. This experimental setting is identical to that in (Miyato et al. 2025). The board accuracy in C-voting with 4096 samples is 94.4 + 0.1%, which 4.9% higher than that of E-voting (89.5 + 2.5%) reported in (Miyato al., 2025). We also compare the performance with the Sudoku-extreme dataset in Figure 2(b) This result indicates that C-voting outperforms E-voting and is useful for models even with an explicit energy function. For Maze-hard, AKOrN fails to learn, resulting in a test board accuracy of 0.
6.3 ITRSA++ WITH C-VOTING
To show the performance of ItrSA++ with C-voting, we train ItrSA+ for Sudoku, Sudoku-extreme, and Maze-hard datasets and compare the test-time accuracy to HRM and AKONN.
The results are shown in Figure 3 Even without the voting, ItSA++ outperforms AKOrN and HRM for all the tasks. Note that for the HRM experimental results for Sudoku-extreme and Maze-hard,

---

Published as a conference paper at ICLR 2026
Sudoku-hard AKOrN
Sudoku-extreme (9x9), AKOrN
C-Vating
Board Accuracy(15
90
E-Voting
40.0
Civoting
E-vating
Boars Accuracy
15.0
70
32.5
30.0
60
27.5
50
64
126
25.6
512
1024
2040
4096
128
256
random samples
random
(a) Sudoku-hard
(b) Sudoku-extreme
Figure 2: A performance comparison between C-voting and E-voting in AKOON.
Sudoku-har hard (9x9)
Sudekku-extreme extreme (9x9)
hard- (30x30)
90
B-5dee (T-121
It:SA++ (T=64)
HRM
Bowrd Aecumryyt))
80
Board Acouracy'))
70-
IuSA++ (T=32)
70
AKDrN
60
HRM
50-
76
550
40
1024
1:0
256
random samples
random samples
random samples
(a) Sudoku-hard
(b) Sudoku-extreme
(c) Maze-hard
Figure 3: Scaling analysis of ItrSA++ with C-voting.
utilize those reported in (Wang al. 2025). On the other hand, for the HRM results on Sudoku- hard, we employ the original HRM code and modify only the dataset. For all of the AKOrN results, employ the original code (Miyato al. 2025) and implement datasets for Sudoku-exter
and Maze-hard. As mentioned in |subsection 6.2 the test board accuracy of AKOrN for Maze-hard is and not plotted in the figure. ItrSA++ with C-voting scales similarly AKONN for the Sudoku tasks when the number of random samples increases, and also exhibits similar scaling for the Sudoku- extreme task. For Maze-hard, the improvement with scaling weaker compared Sudoku- hard or Sudoku-extreme, but it nonetheless surpasses HRM and confirms the effectiveness of the voting.
6.4 HRM WITH C-VOTING
To demonstrate the general applicability of C-voting, we combine C-voting with HRM and evalu- ate the scaling ability on the Sudoku-extreme dataset. While HRM initializes the latent state with random variables, it fixes throughout training and inference. To integrate C-voting with HRM, we modify to use different initial latent state for each input. We also set the exploration rate for ACT to 1, which means that ACT is not actually used. With these modifications, we train HRM and use C-voting at test-time.
Figure 4 shows the results for different numbers of random samples. The light blue solid line rep- resents board accuracy of HRM with C-voting, and the red dotted line represents that of the original HRM reported in (Wang et al.] 2025). Increasing the number of initial random sam- ples demonstrates improved performance. Note in our experiments, we extended HRM to support randomized initial states, while HRM is originally designed use a fixed initial state across all sam- ples, where introducing randomness can destabilize its updates. Thus, while C-voting shows clear improvements for AKOrN and It,A++, its effect on HRM is limited under this modified setting. Nevertheless, even with this mismatch, we observe non- con-trivial gains when increasing the number of samples.
7

---

Published as a conference paper at ICLR 2026
Sudoku-extreme (9x9), HRM C-Voting
55.0
(c
52.5
50.0
47.5
Veting (T-16)
... HRM original
42.5
37.5
16
random samples
Figure 4: Board accuracy for Sudoku-extreme task of HRM with C-voting.
While the computational complexity of C-voting increases linearly with the number of votes, the computational complexity increase in HRM when increasing the maximum ACT step is expected to be sublinear. Note, however, that our results demonstrate C-voting can be scaled a manner distinct from scaling in the direction of recurrence and does not focus on computational complexity.
6.5 VISUALIZATION OF CONFIDENCE
To analyze the reasons why the performance doesn't 't improve much on the Maze dataset compared the Sudoku dataset, where it scales nicely, visualize the confidence in this section.
First, we show the reliability diagram with several temperatures and the relationship between the expected calibration error (ECH) and average accuracy across all positions with 16 different initial states in Figure 5] When varying the temperature, the ranking of the probability for each position remains unchanged, but the average confidence slightly changes, allowing candidate rankings to fluctuate a little. In fact, calibration does change, with ECE reaching a minimum at T=2. However, we also observe that the impact of calibration on average accuracy across all positions is limited. In our setting, C-voting relies on the relative ordering of confidence among sampled candidates, rather than the absolute calibration measured by ECE. Temperature scaling changes the absolute confidence values but preserves the top-1 ordering within each cell, explaining why ECE varies while accuracy remains nearly unchanged.
We show the distributions of confidence for 32 samples with 32 different initial states grouped by whether predictions are correct in Figure For the Sudoku-extreme samples, we observe a broader distribution for incorrect samples than for correct samples. This indicates that when problems are difficult, predictions become unstable due to the randomness of the initialization. On the other hand, the lower histogram, which is from the Maze-hard hard samples, shows that even for the incorrect predictions, the distribution is tight. This suggests that the model possesses incorrect confidence in the Maze-hard samples, regardless of its initial state.
Figure shows the relationship between the number of iteration steps and confidence for 32 random initial states. In all cases, it can be seen that confidence increases the number of iteration steps increases. For the Sudoku-extreme dataset, the confidence is low when predictions are incorrect. In contrast, this trend is not observed in Maze-hard, which again indicates that the model has incorrect confidence for incorrectly preddicte samples in the Maze-hand harze dataset.
DISCUSSION AND CONCLUSION
We propose C-voting, function is not defined. It starts from multiple initial random latent states in models with recurrent structures and selects the best candidate based confidence.
test-time voting strategy applicable even when the explicit energy
provides test-time scaling other than increasing recursion depth. We show that C-voting can be integrated into A AKOrN, and find that it outperforms E-voting in subsecction 6.2 Although the reason
8

---

Published as a conference paper at ICLR 2026
Reliability Diagram (num votes=16)
Reliability Diagram (num votes=
1.0
T-0.25
1.0
T-0.25
T=0.5
T=0.5
0.8
T=1.0
0.8
T=1.0
T=2.0
T=2.0
Accuraty
0.6
Tw4.0
Accurary
0.6
T-4.0
0.4
0.4
0.2
0.0
0.0
0.0
0.2
0.4
0.8
0.0
0.2
0.4
0.8
Confidence
Confidence
(a) Reliability diagram Sudoku-extreme
(b) Reliability diagram in Maze-hard
Sudoku extreme (9x9) (num, vates=
Sudoku-extreme (9x9) (num, votes-16)
8.47a=1
Average Accuracy across Positions
Averaga Accuracy across Pustonns
0.00002
T-0.55
0.9880
T-0.5
0.00000
T=1.0
0.9878
T-2.0
-0.00004
0.9874
T=0.25
Tm0.5
0.00006
0.9872
T-1.0
T-2.0
-0.00008
0.9870
T=4.0
0.050 0.075 0.100
0.125
0.150
0.275
EGE
(c) ECE vs. accuracy in cedoou-eettrmme
(d) ECE vs. accuracy in Maze-hard
Figure 5: Visualization of calibration of ItrSA++.
for the improvement not yet clear, least in the Sudoku task, the confidence may be more direct proxy for board accuracy than energy.
C-voting achieves state-of-the-art performance by integrating with a new lightweight recurrent model. We introduce ItrSA++ in (section 5) as simple but powerful example of recurrent mod- els for which C-voting can be applied. subsection 6.3) we demonstrate that ItrSA+ integrated with C-voting outperforms AKOrN in Sudoku tasks, and HRM in Sudoku and Maze-hard tasks.
For models such as AKOrN and ItrAA+, which are trained to operate with random initializations, the sampled candidates evolve into meaningfully different predictions, making C-voting effective. For HRM, however, the original design relies on fixed initial state shared across all inputs. In- troducing randomness at inference time breaks this assumption and can lead to similar unstable hidden-state evolutions across samples, which fundamentally limits the improvement obtainable from C-voting. Nevertheless, even under this mismatch, still observe non-trivial gains when the number samples increases.
As in subsection 6.5) performance gains from voting are limited when the model holds incorrect confidence or makes similar predictions regardless of initial random variables. On the other hand, would also be possible that even if the prediction accuracy of the models cannot be improved, C-voting may still enhance performance by making the models produce more diverse outputs.
Since voting based on confidence corresponds to the maximization of average accuracy across all positions, as shown in equation 14] it would be useful for masked language models (Devlin et al.) 2019 Joshi et al., 2020; Li al. (022), text infilling (Zhu et al., 2019 Raffel al. 2020). or image inpainting (Lugmayr et al. [0222 Pathak et al. 2016). Furthermore, using other uncertainty metrics, such as entropy or the sum of log probabilities, may potentially improve performance for specific tasks. We would like to address these topies for future research.
Reproducibility Statement We provide anonymized codes containing training and evaluation scripts for HRM with C-voting, AKOrN with Co/Envoting, and ItrA++. We specify all hyper- parameters in Tables 1-3, including optimizer settings, gradient clipping, EMA, iteration steps T,

---

Published as a conference paper at ICLR 2026
30
25
600
20
400
200
0.600
0.700
ang
0,900
0.600
0,700
0 800
0.900
1.000
0
Confidence
Confidence
(a) Incorrect
prediction for Sudoku- (b) Correct
prediction for Sudoku-
extreme
extreme
200
150
150
Count
Count
100
75
50-
25
0,570
0,960
0,990
1.000
0.985
0.968
9,9
0.995
0,958
1.000
Confidence
Confidence
(c) Incorrect prediction for Maze-hard
(d) Correct prediction for Maze- hard
Figure 6: Distributions of confidence of It+ at 32.
1.0
0.9
Confidence
0.7
Confidence
0.8
0.7
0.6
0.6
0.5
0.5
std
0.4
mean
0.4
mean
max
max
10
15
20
25
30
15
20
30
itteatioon
Iterations
(a) Incorrect extreme
prediction for Sudoku- (b) Correct prediction for Sudoku- extreme
1.00
1.000
0.975
Confidence
0.95
Confidence
0.950
0.925
0.90
0.900
std
mean
0.850
mean
0.825
max
25
of Rterations
of iterations
(c) Incorrect prediction for Maze-hard
(d) Correct prediction for Maze-hard
Figure 7: Time step dependency of confidence.
10

---

Published as a conference paper at ICLR 2026
and the number of attention heads. We also provide exact data preprocessing and augmentation pipelines for Sudoku, Sudoku-hard, Sudoku-extreme, and Maze-hard.
REFERENCES
Cem Anil, Ashwini Pokle, Kaiqu Liang, Johannes Treutlein, Yuhuai Wu, Shaojie Bai, Zico Kolter, and Roger Baker Grosse. Path independent equilibrium models can better exploit test-time com- putation. In Advances in Neural Information Processing Systems, October 2022.
Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Deep equilibrium models. arXiv Septembrr 2019.
François Chollet. On the measure of intelligence. arXiv preprint arXiv: 2019.
Francois Chollet, Mike Knoop, Gregory Kamradt, Bryan Landers, and Henry Pinkard. Arc-agi-2: A new challenge for frontier ai reasoning systems, arXiv preprint urXiv:2505.11833 2025.
Luke Darlow, Ciaran Regan, Sebastian Risi, Jeffrey Seely, and Llion Jones. Continuous thought machines. arXiv preprint arXtiv2505.05522. 2025.
Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In International Conference on Learning Representations, 2019. URL https:
//openzeviev/ net. fort:/foummmmm http://ooooumnaa..yyyo......
Jacob Devlin, Ming-Wes Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 conference of the North American chapter of the association for computational linguistics: human language technologies, volume (long and short papers). pp. 4171-4186 2019.
Katie Everett, Lechao Xiao, Mitchell Wortsman, Alexander A Alemi, Roman Novak, Peter Liu, Izzeddin Gur, Jascha Sohk-Dic,,,ein, Leslie Pack Kaelbling. Jaehoon Lee, et al. Scaling expo- nents across parameterizaatins and optimizers. arXiv preprint 240.::::000.0877.. 2024.
Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian R. Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach. CoRR, abs/2502.05171, February 2025. URL https:://oi. org/10 48550/ 2tt.l...500001577..
Alexi Gladstone, Ganesh Nanduru, Md Mofijul Islam, Peixuan Han, Hyeonjeong Ha, Aman Chadha, Yilun Du, Heng Ji, Jundong Li, and Tariq lqbal. Energy- based transformers are scalable learners and thinkers, 2025. URL https: //trx/aa.vvvv///////a wwt./org//////..o.ooo..o 2507 02092
Yunzhe Hu, Difan Zou, and Dong Xu. Hyper-SET: Designing transformers via hyperspherical energy minimization. arXiv [cs.LG), 2025.
Andrew Jaegle, Felix Gimeno, Andy Brock, Oriol Vinyals, Andrew Zisserman, and Joao Carreira. Perceiver: General perception with iterative attention. In International conference machine learning, pp. 4651 4651-4661 14644 PMLR, 2021.
Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel Weld, Luke Zettlemoyer, and Omer Levy. Span- bert: Improving pre-training by representing and predicting spans. Transactions of the association for computational linguistics, 8:64-77, 2020.
Tero Karras, Miika Aittala, Jaakko Lehtinen, Janne Hellsten, Timo Aila, and Samuli Laine. Ana- lyzing and improving the training dynamics of diffusion models. ArXiv, abs/2312.02666, 2023. URL /tttps://ppp...... http:/ppp..amaiiscchhooooooooose htt.aaar......aa......oooooooopa
Yoshiki Kuramoto. Self-entrainment of population of coupled non-linear oscillators. In Inter- national Symposium on Mathematical Problems Theoretical Physics, pp. 420-422, Springer-
Verlag, Berlin/Heidetherg, 1975.

---

Published as a conference paper at ICLR 2026
Hojoon Lee, Hyeonseo Cho, Hyunseung Kim, Donghu Kim, Dugki Min, Jaegul Choo, and Clare Lyle. Slow and steady wins the race: Maintaining plasticity with hare and tortoise net- works. ArXiv, abs/2406.02296, 2024. URL oo
org/ semaapiiccancncccoolaa..
Siyuan Li, Zicheng Liu, Juanxi Tian, Ge Wang, Zedong Wang, Weiyang Jin, Di Wu, Cheng Tan, Tao Lin, Yang Liu, Baigui Sun, and Stan Z. Li. Switch ema: A free lunch for better flatness and sharpness. ArXiv, 0os/2402.09244) 2024. URL pttpss://ap.. sellssseaatt semanticschollo .orgg/
CorpusID:267653
Xiang Li, John Thickstun, Ishaan Gulrajani, Percy S Liang, and Tatsunori B Hashimoto. Diffusion- Im improves controllable text generation. Advances in neural information processing systems, 35: 4328 4328-4343, 2022.
Max Lipton, Renato Mirollo, and Steven H Strogatz. The kuramoto model on sphere: Explaining its dineennnsional dynamics with group theory and hyperbolic geometry. arXiv [math. July 2019.
Andreas Lugmayr, Martin Danelljan, Andres Romero, Fisher Yu, Radu Timofte, and Luc Van Gool. Repaint: Inpainting using denoising diffusion probabilistic models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 11461-11471, 2022.
Takeru Miyato, Bernhard Jaeger, Max Welling, and Andreas Geiger. GTA: A geometry-aware atten- tion mechanism for multi-view transformers. In The Twelfth International Conference on Learn- ing Representations, 2024.
net/ forum d=uJJHHygeee2
Takeru Miyato, Sindy Löwe, Andreas Geiger, and Max Welling. Artificial kuramoto oscillatory neurons. In The Thirteenth International Conference Learning Representations, 2025. URL
https:// http::///ppeneeeee....oo net. www.mmidddwwwer...... 4AMoN
Rasmus Palm, Ulrich Paquet, and Ole Winther, Recurrent relational networks. Advances in neural information processing systems, 31, 2018.
Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Proceedings of the IEEE conference computer vision and pattern recognition, pp. 2536-2544, 2016.
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of machine learning research, 21(140):1-61) 2020.
Nikunj Saunshi. Nishanth Dikkala, Zhiyuan Li, Sanjiv Kumar, and Sashank Reddi. Reasoning with latent thoughts: On the power of looped transformers. arXiv preprint arXiv:2502.
2025.
Noam Shazeer. Glu variants improve transformer. arXiv preprint arXiv:2002.05200 2020.
ARC Prize Team. The hidden drivers of hrm's performance on arc-agi, 2025. URL https: arcprize wttg/blggghhmmeeeooooooggg////oe
lysis
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural informa- tion processing systems, 30, 2017.
Guan Wang, Jin Li, Yuhao Sun, Xing Chen, Changling Liu, Yue Wu, Meng Lu, Sen Song, and Yasin Abbasi Yadkori. Hierarchical reasoning model. 2025. URL htthtt://///x...rrr.
fbs/2506.21733
Po-Wei Wang. Priya Donti, Bryan Wilder, and Zico Kolter. Samee: Bridging deep learning and log- ical reasoning using a differentiable satisfiability solver. In International Conference on Machine Learning, pp. 6545-6554. PMLR, 2019.
12

---

Published as a conference paper at ICLR 2026
Sudaku-hart hard (9x9)
Sudoku
Maze hard (30x30)
80-
60
50
Bowns Brand AccurwsyyN
60-
40
40
30
40
Bowre Somee 300
30
20
20
20
Figure 8: Test-time scaling in ItrSA++
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. The Eleventh International Conference on Learning Representations, 2023. URL https: /pwpreeeeeieeeeee net
NTMMr
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Ad- vances neural information processing systems, 36:1 1809-11822, 2023.
Biao Zhang and Rico Sennrich. Root mean square layer normalization. Advances in Neural Infor- mation Processing Systems, 32, 2019.
Denny Zhou, Nathanael Schärli, Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuur- mans, Claire Cui, Olivier Bousquet, Quoc Le, et al. Least-to-most prompting enables complex reasoning in large language models. arXiv preprint arXiv:2205.10625, 2022.
Wanrong Zhu, Zhiting Hu, and Eric Xing, Text infilling, arXiv preprint arXiv:1901.00753 2019.
A TEST-TIME SCALING IN ITRSA+
ItrSA++ ++ has recursive structures similar to models such as the recurrent transformer (Geiping et al. 2025 Jaegle et al.) 2021). and test-time scaling be observed. [Figure 8 demonstrates that for Sudoku-hame hard, Sudoku-extreme,, and Maze-hard tasks, board accuracy increases as the number of iterative steps grows in ItrSA++.
B TRANSFORMER WITH C-VOTING
To validate the performance improvement by C-voting for other than recurrent models, we also integrate it into transformer and conduct experiments. Training is performed using the Sudoku dataset, and testing performed using the Sudoku-hard dataset. This the same problem setting as subsection 6.2 Unlike standard transformer, it requires random initial latent state to use C- voting. Therefore, we mix the imput æ and the initial latent state z using linear layer before feeding them into the transformer.
Figure shows the dependence of board accuracy on the number of random samples for initial states. Since the transformer is not performing well on the Sudoku-hard task, performance improvements through C-voting are also limited.
C EXPERIMENTAL DETAILS
In this section, we provide an overview of the experimental details. We apply exponential moving average (Karras et al. 2023 Lee et al. 2024 Li et al. 2024) for the model parameters of ItsAA+ and AKOrN. We adopt gradient truncation Geipping et al. 2025) for ItrSA++. More precisely, during the training, detach the gradient of the latent state 2, at / for Sudoku, = 14 for
13

---

Published as a conference paper at ICLR 2026
Sudoku-hard (9x9)
2.14
Board ( (%)
2.12
2.10
2.08
2.06
2.04
2.02
2.00
128
256
512
1024
2048
4096
# of random samples
Figure 9: Board accuracy transformer with C-voting.
Parameter
Value
Optimizer
Adam
B for Adam
(0.9, 0.95)
Weight decay
0.01
Gradient clipping threshold
1.0
Learning rate
x 10
Batch size
64
EMA decay rate # of heads Embedding dims.
0.995
12
384
# of repetitions of Self-Attn.
Table 1: Hyperparameters for ItrSA++.
Sudoku-extrenee and at 28 for Maze. We show the hyperparameters for ItrSA+ Table for HRM in Table 2 and for AKOrN in Table 3 The number of parameters is <3 million for AKOrN and ItrSA++, and 27 million for HRM with these settings.
Parameter
Value
Optimizer
Adam-atan2 (Everett et al. 2024
3 for Adam
(0.9,0.95)
Weight decay
1.0
Gradient clipping threshold
1.0
Learning rate
10-4
Warm-up steps Batch size
2000
768
# of heads Embedding dimension Epochs of H layers
8
512
20000
4
of L layers
4
Halt exploration prob.
1.0
Table 2: Hyperparameters for modified HRM.
14

---

Published as a conference paper at ICLR 2026
Parameter
Value
Optimizer
Adam
3 for Adam
(0.9, 0.999)
Gradient clipping threshold
1.0
Learning rate
5 x 10
Batch size
100
EMA decay rate
0.995
# of heads
8
Embedding dimension Epochs
512
100
# of iteration steps
16
# of Kuramoto layers Oscillator dims. Step size Connectivity
1
4
1.0
Attention
Table 3: Hyperparameters for AKOON.
Variant
Board acc. in test
w/o GT w/o EMA
0.0%
0.0%
Cross attn. to linear
59.2%
SWiGLU FFN
62.0%
(ProosoP))
63.2%
Table 4: Ablation study for ItrSA++
D ABLATION STUDY OF ITRSA++
To clarify the contribution of each architectural and inference component of ItrSA++, conduct ablation experiments on Sudoku-extreme, Table 4 summarizes the results.
Overall, the ablations demonstrate that (1) ItrSA++ requires EMA and GT for stable training, (2) the cross-attention block provides meaningful improvements in reasoning ability.
We further examine how the effectiveness of voting changes when using metrics other than top-1 probability P1(2z,7) in Equation Specifically, we use negative entropy (NE) and the sum of log probability (LP) defined below.
(2 (1NE)
((NE) (k) P3n(z((1)) (k) log (T)()
Σ
(k)
(20)
p(LP) (K) max log (3. (k)
(21)
The results with ItrA++ are shown Figure 10 observed, and even in Maze-hard. the difference is only about 0.1%. This is thought to be because when the top-1 probability is dominant, there is little difference in ranking across metrics. On the other hand, since it facilitates analyses such as EEquation 14 we adopt the top-1 probability.
For Sudoku-extreme, almost no difference is
E PERFORMANCE DEPENDENCY ON RANDOM SEEDS
Our method uses random variables, so performance may vary when different random seeds are used. To verify this, we perform inference ItrSA+ with C-voting using multiple random seeds. Figure II shows the box plots of the results obtained using five different seeds. Compared with Sudoku-extreme, Maze-hard exhibits greater seed dependence, though it remains at around 1 1%. However, looking at the median, board accuracy increases almost monotonically. indicating that the overall results are not significantly affected.
15

---

Published as a conference paper at ICLR 2026
Sudoku-Extrens Extreme (9x9)
Maze (30x30)
90
log probability
78.0
negative entropy
77.8
Board Accuracy(S5)
probability
Accuracy
80
77.4
77.0
log probability
76.8
negative entropy
max probability
6
random samples
# random samples
(a) Sudoku-extreme
(b) Maze-hard
Figure 10: Comparison of voting effects across different metrics.
Sudoku-extrenn (9x9)
Maze-hard (30x30)
90
85
Board Accuracy(ss)
Board Accuracy(96)
2
32
64
2
64
random samples
# random samples
(a) Budoku-extreme
(b) Maze-hard
Figure 11: Random seed dependency of board accuracy.
16

---

Published as a conference paper at ICLR 2026
F USE OF LARGE LANGUAGE MODELS
We use large language models (LLMs) to refine writing for this paper and partially use them for code generation of experiments. We also use LLMs to help explore related works.
17


Reviews:
[{"review_id": "gCTN9Lnb8U", "reviewer": "Reviewer_exsu", "summary": "The paper proposes C‑voting, a test‑time voting strategy for recurrent models that generates multiple candidate trajectories by sampling random initial states and then selects the trajectory with the highest average top‑1 probability across all positions. Unlike energy‑based voting (E‑voting), C‑voting does not require an explicit energy function, making it applicable to recurrent models such as HRM and AKOrN. To verify its effectiveness, the paper also proposes a simple attention‑based recurrent architecture, ItrSA++. Empirically, the authors report sizeable gains: HRM with C‑voting improves on Sudoku‑extreme (from 55.0% to 71.2%), C‑voting surpasses E‑voting on Sudoku‑hard when many samples are used (e.g., 94.4 ± 0.1% vs. 89.5 ± 2.5% at 4096 candidates), and ItrSA++ with C‑voting outperforms HRM/AKOrN on Sudoku‑extreme and Maze‑hard. The paper also analyzes how C-voting can fail due to poor calibration of the recurrent model.", "questions": "* In Fig. 2, why is HRM with C-voting performs exactly identical with random samples from 2 to 16?\n* To mitigate calibration issues, I recommend the authors to consider standard calibration techniques. For example, temperature scaling [3] introduces a single scalar temperature for the output logits, which is calibrated on a separate validation set.\n\n[3] Guo, Chuan, et al. \"On calibration of modern neural networks.\" ICML 2017", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "* The proposed method is straightforward and easy to use. The voting rule is model-agnostic and only requires per-position class probabilities. It should combine easily with other improvements to recurrent models and yield even better results.\n* The proposed method enables a new dimension of test-time scaling. Existing approaches mainly scale the number of iteration steps, which can saturate at large step counts. Here, multiple random initializations provide an orthogonal axis of improvement, and should be easy to be made parallel. Consequently, the proposed method should be able to make good use of the increasing compute power. \n* The reported empirical gains are impressive.", "weaknesses": "* The effectiveness of C-voting relies on the model's calibration , which is not always satisfactory, especially when data are limited.\n* The experimental coverage seems to be selective, or at least the design of experiments is not fully explained. Only Sudoku-extreme and Sudoku-hard results are reported for Fig. 2 and 3, respectively. One would typically expect all of Sudoku, Sudoku-hard, Sudoku-extreme and Maze-hard to be included across Fig. 2-4.\n* Fig. 2 and 3 report the results from prior works. As the results in DL research can be highly sensitive to implementation details, it can be hard to tell if the improvements actually come from the proposed method.\n* Ablations on the effectiveness of ItrSA++ are absent. It is not impossible that the improvements actually come from a better design or implementation of the model rather than C-voting.\n* The idea of sampling multiple reasoning paths at test time for better output is long-standing in LLM research, such as [1] and [2]. Given the similarity, the novelty of the method is not significant.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "gD7Scwzs6s", "reviewer": "Reviewer_8TRX", "summary": "In this submission, the authors present C-Voting, a new method to readout from recurrent neural network-based reasoning models that uses prediction confidence. The proposed method starts with stochastically initializing the first state of an RNN with K candidate states. The RNN architecture is applied to map each of the candidate states to prediction logits. Based on average confidence, the final response of the RNN is chosen to be the output corresponding to that initial state which produces the largest prediction confidence. The authors empirically show that C-Voting outperforms previously proposed methods like E-Voting on a couple of standard reasoning benchmarks (Sudoku and Maze solving). In addition, the authors also propose ItrSA++ -- a new RNN architecture that works effectively with C-Voting and is notably simpler than prior art (HRM and AKOrN).", "questions": "NA. Please refer to my above review.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "Strengths:\n- The proposed approach is a straightforward, simple intervention to reading out task responses from RNNs. C-Voting is broadly applicable to RNNs applied to reasoning problems with a classification head, as the approach doesn't make any further restrictive assumptions on the network's architecture or training method. \n- Empirically, C-Voting outperforms E-Voting (although some key figures lack estimates of statistical significance) on challenging versions of both Mazes and Sudoku.\n- The paper is quite well-written, the explanation of C-Voting and ItrSA++ are accessible to the average reader.", "weaknesses": "Weaknesses:\n- A weakness of C-Voting is that the approach might not work effectively when multiple random initializations of an RNN state don't yield  outputs with significantly varied confidence estimates. It is likely that such behavior might arise when training RNNs on increasingly challenging / high-dimensional reasoning problems. Can the authors comment on whether their experiments have explored such a failure mode of C-Voting, and how they intend to circumvent this issue?\n- Figures 2-4 showing comparison of C-Voting with other baselines doesn't show performance variance. The authors should report the statistical significance of differences observed between the baselines compared.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "4RvXGIfwHt", "reviewer": "Reviewer_zXk5", "summary": "### Summary\n\nThis paper introduces C-voting (Confidence-based Voting), a test-time scaling strategy for recurrent neural networks that enables performance improvements without additional training. Unlike existing energy-based voting (E-voting) methods that require explicit energy functions, C-voting works by:\n- Sampling multiple random initial latent states\n- Running the recurrent model from each initialization\n- Selecting the trajectory with the highest average top-1 prediction probability (confidence)\n\n### Main contributions:\n\n- C-voting method: A model-agnostic voting strategy applicable to any recurrent model with randomized initialization, not just those with explicit energy functions\n- Integration with HRM: Demonstrates that C-voting improves HRM's Sudoku-extreme accuracy from 55.0% to 71.2%\n- Comparison with E-voting: Shows C-voting outperforms E-voting on AKOrN for Sudoku-hard (94.4% vs 89.5%)\n- ItrSA++: Introduces a simple attention-based recurrent model (~3M parameters) that achieves state-of-the-art results when combined with C-voting: 95.2% on Sudoku-extreme, 94.4% on Sudoku-hard, and 78.6% on Maze-hard\n\nThe paper evaluates on three reasoning benchmarks (Sudoku-hard, Sudoku-extreme, Maze-hard) and shows that C-voting provides effective test-time scaling through parallelizable sampling rather than sequential depth increases. The method's effectiveness is attributed to selecting trajectories based on model confidence, which serves as a proxy for prediction accuracy in well-calibrated models.", "questions": "- Why is the C-voting vs. E-voting comparison (Figure 3) only shown on Sudoku-hard? You have trained AKOrN models and evaluate on Sudoku-extreme and Maze-hard elsewhere. Can you provide the C-voting vs. E-voting comparison on all three benchmarks to support the claim that C-voting outperforms E-voting more generally?\n- How well-calibrated are your models, and when does this assumption break down? Equation 14's justification assumes model calibration. Can you provide calibration curves (e.g., reliability diagrams) for your models? Figure 6 suggests Maze-hard has poor calibration - what are the conditions under which C-voting fails?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "- The paper identifies a genuine problem with E-voting (requires explicit energy functions) and proposes a model-agnostic alternative that can be applied to broader classes of recurrent models like HRM and recurrent transformers.\n- C-voting is simple to understand along with the theoretical justification provided in the paper of how selecting the most confident trajectory could be seen as searching for the optimal solution in Sudoku. The method itself is easy to implement and integrate into existing models without architectural changes. \n- Shows positive results across multiple models (HRM, AKOrN) and tasks, with substantial gains (e.g., HRM: 55.0% → 71.2% on Sudoku-extreme; AKOrN: 89.5% → 94.4% on Sudoku-hard). Although the paper doesn't report performance of all models across all the benchmark.", "weaknesses": "- C-voting vs. E-voting is only shown on Sudoku-hard (Figure 3), despite the authors having trained AKOrN models and evaluating on three datasets total. This makes the claim that \"C-voting outperforms E-voting\" (Section 6.3) inadequately supported. A complete comparison on all benchmarks is needed to validate this central claim.\n- Figure 2's comparison seems misleading. it shows HRM's original performance as a flat line while scaling only C-voting's sample count. A fair comparison would show HRM's native test-time scaling method (increasing recurrence depth) vs. C-voting on a compute-normalized x-axis. The paper claims that the performance can saturate with increasing recurrence depth. However, the same is applicable for increasing the same count for C-voting and it's not clear whether C-voting would reach higher test-time optimized accuracy than HRM.\n- Evaluation is restricted to three small reasoning tasks (1,000 test samples each), all involving constraint satisfaction puzzles. HRM had evaluations on the ARC-AGI task while AKOrN had evaluations on image segmentation tasks, along with the Sudoku which provided further empirical grounding to their claims on generalization. The authors could have picked another evaluation in a different domain like ARC-AGI for further empirical grounding.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "3Jgs5af9ch", "reviewer": "Reviewer_aCB1", "summary": "This paper introduces C-voting, a model-agnostic test-time voting strategy for recurrent neural models used in complex reasoning tasks. Unlike previous methods like E-voting, C-voting does not require an explicit energy function. Instead, it generates multiple candidate solutions from random initializations and selects the one with the highest \"confidence,\" defined as the average top-1 probability across all prediction outputs. The authors also propose ItrSA++, a simple 3M-parameter recurrent attention model. Experiments show C-voting is effective: it boosts the performance of HRM on Sudoku-extreme (55.0% to 71.2%), outperforms E-voting on the AKOrN model (94.4% vs 89.5%), and, when combined with ItrSA++, achieves new state-of-the-art results on Sudoku-extreme (95.2%) and Maze-hard (78.6%).", "questions": "Please refer to above Weaknesses.", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The paper is well-written, clearly organized, and effectively motivates the work. It pinpoints the limitation of E-voting (its reliance on an explicit energy function) and proposes a logical, general solution.\n2. The core contribution, C-voting, is intuitive and model-agnostic. Using the average top-1 probability as a proxy for confidence is a clean and effective way to extend test-time voting to a broader class of recurrent models that lack energy functions.\n3.  The results demonstrate the method's effectiveness. C-voting outperforms specialized E-voting on the AKOrN model. Furthermore, when combined with the new lightweight ItrSA++ model, it achieves promising performance on difficult reasoning benchmarks like Sudoku-extreme and Maze-hard.", "weaknesses": "1.  The paper's core contribution, C-voting, hinges on defining confidence as the average of top-1 probabilities. This is a plausible choice, but it is one of many possible uncertainty metrics. It would be helpful to  compare this choice to other common metrics (e.g., negative entropy, sum of log probabilities). Without this comparison, it might be unclear if the chosen metric is optimal or simply one that works well for Sudoku, limiting the understanding of why C-voting is effective.\n\n2.  The paper introduces both a new voting method (C-voting) and a new model (ItrSA++). The SOTA results (e.g., 95.2% on Sudoku-extreme) are achieved by combining them. But it seems hard to disentangle the contributions. How much of the performance gain comes from the strong baseline architecture of ItrSA++ itself, and how much is added by C-voting? It would be helpful to provide the baseline (K=1) performance of ItrSA++ on all tasks to isolate and quantify the true benefit of C-voting. Furthermore, the design choices for ItrSA++ (Cross-Attention, SwiGLU, etc.) are not well-justified with ablation studies.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)