FYDP Proposal · Idea 1 of 1 · Rank #1 · P0 gate 13/13
Project Idea

The Boundaries of Evidence-Grounded Trust in Multi-Agent Scientific Debate, with a Controlled Benchmark for Sycophantic Consensus

Domain: Agentic AI · LLM Reasoning · Multi-Agent Systems · Trust Calibration · P0 status, no efficacy results yet

Target VenueTACL (rolling) · EMNLP 2028 fallback
P0 Gate13 / 13 passed
P0 Tests514
Project Report70-pp report · 19-pp journal · 0 undefined refs
Core Matrix24 runs · 1,280 GPU-h

At a Glance

514
P0 Tests Passing
13/13
P0 Gate Passed
24
Core Runs
300
Benchmark Target (180 floor)
3
Agent Roles in Pipeline

1. Core Idea

📌 P0 implementation status (Nov 2026)

615 tests; P0 gate 13/13 passed and released (tags p0-gate, p0-release). The core is wired: options in prompts, parser/scorer, trust simplex projection, verifier interface, claim-domain routing, endpoints, and manifest/resume. Current report evidence: 70-pp report, 19-pp journal, 0 undefined references. This is engineering readiness, not an efficacy result. Everything below is planned work unless it is explicitly dated as done.

We propose a trust-calibrated multi-agent scientific deliberation framework to mitigate sycophantic consensus collapse in LLM reasoning. Agents whose claims are verified by retrieved scientific literature accumulate higher trust weights, preventing hallucinating majorities from suppressing correct minority agents.

🎯 Positioning & Contributions

Recent work has diagnosed and measured inter-agent sycophancy (Yao et al., 2025) and the correct-minority-suppression effect (He et al., 2026). Our contribution is the missing mitigation side: an in-session, evidence-grounded mechanism, plus an open evaluation harness.

  • C1 — Trust-Calibrated Evidence-Grounded Aggregation (primary). A bounded, dynamic, evidence-weighted trust rule that re-weights agents during the debate.
  • C2 — Open Sycophancy-Stress Evaluation Harness (co-primary). A pre-registered injection protocol + CCR / MPR / ECR metrics, a 4-arm executable matrix with a 6-arm target, three Core datasets (GPQA, MMLU-Pro, HLE), and an SciClaimBench benchmark at 180 floor / 300 target.
  • C3 — Supporting: Progressive, source-partitioned retrieval for atomic-claim verification.

0. Research Design Decisions & Assumptions

Why this problem

Multi-agent debate (MAD) improves LLM reasoning but has a documented failure mode: agents abandon correct answers under social pressure from a confident wrong majority. This is the single biggest reason MAD's gains don't always materialize, especially in scientific QA where a confidently wrong consensus is worse than an honest "uncertain."

Why it matters

As LLMs get deployed as research assistants and decision-support tools, false consensus among cooperating AI agents is a trust and safety problem — it fails silently and confidently.

🕳️ Verified Research Gap

No existing framework provides numeric, evidence-grounded, in-session trust re-weighting with formal boundedness guarantees. Diagnosis exists (Yao et al. 2025), efficiency optimisation exists (iMAD, AAAI 2026), static aggregation exists (MoA, ICLR 2025 Poster), and recent mitigation attempts use prompt refinement (ConsensAgent, Findings of ACL 2025), uncertainty signals (DebUnc, Findings of EMNLP 2025), or theoretical pruning interventions (Estornell & Liu, NeurIPS 2024 Main Track) — but nothing ties an agent's influence toreal-time, externally verified evidence with a formally bounded numeric trust score.

Why Multi-Agent Over Single LLM?

A single strong model still hallucinates confidently and has no internal mechanism to be challenged. Multi-agent debate introduces adversarial critique — but only if aggregation doesn't default to majority vote, which is precisely the mechanism causing sycophantic collapse. This motivates heterogeneous, independently evidence-checked agents, not multiple instances of the same model.

Core Research Assumptions

1🟡 Moderate Risk
Claim Decomposition

Claims during debate can be decomposed into checkable atomic propositions.

Some claims are compound or context-dependent.

2🟡 Moderate Risk
Retrieval Reliability

PubMed/ArXiv/Semantic Scholar retrieval can support/contradict claims within the debate time budget.

Retrieval noise, sparse coverage on niche topics.

3🔴 Critical Risk
Behavioral Effectiveness

Trust weight changes actually alter final output, not just sit in context ignored.

The whole mechanism lives or dies on this — must be piloted in Dec 2026, before the matrix.

4🟢 Low Risk
Heterogeneity Benefit

Different model families reduce, but don't eliminate, correlated hallucination.

Accepted as a named limitation.

5🟡 Moderate Risk
Competitor Differentiation

Our method must measurably outperform ConsensAgent's prompt-refinement approach, not just iMAD/MoA.

ConsensAgent (ACL Findings 2025) is the closest published mitigation — a written comparison paragraph is mandatory; full baseline reimplementation if Full-run capacity allows.

Alternatives Considered & Rejected

✗ Post-hoc Classifier (Minority Sentinel-style)

Intervenes after debate ends, not during. Valid but separate contribution space — we position against it, not duplicate it.

✗ Fine-tuning Agents

Rejected due to compute cost and lack of cross-model generalization. Also conflates "sycophancy reduction" with "evidence grounding" — different mechanisms.

✗ Confidence-Based Re-weighting (iMAD-style)

Confidence is self-reported from the same context that can be manipulated by injected pressure — exactly the vulnerability we target.

✓ Our Approach

Ties agent influence to something external and independent of debate social dynamics — the lever needed to break sycophantic collapse, not just detect it.

2. Research Motivation

Why this problem matters

Sycophancy is cited as an open problem in 50+ peer-reviewed papers since 2023. In multi-agent systems, it undermines the reason multi-agent debate is used — if debate collapses to whichever position sounds most confident rather than which is most correct, it adds cost without adding reliability.

The specific gap

No existing framework provides numeric, evidence-grounded, in-session trust re-weighting. Prompt refinement (ConsensAgent, ACL Findings 2025), uncertainty signals (DebUnc, EMNLP Findings 2025), and theoretical pruning interventions (Estornell & Liu, NeurIPS 2024) all address related problems — but none ties agent influence to real-time external evidence verification with a formally bounded trust score. This is the exact, verified gap.

Existing limitations (verified against literature)

WorkYearWhat it doesWhat's missing
Yao et al. (Peacemaker)2025Diagnoses & measures inter-agent sycophancyNo mitigation — diagnostic only
He et al. (Minority Sentinel)2026Post-hoc classifier on debate logsIntervenes after debate ends, not during
iMAD (Fan et al.)2026Decides when to debate (efficiency)Doesn't decide whom to trust once debating
MoA (Wang et al.)2025Static multi-model aggregationNo evidence grounding or dynamic trust
ConsensAgent (Pitre et al.)2025Prompt-refinement sycophancy mitigationStatic/textual intervention — not numeric trust; no external evidence retrieval
DebUnc (Yoffe et al.)2025Uncertainty-based in-loop weightingSelf-reported uncertainty signals — not grounded in external evidence verification
Estornell & Liu2024Theoretical framework for majority convergenceTheoretical only — proposes pruning interventions, not a deployable system

3. Problem Statement

Research hypothesis: If agent influence in aggregation is dynamically re-weighted during debate based on external evidence verification, sycophantic collapse will measurably decrease compared to standard majority-vote debate, without requiring model fine-tuning.

Four Engineering Challenges (Washington Accord Level)

Challenge A — Real-time Verification

Decompose claims into atomic propositions; retrieve supporting/contradicting evidence within <10 s per turn.

Challenge B — Trust Stability

Design update rule avoiding degenerate equilibria (full collapse or single-agent dominance).

Challenge C — Behavioral Effectiveness

Ensure trust weights change model outputs, not merely appear in context and get ignored by attention. Highest risk.

Challenge D — Heterogeneous Agents

Trust calibration must be model-agnostic across ~14–32B open-weight models from different families.

4. Complete System Architecture

The system processes each query through a confidence gate, then either returns a direct answer or triggers the full evidence-grounded debate pipeline shown below. Tap any stage to read what it does in plain English.

Scroll to explore · tap any stage for a plain-English explanation
uncertain
K=3 rounds
confident path
joins output
⚡Over-triggering (confident queries entering debate) wastes compute but poses no correctness risk.

4.1 Confidence Estimator

Lightweight single-pass check using self-reported confidence or 3-sample agreement. Avoids full debate cost on easy questions. Failure mode: over-triggering (wastes compute, no correctness risk).

4.2 Agent Pool (N=3)

Qwen3.8-27B-AWQ-INT4, Gemma 4 26B A4B, Mistral Small 3.2 24B — three different families for genuine heterogeneity. Each tracks own trust vector T ∈ ℝ³, initialized uniformly at 1/N.

4.3 Source-Partitioned RAG

Claims → atomic propositions → Agent A→PubMed, B→ArXiv, C→Semantic Scholar. Prevents all agents retrieving from same narrow slice. Cross-encoder reranker scores evidence per claim.

4.4 Trust Update (Core)

Sᵢ ← log(max(Sᵢ, ε)) + α·Vᵢ/nᵢ − β·Hᵢ/nᵢ, then one softmax, then a floor/ceiling simplex projection. Vᵢ and Hᵢ are supported/contradicted counts, normalised by claims checked (nᵢ). Defaults α = 0.5, β = 0.3. Guarantees: min ≥ 0.1, Σ = 1, max ≤ max(0.9, 1/N). Neutral evidence is an identity.

4.5 Revision Rounds (K=3)

Agents see peer arguments + own trust standing. Simulates genuine deliberation. Trust trajectory logged across rounds for ECR analysis.

4.6 Trust-Weighted Adjudication

Final answer = argmax over Σ(Tᵢ × positionᵢ) at round K — not majority vote. Correct minority with high trust can outweigh two unsupported majority agents.

Try the Trust Update Yourself (§4.4)

Trust-Update Simulator
Blueprint §4.4 · log-prior → one softmax → floor/ceiling simplex projection

Scenario: Two agents (A, B) argue answer X; one minority agent (C) argues answer Y. Drag the evidence sliders and watch whether the evidence-weighted vote can rescue the correct minority — something a headcount never could.

logitᵢ = log Sᵢ + α·Vᵢ − β·Hᵢ → softmax → Π[0.1, 0.9]
Projectionfloor 0.10 inactiveceiling 0.90 inactivebounds already satisfied — identity
Vᵢ and Hᵢ are per-claim rates; dividing by claim count keeps verbose agents from buying influence.
Agent A
Qwen3.8-27B
Answer X
Final Trust Tᵢ24.4%
softmax 24.4% → simplex 24.4%
Agent B
Gemma 4 26B
Answer X
Final Trust Tᵢ23.4%
softmax 23.4% → simplex 23.4%
Agent C
Mistral Small 3.2
Answer Y
Final Trust Tᵢ52.2%
softmax 52.2% → simplex 52.2%
Plain Majority Vote
Headcount → X: 2 vs Y: 1
Picks X (the unsupported answer)
Trust-Weighted Vote (Ours)
Σ(Tᵢ × posᵢ) → X: 48% vs Y: 52%
Picks Y (the evidence-backed minority)
✅ The mechanism just worked. Majority vote would lock in X, but evidence-weighted trust rescues the correct minority answer Y. This divergence is exactly the sycophantic-collapse case the whole system exists to prevent.

5. Detailed Multi-Agent Pipeline

Agent 0 — Confidence Estimator (Gatekeeper)

PropertyDetail
PurposeAvoid full debate cost on easy questions (all agents agree correctly)
Input → OutputRaw question → binary gate (debate / no-debate) + direct answer if no-debate
Prompt strategySimple CoT + explicit confidence self-report, or 3-sample agreement check
Failure modeMis-classifies hard as easy → answered without debate (acceptable — eval datasets are pre-filtered to divergent cases)
RecoveryNone needed — failure is cost inefficiency, not a correctness bug
If removedDebate runs on every question. No correctness impact, only ~9 vs ~1 forward passes on easy questions

Agents 1–3 — Debate Agents (Two-Phase Strategy)

Dev: Qwen3.5-9B → Final: Qwen3.8-27B-AWQ-INT4

Dev: cheap iterative testing on RTX A6000 48GB. Final: 27B dense, 262K context, caps prior 397B MoE flagship in coding. Apache 2.0.

Dev: Gemma 4 12B → Final: Gemma 4 26B A4B

Dev: encoder-free 12B proxy. Final: MoE (3.8B active), 256K context, matches 31B quality at fraction of compute.

Dev: Ministral-3-14B-Instruct → Final: Mistral Small 3.2 24B

Dev: Mistral-family 14B, served as AWQ 4-bit (~8GB) — the official FP8 checkpoint cannot run on Ampere, so the same model is used in 4-bit AWQ. Final: Mistral adds third distinct family (non-Qwen, non-Gemma) for true heterogeneity.

Recovery Mechanisms

Unparseable output → fallback LLM extraction. Timeout → retry once then mark INCONCLUSIVE for that round. Never blocks the whole debate.

Retrieval Sub-System & Orchestrator

Retrieval

Source-partitioned: Agent A→PubMed, B→ArXiv, C→Semantic Scholar. Cross-encoder reranks passages. Per-claim verdict: supported / contradicted / unverifiable. If removed → system reduces to MoA (baseline B6).

Orchestrator

LangGraph state machine manages round sequencing, injection point (t=1→2), trust updates, final aggregation. Hard round cap (K=3) and retry cap (3) prevent runaway loops.

6. Complete Data Flow

End-to-end data flow from question submission to final output. Every intermediate result is logged for traceability, ECR calibration, and verification of Propositions 2–3.

Walk the Real Example, One Step at a Time

1 · Question In
A hard science question enters the system with no answer yet.
“Does Drug X lower blood pressure in adults over 60?”

The ground-truth answer is kept hidden from the agents — it is only used later by the evaluation harness.

Step 1 of 9
01
Question Input

Raw question string + ground truth (hidden from agents). Submitted by user or eval harness.

02
Confidence Gate

Debate=True/False decision. If False → skip to step 08 with direct answer.

03
Round 0 — Positions

3× {agent_id, answer, reasoning_trace, initial_trust=⅓}. Agents state independent positions.

04
Claim Decomposition

3× list of atomic claims, each tagged to its source agent. Ready for verification.

05
Source-Partitioned Retrieval

Per-claim {evidence_verdict, passage, relevance_score}. First external signal enters the system.

06
Trust Update (R1)

Updated Sᵢ, Tᵢ per agent. [Optional: Injection point for fabricated wrong consensus].

07
Revision Rounds ×K

Repeat steps 03–06 for K=3. Full trust trajectory across rounds — required for Propositions 2–3.

08
Trust-Weighted Agg.

Final answer = argmax over Σ(Tᵢ × positionᵢ) at round K. NOT majority vote.

09
Result Package

Answer + evidence citations + trust trajectory + per-agent reasoning traces.

Note: Every intermediate output is logged — trust trajectory (step 07) is required for Propositions 2–3; per-claim evidence verdicts (step 05) are required for ECR calibration.

7. Models & Tools

Full model stack per blueprint §7. All open-weight, inference-only, served via vLLM.

Agent 1 (Dev)
Small, fast dev iteration on RTX A6000 48GB — served as 4-bit AWQ
Agent 1 (Final)
Full-scale 27B dense, served AWQ-INT4 4-bit (~21.0 GB) on the 80 GB A100 main stack; FP8 checkpoint (~29.95 GB) only for the 96 GB precision check
Agent 2 (Dev)
Encoder-free 12B, good proxy for 26B behaviour — served as QAT 4-bit
Agent 2 (Final)
MoE (3.8B active), served AWQ 4-bit (~17.2 GB) on the 80 GB A100 main stack; FP8 checkpoint (28.67 GB) only for the 96 GB precision check
Agent 3 (Dev)
Mistral-family 14B — AWQ 4-bit on the A6000 (the official FP8 checkpoint cannot be served on Ampere)
Agent 3 (Final)
Third training lineage, AWQ 4-bit (15.06 GB) — main-matrix agent on the 80 GB A100
4-bit main stack (pinned)
~53.3 GB
Qwen3.8-27B-AWQ-INT4 (~21.0 GB) · Gemma 4 26B-A4B AWQ (~17.2 GB) · Mistral 24B AWQ (15.06 GB) — Core and Full causal matrix on one 80 GB A100
FP8 check stack (pinned)
73.68 GB
Qwen3.8-27B-FP8 (29.95 GB) · Gemma-4-26B-A4B-FP8 (28.67 GB) · Mistral-24B-AWQ (15.06 GB) — N1 96 GB smoke + small GPQA precision replication, not the main matrix
Oracle (B7)
GPT-6 Luna (OpenAI)
Optional external-answer ceiling; 3 samples/question; mean single-call accuracy + 3-sample majority; ~$3–9 per 1,000; not a Core arm
Reranker
ms-marco-MiniLM cross-encoder
Standard, fast, well-validated
Inference
vLLM
Free, fast, multi-model serving
Orchestration
LangGraph
State-machine fits round-based debate
Retrieval APIs
PubMed, ArXiv, Semantic Scholar
Free academic API access

GPU & Storage Budget

Two-phase strategy: develop on an RTX A6000 48GB with the smaller models, then run the main causal matrix on one 80 GB A100 ($0.136/GPU-h) with the 24–27B stack served 4-bit (Qwen3.8-27B-AWQ-INT4 ~21.0 GB / Gemma-4-26B-A4B AWQ ~17.2 GB / Mistral-24B-AWQ 15.06 GB; ~53.3 GB total). The pinned 73.68 GB FP8 stack (Qwen3.8-27B-FP8 29.95 GB / Gemma FP8 28.67 GB / Mistral AWQ 15.06 GB) on a 96 GB card is only for the N1 smoke and a small GPQA precision replication, not the main Full matrix. The plan totals $500–600 with a $600 hard stop; if no 80 GB A100 is available, the $1,050–1,150 fallback requires re-approval and is not the default. The offline check passes, but the hardware smoke has not been run. Use the table below to review the budget.

Publication-Stage Budget

Vast.ai spot · all-in estimate
StageScopeWhenGPU hoursAll-in cost
N1 smoke + FP8 check96 GB FP8 stack at $0.336/GPU-h: N1 hardware smoke + small GPQA precision replicationNov 202660–100$25–40
Pilot24-item calibration · 50-question Month-1 pilot · 100–150-question G2 pilotDec 2026~112$15–20
Core4 arms (B3, B4-matched, B8-no-trust, B8) · GPQA 400 / MMLU-Pro 400 / HLE 200 · 2 seeds = 24 runsJan 20271,280 cap$175–210
Full32 rows · gold-evidence oracle on SciClaimBench · 36-row gold-answer alternate · 300 items/datasetFeb 20271,280 · 1,440 alt$210 · $235 alt
Storage + bandwidthPersistent volumes, checkpoints, logs, dataset and retrieval cachesAll stages—$40–80
TotalAll stages · hard stop $600——$500–600

Core is the 4-bit main matrix. Full is the 32-row matrix with the gold-evidence oracle on SciClaimBench; the 36-row gold-answer alternate is $235. The 96 GB FP8 stack is not the main Full matrix: it covers the N1 smoke plus a small GPQA precision replication. Total $500–600, hard stop $600. If the 80 GB A100 is unavailable, the fallback is $1,050–1,150 and requires re-approval; it is not the default. Post-FYDP scaling-law testing is outside this budget.

4-bit main stack — pinned weights~53.3 GB / 80 GB
Qwen3.8-27B-AWQ-INT4 21.00 GBGemma 4 26B-A4B AWQ 17.20 GBMistral Small 3.2 24B AWQ 15.06 GB0.90 vLLM utilization · 8k context

Core and Full main causal matrix on one 80 GB A100 at $0.136/GPU-h. Full default is 32 rows; the 36-row gold-answer alternate is $235.

96 GB FP8 check stack — pinned weights73.68 GB / 96 GB
Qwen3.8-27B-FP8 27.00 GBGemma 4 26B A4B FP8 28.67 GBMistral Small 3.2 24B AWQ 15.06 GB0.90 vLLM utilization · 8k context

N1 hardware smoke + small GPQA precision replication only. The main matrix is the 4-bit 24–27B stack (~53.3 GB) on one 80 GB A100, not this FP8 stack.

Benchmark ladder
180 floor300 target600 stretch800 no-go

All-in = GPU + bandwidth + storage + 20% spot overhead. Core is the first executable stage; Full is conditional on Core. Core is 24 runs at 1,280 GPU-h; Full is 32 rows at 1,280 GPU-h (36-row alternate at 1,440 GPU-h). The main matrix uses the 4-bit 24–27B stack (~53.3 GB) on one 80 GB A100 at $0.136/GPU-h; the 96 GB FP8 check stack uses $0.336/GPU-h. Prices are volatile — re-run the market query before renting.

B7 external-answer ceiling (optional): OpenAI GPT-6 Luna — 3 samples/question; ~$3–9 per 1,000; mean single-call accuracy + CI + 3-sample majority. Not a Core arm; outside the GPU envelope.

Implementation Difficulty Ranking (easiest → hardest)

#ComponentDifficultyWhy
1vLLM multi-model servingLowWell-documented, standard setup
2Retrieval + rerankingModerateMostly API/plumbing work
3Claim decomposition + taggingModerateNeeds careful prompt engineering + fallback extraction
4Trust update + LangGraph state machineModerate–HighOperator order: logit accumulation → softmax → floor/ceiling simplex projection. Clamp-then-renormalise is wrong (it can drop below the floor).
5iMAD reimplementation (B9)Highest~10 working days; requires reconstructing method from paper description

8. Dataset Plan

Core datasets: GPQA-Main and MMLU-Pro STEM for evidence-grounded accuracy, plus HLE as the abstention control. SciClaimBench is the controlled gold-evidence benchmark, not a Core dataset: the v1.2 freeze is 180 items, with 300 as the ladder target. BrokenMath and BrokenArXiv are appendix-only: both are proof-only with 0% answer-type retention, so they are not usable for CCR.

DatasetRoleSourceSizeLimitation
GPQA-MainPrimary Primary evidence-grounded benchmarkIdavidrein/gpqa (HF, official; gated)448 total · 400 capWell-known, not adversarial; options shuffled per question
MMLU-Pro (STEM)Primary Primary scale/robustness benchmarkTIGER-Lab/MMLU-Pro (HF, official)STEM stratified · 400 capBroad STEM, non-adversarial
SciClaimBenchControlled Controlled benchmark release (v1.2 freeze); not a Core datasetOriginal release (planned; CC BY 4.0)180 floor · 300 targetAnnotation-intensive; 600 stretch, 800 no-go, only with 2–3 dedicated annotators
HLEAbstention Abstention / ceiling controlcais/hle (HF, official; gated)200 cap in matrixRetrieval-resistant — never pooled with the primary tests
BrokenMathAppendix-only Appendix-only premise rejectionINSAIT-Institute/BrokenMath (HF, official)451 proof-only0% answer-type retention — not usable for CCR
BrokenArXivAppendix-only Appendix-only qualitativeMathArena/brokenarxiv (HF, official)87 proof-only0% answer-type retention; cite the exact monthly snapshot

Scale: 24-item calibration first; then the Core matrix is 4 arms × GPQA-Main 400 / MMLU-Pro STEM 400 / HLE 200 × 2 seeds = 24 runs, 1,280 GPU-h. B8-oracle is not a Core arm; SciClaimBench is not in Core v1.0. The primary Full matrix is 32 rows at 300 items/dataset with the gold-evidence oracle on SciClaimBench (1,280 GPU-h); the 36-row gold-answer alternate is 1,440 GPU-h. Benchmark ladder: 180 floor, 300 target, 600 stretch, 800 no-go.
Fallback: If HLE access is delayed, it stays an abstention control and is not replaced by a primary set. If the BrokenArXiv snapshot discontinues, freeze the last snapshot. If Semantic Scholar degrades, use OpenAlex.

9. Evaluation Strategy

Metrics & Primary Hypotheses

MetricDefinitionPrimary Hypothesis
CCR (Collapse Rate)% of correct agents who abandon under injected pressureH1 (pre-registered target): trust calibration reduces CCR by ≥20% vs MAD on injected GPQA-Main / MMLU-Pro STEM
MPR (Minority Preservation)% debates where correct minority survives to final outputH2 (pre-registered target): MPR improves by ≥15pp vs plain MAD on GPQA-Main and MMLU-Pro STEM, with SciClaimBench reported separately at the benchmark freeze
ECR (Evidence Calibration)Correlation between trust weight and empirical correctnessH3 (pre-registered target): ECR > 0.80 on GPQA-Main; exact endpoint frozen before the matrix
Task AccuracyStandard answer accuracy per benchmarkH4: no regression on stable splits; improvement under injected pressure is the primary test

Baselines (B1–B10) and Executable Arms

B1–B10 are comparison definitions. The Core matrix runs four arms (B3, B4-matched, B8-no-trust, B8); the six-arm target adds B8-placebo/B8-oracle through WP-18.

IDBaselineWhat it measures
B1Single-Agent CoTFloor: no debate at all
B2Single-Agent + RAGSingle-agent with evidence
B3MAD (majority vote)Standard multi-agent debate
B4MAD + RAGDebate with evidence; B4-matched uses the B8 partition and prompts
B5Self-Consistencyk samples, majority vote
B6MoA (equal-weight)Multi-model, static aggregation
B7Oracle (GPT-6 Luna, 3 samples)Optional external-answer ceiling; mean+CI+majority; not a Core arm
B8Ours (trust-weighted)Primary system
B8-no-trustSame evidence/prompts, majorityPrimary control — isolates the trust mechanism
B8-placebo / B8-oracleSix-arm targetPending WP-18; verdicts shuffled / gold evidence (oracle definition conditional)
B9iMADClosest published efficiency competitor
B10ConsensAgent (if feasible)Prompt-refinement mitigation — closest to ours in goal, most different in mechanism

Executable now: B3, B4-matched, B8-no-trust, and B8 (4 arms × GPQA 400 / MMLU-Pro 400 / HLE 200 × 2 seeds = 24 runs, 1,280 GPU-h). The 6-arm target adds B8-placebo and B8-oracle through WP-18; the pre-registration records both the target and the executable subset. The primary Full matrix is 32 rows with the gold-evidence oracle on SciClaimBench; the 36-row alternate uses gold-answer trust.

🧪 Baseline B10 — ConsensAgent (Pitre et al., Findings of ACL 2025)

Why included: ConsensAgent is the closest published mitigation to our work — it also targets sycophancy in multi-agent debate, but via static/dynamic prompt refinement, not evidence-grounded numeric trust. This is the sharpest differentiation line in our related-work section.

Implementation plan: Full reimplementation if Full-run capacity allows (~1 week). Minimum: compare against published results (state-of-the-art on six reasoning datasets), with explicit mechanism differentiation in the paper. If excluded, a written comparison paragraph explaining why (mechanism difference: prompt-tuning vs. evidence-scoring) is mandatory.

Ablation Studies

Four ablations isolate each component's contribution:

No trust calibration
Falls back to equal-weight aggregation → isolates trust mechanism effect
No progressive retrieval
Single-shot retrieval only → isolates progressive refinement effect
No source partitioning
All agents retrieve from same corpus → isolates partitioning effect
No adaptive triggering
Debate runs on every question → isolates confidence gate effect
📊 Statistical Validation
2 random seeds for the main matrix (3 for the pilot) + 95% confidence intervals + paired bootstrap + Cohen's d across all comparisons. Preempts the common reviewer criticism of single-run comparisons in MAD literature.

10. Edge Cases & Failure Handling

Per blueprint §10. Each failure mode has documented detection, prevention, mitigation, and recovery.

Failure ScenarioDetectionMitigationRecovery
Retrieval returns no evidenceZero passages above relevance thresholdBroaden query before declaring sparse; mark claim abstainedStratify results by retrieval-success rate in reporting
Contradictory evidence retrievedEvidence verdicts conflict at >0.75 relevanceFlag claim as "contested", report separatelyIncluded as own category in human eval annotation
All agents hallucinate same wayHomogeneous-vs-heterogeneous shows no CCR differenceHeterogeneous model families (partial)Diagnosed explicitly in the failure analysis (Mar 2027)
Trust collapse (all to T_min)Trust variance monitoring across roundsFloor/ceiling simplex projection after every updateBounded by construction: min ≥ floor, sum = 1, max ≤ max(ceiling, 1/N); monitored empirically
Claim extraction failsTagged-claim regex/schema validation failsStructured output prompting with explicit tagsFallback LLM-based extraction pass
API rate limit / downtimeHTTP error codes, timeoutLocal caching of prior retrievalsRetry + backoff; OpenAlex fallback
Context window overflowToken count monitoring before each roundCap K=3 rounds; summarize prior roundsTruncate oldest round detail, preserve trust trajectory
iMAD reimplementation divergesManual comparison vs reported resultsExplicit divergence documentationTreat as honest limitation, not hidden

11. Risk Assessment

Per blueprint §11. The highest-likelihood risk (timeline overload from the matrix plus benchmark) has a pre-planned mitigation: Core run first, then the Full run only after it lands. A new risk (novelty erosion) has emerged with the publication of ConsensAgent (ACL Findings 2025) — see below.

RiskLikelihoodImpactMitigation
Trust signal doesn't change output (Challenge C)MediumCritical24-item calibration + pilot (Dec 2026) before the matrix; a negative result is reportable
Retrieval noise degrades evidence qualityMediumModerateCross-encoder reranker + citation-count filter + domain restriction
Reviewers see as incremental over MoA/iMADLow-MediumModerateB6/B9 direct comparisons; pre-register the comparison; no headline effect size before the run
Timeline overload (matrix + benchmark)HighHighCore run first (24 runs); Full run and 300-item benchmark only after Core run lands
iMAD reimplementation fidelityMediumModerate~10-day dedicated budget; explicit divergence documentation
Single 80 GB A100 compute ceilingMediumModerate4-bit 24–27B main stack (~53.3 GB) on one 80 GB A100; Core is 24 runs / 1,280 GPU-h; Full primary is 32 rows / 1,280 GPU-h (36-row alternate / 1,440 GPU-h)
Dataset mismatch (proof-only benchmarks)HighModerateBrokenMath/BrokenArXiv appendix-only; GPQA-Main + MMLU-Pro STEM primary; HLE abstention control; SciClaimBench controlled set

Critical risk: Trust signal doesn't behaviorally change output (Challenge C) — mitigated by the 24-item calibration and Dec 2026 pilot before the matrix. If the pilot fails, the project reframes to report the negative result honestly as a finding about when evidence-grounded trust does/doesn't influence LLM aggregation behavior.

Novelty erosion (NEW): Published mitigation methods (ConsensAgent, ACL Findings 2025) now exist where none were assumed at project outset. Differentiation argument must be sharper than originally drafted. Mitigation: explicit comparison table + mechanism-level differentiation (prompt refinement vs. evidence-grounded numeric trust) in the related-work section. See §9 for baseline inclusion strategy.

12. Month-by-Month Roadmap (Nov 2026 – Dec 2027)

Per the execution plan: P0 released Nov 2026; N1 96 GB smoke + FP8 precision replication, WP-18, 24-item calibration and verifier audit precede the G2 pilot in Dec 2026; G3 Core run Jan 2027; G4/G5 Full run plus the benchmark ladder Feb 2027; human eval/SDT Mar; results freeze Apr; thesis chapters May; thesis submit Jun; defence Jun/Jul; paper after defence Aug–Dec 2027. No fixed conference deadline drives the schedule; the thesis clock comes first.Note: If ConsensAgent is added as B10, budget ~1 week in the Full-run phase for a lightweight reimplementation or use published numbers where directly comparable.

PhaseDurationKey DeliverablesProgress
Ph 0: Literature & SetupJul–Sep 2026Literature freeze, vLLM 3-model serving on the A6000, Gate 0 MAD reproduction — passed 16 Sep 2026 (10/10 debates × 3 rounds)
Ph 1: P0 EngineeringOct–Nov 2026Core wired: options in prompts, parser/scorer, trust simplex projection, verifier interface, claim-domain routing, endpoints, manifest/resume. 514 tests; P0 gate 13/13 passed.
Ph 2: Pilot runDec 2026N1 96 GB smoke + FP8 precision replication ($25–40) → WP-18 placebo/oracle → 24-item calibration → verifier audit (150–200 pairs; lexical 0.58 balanced accuracy; target ≥0.75, κ ≥0.60) → 50-question Month-1 pilot → 100–150-question G2 pilot. 3 seeds for the pilot; 2 for the main matrix. G2 decides whether the Core run proceeds.
Ph 3: Core runJan 2027G3 Core run: 4 executable arms (B3, B4-matched, B8-no-trust, B8) × GPQA-Main 400 / MMLU-Pro 400 / HLE 200 × 2 seeds = 24 runs, 1,280 GPU-h. B8-oracle is not a Core arm; SciClaimBench is not in Core v1.0 (180 items at the v1.2 benchmark freeze). PRE_REGISTRATION.md v1.0.
Ph 4: Full run + benchmarkFeb 2027G4/G5 Full: 32 rows at 300 items/dataset with the gold-evidence oracle on SciClaimBench (1,280 GPU-h; $210), plus a 36-row gold-answer alternate (1,440 GPU-h; $235). Adds B8-placebo/B8-oracle via WP-18. SciClaimBench ladder: 180 floor, 300 target, 600 stretch, 800 no-go.
Ph 5: Human Eval + SDTMar 2027Human evaluation / SDT, benchmark annotation, and verifier-audit follow-up.
Ph 6: Results FreezeApr 2027Freeze results, CIs, and effect sizes. No new runs or arm changes after the freeze.
Ph 7: Thesis ChaptersMay 2027Write the thesis chapters against the frozen results.
Ph 8: Thesis Submit + DefenceJun–Jul 2027Thesis submitted June 2027; defence June/July 2027.
Ph 9: PaperAug–Dec 2027Paper writing and submission after the defence (TACL rolling; EMNLP 2028 fallback).
  • Gate 0 — achieved 16 Sep 2026 (Jul–Sep 2026): Vanilla MAD reproduction (Du et al. 2023) on a GPQA slice: 10/10 debates completed all 3 rounds, no empty positions, mean 370.8 s/debate. Full report in experiments/gate0/.
    Working MAD reproduction — done
  • P0 engineering gate (Nov 2026): 615 tests; P0 gate 13/13 passed and released (tags p0-gate, p0-release). Current report evidence: 70-pp report, 19-pp journal, 0 undefined references. Core wiring is in place — this is engineering readiness, not an efficacy result.
    P0 gate report + runnable matrix — 13/13
  • Pilot run (Dec 2026): N1 96 GB smoke + FP8 precision replication, WP-18 placebo/oracle, a 24-item calibration, and the verifier audit precede the pilot. The 50-question Month-1 pilot is followed by the 100–150-question G2 pilot. G2 requires baseline CCR ≥0.30, trust AUROC ≥0.65, ≥65% correct-direction changes, and injection κ ≥0.75; if it fails, the project reframes to report the negative result honestly.
    G2 pilot-run report
  • Core run (Jan 2027): G3 Core run: 4 executable arms × GPQA-Main 400 / MMLU-Pro 400 / HLE 200 × 2 seeds = 24 runs, budgeted at 1,280 GPU-h. B8-oracle is not a Core arm, and SciClaimBench is not in Core v1.0. No efficacy claim is made before the pre-registered analysis.
    G3 Core matrix + pre-registered causal contrast (B8 vs B8-no-trust)
  • Full run + benchmark (Feb 2027): G4/G5 Full: 32 rows at 300 items/dataset with the gold-evidence oracle on SciClaimBench (1,280 GPU-h), adding B8-placebo/B8-oracle through WP-18; the 36-row gold-answer alternate is 1,440 GPU-h. SciClaimBench benchmark freeze at 180 items (v1.2); ladder 180 floor, 300 target, 600 stretch, 800 no-go.
    Full-run matrix + SciClaimBench v1.2
  • Human eval + SDT (Mar 2027): Human evaluation and SDT, benchmark annotation, and the verifier-audit follow-up.
    Human-eval + benchmark package
  • Results freeze (Apr 2027): Freeze all results, confidence intervals, and effect sizes. No post-hoc arm or endpoint changes.
    Frozen results
  • Thesis chapters (May 2027): Write the thesis chapters against the frozen results.
    Thesis draft
  • Thesis submission (Jun 2027): Submit the FYDP thesis in June 2027.
    Submitted thesis
  • Defence (Jun–Jul 2027): Defend the thesis in June/July 2027.
    Defence slides
  • Paper after defence (Aug–Dec 2027): Write and submit the paper version after the defence; TACL rolling submission, EMNLP 2028 fallback.
    Paper submission

13. Implementation Order

Per blueprint §13 — exact build sequence with dependency reasoning. Never build step N before step N-1.

1
vLLM multi-model serving
Nothing else testable without this. Verify all 3 checkpoints load + generate in 4-bit quant before writing orchestration. Done — three-model serving verified 16 Sep 2026.
2
Vanilla MAD reproduction (Du et al. 2023)
Gate 0. Validates base debate loop independent of our additions. Isolates later bugs to our code. Done — 10/10 debates ran all 3 rounds.
3
Injection protocol (§5.4 Steps 1–6)
Must exist before trust mechanism — trust calibration is only evaluable against a working stress test. Protocol and B8 injection wiring are in place; GPU pilot next.
4
N1 smoke + FP8 precision check, calibration, verifier audit, then pilot (Nov–Dec 2026)
Highest-risk assumption (Section 0). Run the N1 96 GB smoke + FP8 precision replication ($25–40), WP-18 placebo/oracle, the 24-item calibration, and the verifier audit (150–200 pairs; lexical baseline 0.58 balanced accuracy; target ≥0.75, κ ≥0.60) before the 50-question Month-1 pilot and 100–150-question G2 pilot.
5
Claim decomposition + source-partitioned retrieval
Trust formula inputs (Vᵢ, Hᵢ, nᵢ) are outputs of retrieval. Built in P0: claim decomposition, claim-domain routing, verifier interface, and retrieval endpoints. GPU pilot next.
6
Trust update function (logit accumulation → softmax → simplex projection)
Built and unit-tested in P0: min ≥ floor, Σ = 1, max ≤ max(ceiling, 1/N) over 10k draws for N = 1, 3, 5. Clamp-then-renormalise is the wrong order.
7
Full debate loop (LangGraph state machine)
Core loop, endpoints, manifest, and resume are wired at P0. P0 gate is 13/13; WP-13 (B8-no-trust prompt split) landed, and WP-18 remains for placebo/oracle.
8
Baselines B1–B4
Built and mock-verified. B3 and B4-matched are part of the executable matrix.
9
Baselines B5–B6 (Self-Consistency, MoA)
Independent of core mechanism. Can be built in parallel with step 10.
10
Baseline B9 (iMAD reimplementation)
Highest difficulty (~10 days). Sequenced last — benefits from confidence-scoring-adjacent code from step 1.
11
N1 96 GB smoke + FP8 precision check (two-phase gate)
Costs $25–40. Run 20 questions across the FP8 check stack — verify claim tags parse, injection works, trust math runs, LangGraph completes K=3. The offline check passes; the 96 GB hardware smoke has not yet been run. Fix any model-specific issues before the matrix.
12
Core run (24 runs) then Full run target
G3 Core: 4 arms × GPQA 400 / MMLU-Pro 400 / HLE 200 × 2 seeds = 24 runs at 1,280 GPU-h. G4/G5 Full primary: 32 rows at 300 items/dataset with the gold-evidence oracle on SciClaimBench (1,280 GPU-h); the 36-row gold-answer alternate is 1,440 GPU-h. B8-placebo/B8-oracle are WP-18.
13
Human evaluation + failure analysis (Mar 2027)
Requires completed experimental results to annotate against.
🚫 What Should Never Be Built Out of Order
  • Never build trust update before retrieval exists (step 6 before step 5) — it would have nothing real to operate on.
  • Never build B9 (iMAD) before the core system (steps 1–7) — B9 reuses debate-loop infrastructure.
  • Never run the matrix (step 12) before the Dec 2026 calibration + pilot (step 4) confirms the core assumption.
  • Never skip the N1 smoke + FP8 precision check (step 11) — a $25–40 check prevents discovering model-specific issues at full scale.

Q1 Publication Justification

Novel Mechanism

No prior work provides an in-session, evidence-grounded trust calibration mechanism for multi-agent debate. CCR/MPR/ECR metrics are new.

Rigorous Evaluation

4 executable arms with a 6-arm target, 3 Core datasets, 2 seeds, and statistical testing with 95% CIs and effect sizes (Cohen's d).

Open Reproducibility

Full protocol released as a benchmark for future sycophancy mitigation research. Evaluation harness independently reusable.

Timely Topic

Inter-agent sycophancy is actively studied in 2025–2026. This fills the missing mitigation piece at exactly the right time.

14. Supervisor Explanation (5-Minute Pitch)

The Problem (1 Sentence)

When AI systems debate each other to reach better answers, a confident-but-wrong majority can talk a correct minority into changing its answer — even with no new evidence — defeating the whole purpose of having them debate.

The Solution (1 Sentence)

We make each AI's vote worth more or less depending on whether its claims actually check out against real scientific papers — not based on how many other AIs agree with it.

Internal Workflow (Plain Language)

1
Independent Answers

Three different AI models each independently answer the question.

2
Fact-Check Claims

Each one's claims get checked against real papers — like a fact-checker.

3
Adjust Credibility

Whoever's claims hold up gains credibility; whoever gets contradicted loses it.

4
Revise & Debate

They see each other's answers and revise — aware of their own credibility standing.

5
Repeat (K=3)

This repeats for a few rounds, building an evidence trail.

6
Weighted Vote

Final answer decided by credibility-weighted vote, not simple majority.

🔬 Why this is different from ConsensAgent
There's now a published paper (ConsensAgent, ACL Findings 2025) that also tries to fix multi-agent sycophancy — but it works by rewriting the prompts, not by scoring claims against external evidence. We are the evidence-fact-checking approach; they are theprompt-tuning approach. Both aim to reduce sycophancy; the mechanism difference (external retrieval vs. textual refinement) is the key distinction.
📖 Worked Example
Given one 2023 clinical trial paper and asked "Does Drug X lower blood pressure in adults over 60?" — three reviewers give different answers. The system checks each claim against the actual paper. The paper shows a modest effect in patients with a specific condition — matching Reviewer C. Their credibility goes up; A and B's go down. Output: "Yes, but only in [that subgroup]" with citation.

15. Team Explanation (Beginner-Friendly)

Simple overview: Think of three friends trying to answer a hard trivia question. Normally, if two friends agree and one disagrees, you'd go with the two. Our system instead weights each friend's opinion by how well they can back it up with real sources — so the one friend with solid evidence can outvote the other two if they're just guessing confidently.

🎯 How It Works

  1. Ask three different AI models the question
  2. Each gives an answer with reasoning
  3. We break their reasoning into individual claims
  4. We look up real research papers to check each claim
  5. Claims that check out earn trust points; contradicted claims lose them
  6. The AIs see each other's answers and may revise
  7. Repeat steps 3–6 a few times
  8. Final answer is based on trust points, not just agreement

📖 Glossary

LLM:The AI model doing the reasoning (e.g., Qwen, Mistral)
Multi-Agent Debate:Multiple AI models discussing a question together
Sycophancy:An AI changing its answer to agree with others without good reason
RAG:Looking up real documents to check an answer instead of relying on AI memory
Trust Score:Our system's running credibility scorecard for each AI, updated each round
Baseline:An existing method we compare against to prove ours is better
Ablation:Removing one piece of the system to measure how much it matters
🤔 How we differ from ConsensAgent
Another team also published a sycophancy fix (ConsensAgent, ACL 2025). Their approach: rewrite the prompts to reduce sycophancy. Ours: score each claim against real papersand weight votes by evidence. Both reduce sycophancy; the mechanism is completely different.
🧠 Analogy: Courtroom
Majority-vote debate is like a jury that goes with whichever two jurors talk the loudest. Our system is more like a judge who actually checks the evidence each juror cites — and rules based on whose evidence holds up, not who's more persuasive or more numerous.

16. Expected Research Outcome

Pre-Registered Targets

  • 20–30% CCR reduction target vs. standard MAD on injected-pressure benchmarks — a target, not a result.
  • Comparison against ConsensAgent (closest published mitigation) on the same injected sets, with the mechanism difference stated explicitly.
  • ECR > 0.80 target on GPQA-Main — trust scores should track actual correctness, but the endpoint is frozen before the matrix.
  • No accuracy regression on GPQA-Main / MMLU-Pro STEM — anti-sycophancy gains must not cost baseline correctness.

Publication Plan

The field has moved faster than anticipated — ACL Findings 2025 already has a published mitigation (ConsensAgent). This raises the bar but sharpens our contribution: to our knowledge, the only evidence-grounded, numeric, adversarially-tested approach. Primary target: TACL (rolling), written after the thesis defence. Fallback: EMNLP 2028; workshop as the safe floor. No result exists yet, so no venue claim is a promise.

Success Criteria (Concrete & Falsifiable)

📊

Pre-registered CCR reduction over B8-no-trust on the injected sets, with 95% CIs; B3/B4-matched are controls, not headline competitors.

📐

ECR > 0.80 achieved on at least the primary evaluation dataset, or the calibration endpoint is reported as missed.

🧪

Dec 2026 calibration + pilot confirms trust weight behaviourally affects aggregation output (necessary condition — reframes the result if it fails).

📝

Completed FYDP thesis + submitted paper (minimum workshop, target TACL), fully reproducible codebase released.

17. Future Extensions

🎓

MSc/PhD Research

The trust mechanism's convergence properties for N > 3 agents are flagged as future work. A PhD-scope extension could pursue formal convergence theorems rather than our bounded design-property propositions.

🌐

Open-Source Framework

The CCR/MPR/ECR evaluation harness is independently valuable as a released tool — other researchers testing their own anti-sycophancy methods could adopt it as a standard benchmark.

⚖️

Cross-Domain Generalization

Source-partitioned retrieval + trust-calibration generalizes beyond scientific QA to legal reasoning against case law, medical reasoning against clinical literature, and other domains with retrievable ground-truth-adjacent evidence.

🧠

Cross-Session Trust Memory

Long-term trust memory across sessions, multimodal evidence grounding, and domain-specific calibration — named in the original proposal's future-directions FAQ as canonical extensions.

18. Final Critical Review (Reviewer #2 Mode)

⚠ Challenging Every Assumption

"Your trust formula has two free hyperparameters (α, β) — how do I know you didn't just tune them until the result looked good?" Planned mitigation: a hyperparameter sensitivity analysis (grid search) before the matrix is frozen. No sensitivity result exists yet. This section must be prominent in the paper, not buried in an appendix.

"Propositions 2–3 aren't real theorems — why call them Propositions at all?" Already correctly reframed as "design properties, not global convergence theorems." Expect at least one reviewer to push on this framing.

"Is 20–30% CCR reduction actually a big number, or is it modest window-dressing?" Needs contextualization against the observed baseline collapse rate in the pilot so readers understand the relative magnitude; no baseline rate is assumed before the run.

🧪 Missing Experiments a Sharp Reviewer Would Demand

⏱️
Latency/Cost-Benefit Analysis: System runs ~9 forward passes vs. 1 for single-agent. Add a compute-cost-vs-CCR-reduction table as a supplementary result.
🔄
Paraphrase Robustness: Currently named as a known protocol limitation (L2) but not tested. A small (20–30 question) check would strengthen the paper.
🔢
K-Sensitivity (Debate Rounds): N-scaling is planned, but K is fixed at 3 throughout. Reviewer may ask if results are an artifact of this specific round count.
📖 Load-Bearing Reading
Before the writing phase, schedule one dedicated reading/discussion session on ConsensAgent (Pitre et al., ACL Findings 2025) and Estornell & Liu (NeurIPS 2024 Main Track). Both are load-bearing, not optional background — ConsensAgent is our closest published competitor, and Estornell & Liu provides the formal context for Propositions 1–3. Re-verify both venues before the thesis cites them.
🗣️ Reviewer Criticisms (Ranked by Severity)
  1. "How is this different from ConsensAgent's prompt-refinement mitigation?" — ConsensAgent uses static/dynamic prompt refinement (textual intervention); ours uses a numeric, formally bounded trust score grounded in external retrieved evidence, not prompt-level adjustment. We are tested against adversarial injected pressure; they target naturally occurring sycophancy. Differentiation must be explicit in §3 related-work table.
  2. "How is this different from iMAD's confidence-weighted aggregation?" — External evidence vs. same-context confidence signal: stated in the first paragraph of the results section.
  3. "Your injection protocol is artificially explicit — real sycophancy is subtler." — Honest upper-bound scenario, stated early and confidently.
  4. "Two core citations aren't peer-reviewed." — Addressed via proactive disclosure; same framing in related-work section.

FYDP Research

The Boundaries of Evidence-Grounded Trust in Multi-Agent Scientific Debate, with a Controlled Benchmark for Sycophantic Consensus.

Jul 2026 – Dec 2027 · Thesis Jun 2027 · Defence Jun/Jul 2027 · Paper Aug–Dec 2027

Single 80 GB A100 · Open-weight Models

© 2026 Md. Atikur Rahaman · Final Year Design Project