N-Way Self-Evaluating Deliberation

• N-Way Self-Evaluating Deliberation (NSED) is a runtime mixture-of-models architecture that orchestrates heterogeneous agents through iterative consensus and semantic recurrent updates.
• It employs a five-stage loop where models generate proposals, cross-evaluate, and aggregate votes using an identity-blind quadratic voting mechanism with a dynamic forget gate.
• NSED scales inference-time reasoning on consumer-grade hardware, achieving significant improvements in benchmarks for math reasoning, coding, and safety tasks.

N-Way Self-Evaluating Deliberation (NSED) is a Runtime Mixture-of-Models (MoM) architecture for inference-time reasoning that coordinates heterogeneous models or agents to generate proposals, cross-evaluate one another, and iteratively refine a shared consensus state rather than relying on a single monolithic model (Pecerskis et al., 23 Jan 2026). The protocol is formalized as a macro-scale Semantic Recurrent Neural Network (SRNN): the ensemble behaves like an RNN/LSTM at the level of whole models, with an evolving consensus state $S_t$ that is fed back into subsequent rounds through a semantic decay or forget mechanism $\gamma$. Within this framing, NSED is presented as recurrent, semantic rather than token-routed, identity-blind, self-evaluating, and cost-aware, with the broader aim of scaling inference-time compute through deliberation steps and model composition rather than only through parameter count (Pecerskis et al., 23 Jan 2026).

1. Conceptual definition and motivation

NSED is defined by a five-stage loop: multiple models generate candidate answers, models score each other’s proposals, the system aggregates these evaluations into a new consensus state, the updated state is fed into the next round, and the process halts when gains diminish or budget is exhausted (Pecerskis et al., 23 Jan 2026). The paper presents this as a means of obtaining “System 2” style deliberation from smaller or heterogeneous models without requiring a single huge model.

The motivation is framed against three limitations in existing paradigms. First, traditional Mixture-of-Experts (MoE) systems route at the token level via a static or learned gating network, which the paper characterizes as a granularity mismatch for complex reasoning. Second, Mixture-of-Agents and Chain-of-Agents are described as feed-forward DAGs in which information moves in one direction, depth increases memory cost linearly, errors can propagate downstream, and no recurrent correction loop exists. Third, standard ensembles and majority voting are described as vulnerable to herding, authority bias, and the absence of a transparent mechanism for trustless, self-correcting consensus (Pecerskis et al., 23 Jan 2026).

Within this problem setting, NSED is proposed as a recurrent alternative that performs semantic routing at the session or task level, rather than token routing, and treats model composition as an inference-time optimization problem. The paper’s broader claim is that intelligence can be scaled by increasing deliberation depth and heterogeneous composition under budget constraints, rather than solely by increasing the size of a single checkpoint.

2. Relation to adjacent architectures

Relative to traditional MoE, NSED is characterized as a macro-level analogue rather than a direct extension. Traditional MoE routes tokens to experts, uses a gating network, and usually remains embedded in one model architecture. NSED instead selects entire models or agents at runtime, routes at the session or task level, uses a Dynamic Expertise Broker, treats model selection as a knapsack-style optimization problem, and is described as orchestrating multi-agent deliberation rather than merely routing compute (Pecerskis et al., 23 Jan 2026).

Relative to Mixture-of-Agents, Chain-of-Agents, and related DAG ensembles, the key distinction is recurrence. NSED loops state back into the next round, allows iterative refinement over time, can stop early once convergence is reached, and is explicitly presented as avoiding the linear-depth memory growth associated with feed-forward agent graphs. This recurrent structure is central to the paper’s claim that intermediate errors need not be terminal, because later rounds can revise prior consensus.

Relative to simple majority voting, NSED introduces structured role separation and persistent state. Proposals are anonymized before scoring, self-voting is disallowed, quadratic voting is used for aggregation, and the deliberative trajectory is accumulated into a continuing consensus state rather than reduced to a single one-shot vote. The paper also states that the system learns from telemetry for future sessions (Pecerskis et al., 23 Jan 2026). This suggests that NSED is intended not merely as an aggregation rule but as an inference-time control architecture.

3. Core architecture and governance mechanisms

The overarching architecture is a Runtime Mixture-of-Models in which a temporary ensemble system is assembled for a task from heterogeneous models. The control-plane component is the Dynamic Expertise Broker, which chooses which models to activate, how many deliberation rounds to run, and under what latency, cost, and quality constraints. The paper gives the optimization objective as

$$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$$

subject to

$$\text{Latency}(A, T) \le T_{max}^{SLA}, \quad \text{Cost}(A, T) \le C_{max}^{SLA}, \quad \text{Quality}(A) \ge \mathcal{Q}_{min}.$$

Here, $A$ is the selected agent subset, $T$ is the number of rounds, $\lambda$ is cost elasticity, and utility is predicted from historical telemetry (Pecerskis et al., 23 Jan 2026). The paper emphasizes that the broker is not simply choosing the strongest model, but the best hardware-time configuration for the task.

Execution is coordinated by an orchestration fabric that manages synchronous rounds, model generation, N-to-N cross-evaluation, state updates, early stopping, and hot-swapping if one model stalls. The architecture includes a Client/Task, an Orchestrator, a Broker, multiple Agents, and a shared NSED state $S_t$. The orchestrator uses barrier-style round execution and can replace stragglers to preserve SLA (Pecerskis et al., 23 Jan 2026).

The trustless governance mechanism is identity-blind. Proposals are anonymized before scoring according to

$$\text{Route}(M_j, \hat{P}_i) \quad \text{s.t.} \quad P(\text{Author}(\hat{P}_i) = M_i \mid M_j) = \frac{1}{N},$$

and self-voting is disallowed through the diagonal mask

$v_{j,i} := 0 \quad \forall i = j.$

The stated purpose is to reduce sycophancy, self-dealing, reputation-based bias, and herding (Pecerskis et al., 23 Jan 2026). The paper’s aggregation mechanism is a Quadratic Voting activation function, described as a square-root style transform with budget normalization, intended to yield nonlinear vote weighting, saturation under budget caps, and reduced influence of extreme self-reinforcement.

4. Recurrent formalization and stopping dynamics

The paper repeatedly formalizes NSED as a macro-scale RNN or SRNN in which the hidden state is the consensus state rather than a vector of neuron activations (Pecerskis et al., 23 Jan 2026). The dynamic embedding stage combines the current task with the previous state:

$\gamma$0

Each agent then produces a proposal,

$\gamma$1

after which cross-evaluation and aggregation update the shared state.

The recurrent core is the feedback-driven state update:

$\gamma$2

In the paper’s interpretation, $\gamma$3 functions as the cell state, $\gamma$4 functions as a semantic attention regulator or forget gate, and the voting-based aggregation acts as the gated update (Pecerskis et al., 23 Jan 2026). The associated recurrence,

$\gamma$5

is used to express how the system preserves useful prior consensus while discarding stale or noisy reasoning.

The paper also defines a time-varying decay schedule,

$\gamma$6

meaning that feedback is effectively clamped off once the estimated optimum stopping point is reached. A related halting criterion is based on the convergence delta: if $\gamma$7, stop early. In future work, the paper proposes

$\gamma$8

as a thermodynamic stopping rule (Pecerskis et al., 23 Jan 2026).

A separate thermodynamic utility curve is introduced to model the trade-off between signal extraction and fatigue. The paper states that convergence requires $\gamma$9, where $$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$$0 is base generation precision and $$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$$1 is verification precision, and interprets the quadratic penalty term as growing context noise and overthinking. The conceptual role of this model is to explain why additional rounds can help initially and degrade later.

5. Benchmarks, performance, and safety behavior

The empirical evaluation is reported on AIME 2025 for math reasoning, LiveCodeBench v5 Hard for coding, and DarkBench for safety or dark patterns, all in a text-only regime without sandbox execution feedback in order to isolate the topological effect (Pecerskis et al., 23 Jan 2026).

Benchmark	Reported results	Notes
AIME 2025	Majority voting (Qwen-8B): 54.0%; Gemini-2.5-Pro-06-05: 78.3%; DeepSeek-R1: 84.2%; NSED (consumer open-weight): 84.0%; NSED (high-performance open-weight): 90.0%	Peak around round 6 for consumer and round 5 for high-performance
LiveCodeBench v5 Hard	NSED started around 51.5%; reached about 60.2% pass@1; majority voting baseline was about 33.1%	Fluctuations attributed to over-refactoring and lack of compiler feedback
DarkBench	NSED-R2 sycophancy: 0.040; lowest overall RMS score: 0.285	Sneaking did not improve relative to baseline

On AIME 2025, the paper states that a consumer-grade small-model ensemble reached 84% and a high-performance ensemble reached 90%, with peak performance occurring around round 6 for the consumer setup and round 5 for the high-performance setup. It also reports thermodynamic-fit explanatory power of $$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$$2 for the mediocre or consumer ensemble and $$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$$3 for the high-performance ensemble, interpreting late-round degradation as predictable entropic fatigue rather than random noise (Pecerskis et al., 23 Jan 2026).

On LiveCodeBench v5 Hard, the paper reports that NSED began around 51.5% and reached about 60.2% pass@1, compared with a majority voting baseline of about 33.1%. The interpretation offered is that intermediate regressions reflected occasional over-refactoring and the lack of compiler feedback, but that the recurrent topology eventually recovered. This is presented as evidence of a self-healing deliberative trajectory.

On DarkBench, the paper reports that NSED reduced some dark-pattern behaviors, especially sycophancy. NSED-R2 is reported at 0.040 sycophancy, described as about a 40% reduction over the best single agent, and also as having the lowest overall RMS score at 0.285. At the same time, the paper explicitly notes that Sneaking did not improve relative to baseline, using this result to argue that topology alone cannot replace domain knowledge (Pecerskis et al., 23 Jan 2026).

6. Scaling claims, limitations, and theoretical positioning

A central claim is hardware arbitrage: ensembles of small, consumer-grade models can match or exceed the performance of state-of-the-art 100B+ parameter models while exchanging only text rather than dense tensors (Pecerskis et al., 23 Jan 2026). The paper contrasts monolithic MoE systems that require very large VRAM and often NVLink/H100-class infrastructure with NSED ensembles that run on isolated consumer-grade GPUs, avoid tensor-parallel interconnect bottlenecks, and can use 8-bit or FP8-style serving. It gives rough claims of 4x to 8x CAPEX reduction, potentially 10x to 20x on older consumer hardware, and performance on RTX 5090-class clusters in the \$\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$47,500 range versus much more expensive enterprise setups.

The scaling argument is that NSED grows through iterative semantic refinement rather than linear increases in model size or VRAM for a single giant model. The paper also claims that prefix caching and KV-cache reuse help amortize latency across rounds. A plausible implication is that the architecture treats text-mediated deliberation as a substitute for interconnect-heavy tensor parallelism in some deployment regimes.

The paper also delineates several limitations. Not all safety dimensions improved; Sneaking remained problematic. Performance depends on sufficiently strong verifiers, and the Condorcet-style condition $\operatorname*{maximize}_{A, T} \quad E(A, T) = \text{Utility}(A, T \mid \mathcal{T}) - \lambda \cdot \text{Cost}(A, T)$5 is identified as important. The broker was not fully dynamic in experiments, often using fixed agent sets rather than solving the full runtime knapsack for every prompt. Text-only deliberation is described as lossy, with future work proposing logit exchange or lattices to preserve richer uncertainty. Latency is nontrivial, and the system is described as trading time for intelligence, potentially taking minutes rather than seconds. The paper also notes that some claims are theoretical or extrapolative rather than fully validated across many deployment regimes (Pecerskis et al., 23 Jan 2026).

Several theoretical analogies are used as conceptual foundations rather than strict proofs: Wald’s Sequential Probability Ratio Test for evidence accumulation, Condorcet’s Jury Theorem for the requirement that verification quality exceed random chance, Carathéodory’s Theorem and Cover’s Theorem to justify heterogeneous ensemble diversity, median voter and herding concerns in voting, and a thermodynamic trade-off between information gain and context entropy. Taken together, these analogies position NSED as a recurrent, self-evaluating, budget-aware ensemble protocol whose novelty lies in combining runtime model selection, peer review, identity-blind quadratic voting, feedback-based state recurrence, and cost-aware stopping within a single inference-time reasoning topology (Pecerskis et al., 23 Jan 2026).