Task-Type Routing for Multi-Agent Debate: When Does Deliberation Add Value?

1. Introduction

The central question this study addresses is deceptively simple: does having multiple language models debate an answer produce better outputs than having a single model reason through the same problem? A growing body of experimental work shows that the answer is neither "always yes" nor "always no." It is "it depends," and the conditions on which it depends are now well enough understood to be operationalized as a classifier.

Multi-agent debate, as formalized by Du et al. (2023), initiates independent responses from multiple LLM agents and then runs iterative rounds of critique and revision until consensus converges.^[1] The intuition draws on ensemble learning: diversity of initial positions, combined with adversarial pressure to defend or revise claims, should push the group toward better-calibrated answers. The empirical record confirms this intuition under specific conditions. Du et al. themselves reported +14.8 percentage points on arithmetic tasks and +8 percentage points on GSM8K benchmarks using debate versus single-model inference.^[1] Liang et al. found +11 percentage points on CIAR (commonsense-infused argument reasoning) tasks.^[2] Wu et al. observed gains of 32 to 52 percentage points on KKS logic puzzles.^[3]

Yet the same literature documents consistent failure modes. Wynn et al. found that debate degrades performance on every tested CommonSenseQA configuration, with losses of up to 12 percentage points on MMLU, driven by a sycophancy correlation of r=0.902 across agent configurations.^[4] Kim et al. demonstrated that all multi-agent system variants produce 39% to 70% degradation on PlanCraft sequential planning tasks.^[5] Zhang et al. showed that homogeneous MAD fails to beat chain-of-thought or self-consistency on 9 of 9 benchmarks.^[6]

These findings are not contradictory: they are diagnostic. The task type, the agent configuration, and the difficulty distribution of queries together predict whether debate will help. For Cabinet, a production multi-agent system, this insight has direct engineering consequence. Routing every query to debate mode is both costly and quality-degrading. Routing no query to debate mode forfeits measurable gains on the tasks where debate genuinely helps. The economically and qualitatively optimal policy is conditional routing: submit the query to debate if and only if the predicted benefit exceeds the cost.

This study synthesizes 60+ primary sources across four research domains to establish the evidential foundations for that routing decision. Section 2 maps the task types where debate helps, with quantitative evidence. Section 3 maps where debate hurts, with failure-mode analysis. Section 4 identifies model heterogeneity as the single most important moderating variable. Section 5 reviews the state of the art in difficulty-aware routing systems. Section 6 covers the query classification methods that enable real-time routing. Section 7 reviews methodology for measuring user preferences in multi-agent experiments. Section 8 presents a complete experimental design for Cabinet to validate and calibrate its own router. Sections 9 through 11 state testable propositions, limitations, and conclusions.

2. The Evidence Landscape: When Debate Helps

2.1 Task-Type Decision Matrix

The evidence converges around a set of structural task properties that predict debate benefit. Verifiability (can the answer be checked objectively?), decomposability (does the problem break into sub-problems amenable to parallel reasoning?), initial answer diversity (do agents start with different answers before deliberation?), and sequential independence (do subtasks lack hard ordering constraints?) together form the primary predictors.

Mathematical reasoning tasks satisfy all four criteria. Arithmetic problems have ground-truth answers; multi-step calculation decomposes naturally; different agents frequently propose different intermediate results, generating productive disagreement; and individual calculation steps are largely independent. This explains the consistent gains reported by Du et al.^[1] and the even larger gains from heterogeneous MAD configurations reported by Zhang et al.^[6]

Commonsense QA tasks satisfy almost none of these criteria. The "correct" answer is often a matter of cultural consensus rather than logical derivation; the problem does not decompose; agents trained on similar corpora tend to produce similar initial answers; and the conversational pressure of debate drives convergence toward confident but incorrect consensus through sycophancy rather than genuine reasoning improvement.^[4]

2.2 Quantitative Evidence Table

3. The Evidence Landscape: When Debate Hurts

3.1 Sycophancy and Commonsense Failure

The most comprehensive study of debate failure modes comes from Wynn et al., who systematically tested MAD configurations across a range of natural language understanding tasks. Their central finding is that debate degrades performance on CommonSenseQA in every tested configuration, with losses reaching 12 percentage points on MMLU benchmarks.^[4] More importantly, they quantified the mechanism: sycophancy (the tendency of agents to revise toward social consensus rather than logical correctness) correlates at r=0.902 with performance degradation across configurations.^[4]

The sycophancy mechanism works as follows: when agents hold heterogeneous initial answers to a commonsense question, the agent holding the minority position is exposed to majority pressure during debate rounds. Because commonsense questions lack objective verification criteria, the minority agent has no logical basis on which to resist that pressure. The result is convergence toward a plurality answer that may be systematically wrong if the plurality position reflects a training corpus bias rather than genuine knowledge.

Yang et al. contribute a related finding: for strong frontier models on MATH500, self-consistency (SC) dominates MAD in both accuracy and cost-efficiency.^[10] This is important because SC is a natural comparison baseline that many early MAD papers omitted. When agents are homogeneous and capable, the diversity of initial samples from a single strong model via temperature sampling is sufficient; additional agents add cost without adding novel perspectives.

3.2 Sequential and Tool-Dense Tasks

Kim et al. provide the most systematic analysis of MAD failure on planning tasks.^[5] Testing on PlanCraft (a sequential planning environment), they found that all multi-agent system variants produced 39% to 70% degradation relative to a single capable agent. The failure mode is structural rather than incidental: sequential planning tasks have hard dependency constraints between subtasks. When multiple agents each reason about the plan from different initial states, their outputs cannot be combined without resolving conflicts that are computationally expensive to adjudicate. The coordination overhead exceeds the reasoning benefit.

The same study identifies tool count (T) as a continuous moderator. For tool-dense tasks where T exceeds 16, the interaction effect reaches beta=-0.330, meaning that each additional tool beyond 16 accelerates performance degradation.^[5] This is consistent with the sequential dependency hypothesis: complex tool chains impose ordering constraints that multi-agent systems cannot efficiently coordinate.

Zhang et al.'s homogeneous MAD study completes the failure picture.^[6] Across 9 benchmarks spanning mathematics, coding, reasoning, and language understanding, homogeneous MAD (multiple instances of the same model) failed to beat chain-of-thought or self-consistency on any benchmark. The conclusion is that agent diversity is not a byproduct of using multiple agents: it must be actively constructed through model selection. Homogeneity combined with debate adds the costs of debate (tokens, latency) without the benefits (diverse initial positions).

4. The Critical Moderator: Model Heterogeneity

The single finding that most reorganizes the literature on multi-agent debate is Zhang et al.'s direct comparison of heterogeneous versus homogeneous MAD.^[6] Heterogeneous MAD (agents drawn from distinct model families, with different pretraining and fine-tuning histories) achieved +29.3% improvement over chain-of-thought on MATH, and produced universal improvement across all 9 tested benchmarks. Homogeneous MAD (multiple instances of a single model) achieved no improvement on any benchmark. This is a clean empirical distinction that changes how the routing problem should be framed.

The fundamental question is not debate versus no debate, but heterogeneous debate versus self-consistency. These are different policies with different cost and quality profiles across every task type.

Proposition P9a, Section 9

The mechanism behind heterogeneous advantage is straightforward. When agents are drawn from different model families (for example, one from the GPT lineage, one from the Claude lineage, one from Gemini), their errors are imperfectly correlated. A calculation error that GPT-4 makes systematically may not be replicated by Claude, and vice versa. Debate rounds surface these divergences and force agents to resolve them with explicit reasoning. When agents are homogeneous, their errors are correlated: they make the same mistakes, debate reinforces the shared error, and the group converges confidently on the wrong answer.

For Cabinet specifically, this finding implies that the debate mode must be implemented as heterogeneous by design. If Cabinet's debate pipeline uses multiple calls to the same underlying model (or models from the same provider with similar training), the debate costs are incurred without the diversity benefits. The router should therefore track not just whether to route to debate, but whether the current agent pool satisfies a minimum heterogeneity threshold.

5. Difficulty-Aware Routing: State of the Art

5.1 Routing Systems

The routing problem (assigning a query to an inference mode based on estimated difficulty and task type) has generated a substantial engineering literature independent of the debate literature. The most relevant systems share a common architecture: a lightweight router that inspects incoming queries and directs them to cheap-but-sufficient or expensive-but-capable inference pipelines.

DAAO (Difficulty-Adaptive Agent Orchestration) achieves 83.26% average accuracy at an average cost of $2.61 per task, compared to $24.16 for AFlow (a non-adaptive alternative).^[13] DAAO's difficulty estimator is a variational autoencoder (VAE) that embeds query features into a latent difficulty score, then uses that score to select among a portfolio of agent configurations calibrated for different difficulty levels. The VAE-based difficulty estimator outperforms surface feature heuristics by better capturing semantic complexity that correlates with agent failure modes.^[13]

RouteLLM, developed at LMSYS, approaches the routing problem as a classification task: given a query, predict whether a strong (expensive) model or a weak (cheap) model will produce a satisfactory response.^[14] Their best-performing router, based on matrix factorization of historical query-model interaction data, achieves 73% reduction in GPT-4 calls while maintaining competitive response quality, at a routing throughput of 155 requests per second.^[14]

HybridLLM uses a DeBERTa-based classifier for routing and achieves a 36ms routing latency, a 40% reduction in compute cost, and less than 0.2% quality degradation on evaluation benchmarks.^[15] The DeBERTa architecture is well-suited for routing because it produces rich contextual embeddings with moderate inference cost and has strong transfer learning properties from its pretraining on natural language inference tasks.

A distinct line of work exploits hidden model states for difficulty estimation without adding routing tokens. Zhu et al. demonstrate zero-token difficulty estimation from residual stream activations, achieving competitive difficulty prediction with no prompt overhead.^[16] Lugoloobi et al. apply linear probes trained on hidden states to route MATH queries, achieving 70% cost reduction over always-strong-model with less than 2% quality loss.^[17] These hidden-state methods are particularly relevant for production systems where every additional token represents real cost.

A key architectural decision in routing systems is the choice between pure routing (assign to one pipeline at submission time) and cascade routing (try the cheap pipeline first, then escalate on verified failure). Gao et al.'s meta-analysis of MAS cost efficiency shows that when verification is available (as in code execution or formal proof checking), cascade consistently outperforms pure routing because the cheap pipeline succeeds on easy queries and the escalation overhead is only incurred when it is genuinely needed.^[12]

5.2 Token Cost Analysis

Gao et al. (2025) provide the most systematic token cost analysis of multi-agent systems relative to single-agent inference.^[12] Across a range of tasks and configurations, MAS-to-SAS token ratios range from 3x to 220x, with the high end occurring in iterative debate setups on long documents where each debate round recirculates the full context.

The Gao et al. analysis also highlights a temporal trend relevant to Cabinet's long-term router policy: as frontier single models improve, the quality delta from MAS decreases while the token cost ratio remains roughly constant.^[12] This means the economic threshold for routing to debate should become more stringent over time, and the router calibration should be updated periodically to account for model capability improvements.

6. Query Classification for Debate Routing

6.1 Feature Taxonomy by Extraction Cost

A practical routing classifier must balance predictive power against extraction cost. Features that require running a large model to compute are too expensive for real-time routing. The following taxonomy organizes features by their extraction cost tier.

Linguistic complexity markers provide cost-free signals that correlate with task difficulty and debate benefit. Contrast markers (but, however, although, despite) are associated with argument structure tasks that are typically commonsense-heavy: their presence correlates with 5 to 9 percentage-point reductions in debate benefit.^[19] Knowledge-seeking verbs (prove, derive, calculate, demonstrate, verify) correlate with 4 to 10 percentage-point increases in debate benefit, reflecting the verifiability property.^[19]

LLMRank, a feature engineering framework for LLM routing, demonstrates that a carefully chosen set of surface and embedding features captures 89.2% of the oracle utility (the utility achievable with a perfect difficulty classifier).^[20] This is relevant because it establishes a practical ceiling: even with access to Tier 3 and Tier 4 features, the marginal gain over a well-engineered Tier 1/2 classifier is bounded. The practical implication for Cabinet is to invest in Tier 1 and Tier 2 feature engineering before committing to Tier 3 model training.

6.2 Classifier Architectures

Several specialized architectures have been proposed for the routing classification problem. IRT-Router applies Multidimensional Item Response Theory (MIRT) to model the interaction between query difficulty (treated as an item parameter) and model capability (treated as an ability parameter).^[18] On standardized benchmarks, IRT-Router achieves performance 3% above GPT-4o at 1/30th the inference cost, demonstrating that the difficulty estimation problem is amenable to classical psychometric models when sufficient historical performance data is available.^[18]

ProbeDirichlet uses hidden-state probes combined with a Dirichlet process mixture model to produce calibrated uncertainty estimates over routing decisions.^[21] The hidden-state approach achieves +16.68% AUROC improvement over text-based classifiers, reflecting the information advantage of operating on model internals rather than surface text features.^[21] The practical constraint is that hidden-state access requires white-box access to the underlying model, which is not available for proprietary APIs.

7. User Study Methodology for Preference Measurement

Evaluating whether users prefer debate-generated responses requires careful methodological design. Automated metrics (accuracy, F1, BLEU) are useful for objective tasks but miss the user experience dimension of open-ended and creative tasks. Several methodological frameworks are relevant to Cabinet's evaluation needs.

The Chatbot Arena paradigm uses Bradley-Terry (BT) models to derive stable preference rankings from pairwise comparisons.^[22] Chiang et al. demonstrate that approximately 4,400 adaptive votes are required to achieve precision of 0.2 in BT model estimation, where adaptive means votes are concentrated on confusable pairs.^[22] For Cabinet's controlled study (Phase A), this translates to a requirement for N=200 within-subjects pairs when effect size d_z=0.20 and power=0.80, sufficient for task-category-stratified estimates.^[23] A between-subjects design at d=0.20 would require N=392 participants per arm, motivating the within-subjects approach.^[23]

Behavioral proxies offer scalable preference signals for Phase B production A/B testing. Pang et al. find that response length produced by the user in follow-up turns achieves accuracy=0.761 as a preference predictor and correlates with +12% win rate for preferred responses.^[24] Mean Conversation Length (MCL) provides a session-level proxy: Irvine et al. show that a +70% increase in MCL corresponds to a +30% increase in 30-day retention.^[25] These behavioral metrics do not require explicit preference judgments and can be tracked passively at scale.

SPUR (Stated Preference for Uncertainty Representation), applied on Bing Copilot, achieves F1=75.4 in predicting user preferences from response characteristics, demonstrating that stated preference surveys can achieve high predictive validity in production settings.^[26]

Clarke et al. establish a crucial finding about user attitudes toward multi-agent orchestration transparency.^[27] Users who are informed about the orchestration process (knowing that multiple agents deliberated before producing a response) show significantly higher satisfaction than users who are not informed (SUS 86 vs. 56, p<0.01).^[27] This suggests that Cabinet should expose the debate process to users, framing it as a quality guarantee rather than hiding the infrastructure complexity.

WildBench, a human preference benchmark based on 1,024 naturally collected user queries, provides the strongest correlation with Chatbot Arena Elo scores (Pearson r=0.984).^[28] This makes WildBench the preferred task taxonomy for stratifying Cabinet's evaluation sample, as it ensures that evaluation results on the study tasks generalize to real user query distributions.

8. Experimental Design for Cabinet

This section presents a complete, implementation-ready experimental design for Cabinet to validate task-type routing in production and train a calibrated routing classifier.

8.1 Research Questions

RQ1: For which WildBench task categories does Cabinet's debate mode produce pairwise win rates significantly above 0.50 when compared against single-model inference, controlling for query difficulty?

RQ2: Can a lightweight DeBERTa-v3-base classifier trained on 10,000 labeled examples from the A/B test predict debate benefit at query submission time with AUROC >0.70 and routing latency below 50ms?

RQ3: Does difficulty-adaptive routing (using the trained classifier) reduce total inference cost by more than 40% while maintaining aggregate preference scores within 2% of an always-debate policy?

8.2 Independent Variables

System Configuration (3 levels): (1) Single-model baseline (Cabinet in single-agent mode, chain-of-thought enabled); (2) Cabinet debate mode (heterogeneous multi-agent deliberation, 3 agents, 2 debate rounds); (3) Difficulty-adaptive routed mode (the trained classifier routes each query to either single or debate mode).

Task Type (5 levels, WildBench taxonomy): Information Seeking; Math and Data Analysis; Reasoning and Planning; Creative Tasks; Coding and Debugging.

Query Difficulty (3 levels): Low (rated 1 to 2 by LLM judge consensus); Medium (rated 3); Hard (rated 4 to 5). Two or more LLM judges must agree on the difficulty rating for inclusion.

8.3 Dependent Variables

Primary: Pairwise Preference. 5-point scale (A clearly better / A slightly better / About equal / B slightly better / B clearly better), modeled via Bradley-Terry with participant random effects. This scale allows soft preference signals while remaining compatible with the BT framework.^[22]

Secondary: Decision Confidence. 7-point Likert scale (1=extremely uncertain, 7=extremely confident). This captures whether debate mode increases user confidence in the correctness of responses, independent of accuracy.

Secondary: Trust in Response. 5-point Likert (1=not at all trustworthy, 5=completely trustworthy). Informed by Clarke et al.'s finding that orchestration transparency significantly modulates trust.^[27]

Behavioral (Phase B only): Session continuation (binary: user sends at least one follow-up message); next-response length (word count of user's next message, as per Pang et al.); regeneration rate (fraction of responses regenerated by the user); Mean Conversation Length (MCL, total turns per session).^[24][25]

8.4 Sample Size

Phase A (Controlled Study): N=200 within-subjects pairs (d_z=0.20, two-tailed alpha=0.05, power=0.80). Each participant evaluates 10 randomly assigned query pairs, balanced across task types. This yields 200 pairs total, sufficient for Bradley-Terry estimation with 15 primary comparisons after Holm-Bonferroni correction.^[23]

Phase B (Production A/B Test): N=10,000 users per arm (3 arms: baseline, debate, adaptive). Power analysis for behavioral metrics assumes medium effect size (Cohen's d=0.30) with alpha=0.05. 10,000 per arm provides power >0.99 for primary behavioral outcomes. Phase B also serves as the training data source for the Phase C classifier.

Phase C (Router Training): 10,000 labeled query-outcome pairs, where the outcome label is "debate significantly preferred" (win rate >0.60 in Phase B). The label will be derived from the Bradley-Terry estimates obtained from Phase B pairwise comparisons. DeBERTa-v3-base will be fine-tuned on these labels with 80/10/10 train/validation/test split.

8.5 Statistical Analysis Plan

The primary analysis applies the Bradley-Terry model to the pairwise preference data, with stratified estimation per task type and difficulty level. The BT model produces a log-odds of debate preference for each stratum, with 95% confidence intervals. A stratum is classified as "debate helps" if the lower bound of the confidence interval for the win rate exceeds 0.50.^[22]

Multiple comparisons are handled with Holm-Bonferroni correction across the 15 primary comparisons (3 system configurations x 5 task types).^[30]

Router performance evaluation uses four metrics: AUROC (area under the ROC curve, target >0.70); CPT(50%) (cost at which 50% of oracle quality is preserved); CPT(80%) (cost at which 80% of oracle quality is preserved); and APGR (average pairwise gain ratio, the ratio of quality gain to cost increase for routed vs. single-model).^[14]

Cost analysis computes per-task token ratios for each (task type, difficulty) cell, then aggregates using the empirical query distribution from Phase B. The router's cost reduction is expressed as the percentage reduction in expected tokens per query under the routed policy versus the always-debate policy.

8.6 Router Architecture

The proposed Cabinet router uses a three-tier architecture that balances latency and predictive power.

Tier 1 (Regex, <1ms): Surface feature extraction. Binary flags for: mathematical operators present, length >100 tokens, sequential planning keywords (schedule, plan, step-by-step, order of), commonsense markers (normally, usually, most people, common sense), tool-invocation keywords. If Tier 1 features produce a high-confidence routing decision (probability >0.90), route immediately. This handles the clear cases (very simple factual queries, explicit math problems) without incurring encoder cost.

Tier 2 (DeBERTa-v3-base, ~36ms): Full contextual classification. Input: query text, truncated to 512 tokens. Output: probability vector over (route to single, route to debate). This tier is invoked for all queries not handled by Tier 1. The DeBERTa classifier is trained on Phase C labels from Phase B outcomes, following the HybridLLM architecture.^[15]

Tier 3 (Cascade fallback): For tasks with objective verification criteria (code: unit test execution; math: symbolic verification), route to single-agent first, then escalate to debate if the single-agent response fails verification. This cascade mechanism reduces debate overhead for easy instances while preserving quality on hard instances.^[12]

8.7 Task Selection Protocol

The Phase A evaluation task pool is drawn from WildBench 1,024 naturally collected user queries.^[28] Tasks are stratified into the 5-group WildBench taxonomy. Difficulty ratings are obtained from two independent LLM judges (one frontier model, one mid-tier model); queries where the judges disagree by more than 1 point are resolved by a third judge or excluded. Queries rated 1 to 2 on both judges are excluded from Phase A (insufficient difficulty for debate to matter), retaining only medium-to-hard queries. The final Phase A task pool requires at least 40 queries per cell across 15 cells (5 task types x 3 difficulty levels), for a minimum pool size of 600 tasks.

8.8 Experimental Pipeline

9. Testable Propositions

The following propositions are derived from the literature synthesis and are designed to be empirically falsifiable using the experimental design in Section 8. Each proposition is stated with sufficient precision to permit a binary verdict from the experimental data.

10. Limitations

This study synthesizes a large literature and proposes an experimental design based on that synthesis. Several substantive limitations bear on the confidence one should place in the conclusions.

Publication bias. The literature on multi-agent debate is subject to strong positive-result bias: studies finding that debate helps a given task are more likely to be published and cited than studies finding null or negative results. The evidence table in Section 2 incorporates known negative-result studies (Wynn et al., Zhang et al., Kim et al.), but there is likely a larger set of unreported failures that would shift the prior toward debate being less beneficial than the published literature suggests.^[31]

Baseline adequacy. Several foundational MAD papers lack chain-of-thought or self-consistency baselines. Du et al. (2023) compared debate against plain single-model inference without chain-of-thought, which substantially inflates the apparent debate advantage.^[1] Liang et al. (2023) similarly used weak baselines.^[2] When reanalyzed against CoT/SC baselines (as in Yang et al.), the debate advantage is substantially reduced for capable models.^[10]

Ecological validity. The benchmarks used in the literature (GSM8K, MMLU, MATH, HumanEval) are structurally different from production user queries. Benchmark tasks are typically shorter, more precisely specified, and have cleaner ground truth than the conversational queries Cabinet serves. The WildBench-based experimental design in Section 8 partially addresses this concern, but the external validity of routing classifiers trained on WildBench to Cabinet's proprietary query distribution remains uncertain.^[28]

The shrinking MAS advantage. Gao et al. (2025) document a secular trend: as frontier single models improve (GPT-4 to GPT-4o to frontier-class models), the performance gap that multi-agent systems exploit narrows.^[12] The literature evidence for debate benefit is largely based on models that are 1 to 3 generations behind the current frontier. For Cabinet running on the current generation of models, the absolute benefit of debate may be smaller than the literature suggests, even for tasks where debate structurally helps.

Sample size constraints. Many MAD studies test only 100 to 200 samples per task, which is insufficient to detect small effect sizes with adequate power or to produce stable estimates for task-by-difficulty interaction effects. Effect size heterogeneity across studies is high, and the confidence intervals around individual study estimates are wide.^[32]

No published debate-routing system. No published system explicitly trains a classifier for the debate-versus-no-debate routing decision specifically (as opposed to strong-versus-weak model routing). The AUROC and cost-reduction projections in Section 8 are extrapolated from related routing systems (HybridLLM, RouteLLM) and may not transfer to the debate routing problem, which has different label structure and feature relevance.^[14][15]

Human versus model difficulty. Lugoloobi et al. (2026) demonstrate that human-rated query difficulty and model-rated query difficulty diverge substantially, particularly for tasks where human cultural knowledge reduces perceived difficulty without reducing model difficulty.^[17] The Cabinet experimental design uses LLM judges for difficulty estimation, which may not align with the difficulty dimension that predicts debate benefit.

Distribution shift. Query distributions change over time as user populations change and as users adapt their prompting behavior to the system's capabilities. A routing classifier trained on one time period may degrade in AUROC as the query distribution shifts. The experimental design does not include a planned monitoring or retraining protocol, which should be added to a production implementation.

11. Conclusion

The literature on multi-agent debate, when viewed through the lens of task-type routing, yields a coherent and actionable picture. Multi-agent debate is not universally beneficial; it is conditionally beneficial. The conditions are well enough characterized to support a production routing system with reasonable confidence.

The four critical moderators are: task verifiability (does an external criterion exist to adjudicate between competing answers?), model heterogeneity (are the agents drawn from distinct model families with imperfectly correlated errors?), sequential dependency (do subtasks impose hard ordering constraints that coordination cannot satisfy?), and query difficulty (does the task expose the knowledge boundary of individual agents?). When verifiability is high, heterogeneity is high, sequential dependency is low, and difficulty is medium to hard, debate reliably improves over single-agent inference. When any of these conditions fails, debate either fails to improve or actively degrades performance.

The heterogeneity finding from Zhang et al. is the most important single result for Cabinet's architecture.^[6] Homogeneous debate adds cost without adding quality. If Cabinet's debate pipeline does not actively ensure agent diversity, routing to debate is strictly dominated by routing to self-consistency. Heterogeneous debate, by contrast, achieves +29.3% on MATH and universal improvement across all 9 benchmarks tested, justifying the inference overhead for appropriate task types.^[6]

The routing literature establishes that classifier-based routing is technically feasible: HybridLLM achieves 40% cost reduction with under 0.2% quality degradation at 36ms latency,^[15] RouteLLM achieves 73% reduction in expensive model calls at 155 requests per second,^[14] and IRT-Router achieves 3% above GPT-4o at 1/30th the cost.^[18] These are existence proofs that the routing objective is achievable; Cabinet's contribution is to apply the routing decision specifically to the debate-versus-single-agent choice, which has a richer feature set and a more interpretable label structure than general strong/weak model routing.

The experimental design in Section 8 provides Cabinet with a three-phase validation path: a controlled user study to establish ground truth on debate benefit by task type and difficulty; a production A/B test to collect the training data for the router; and a classifier training pipeline targeting AUROC >0.70 with under 50ms routing latency. The projected outcome, consistent with the literature, is a 40%+ reduction in inference cost while maintaining preference scores within 2% of an always-debate policy.

This is the foundational architecture for Cabinet's adaptive inference layer. The experimental design is not merely an academic validation exercise: it is the production pipeline that transforms the literature's conditional findings into an operational routing policy calibrated to Cabinet's specific agent configurations, query distribution, and user population.