AxoWorks Intelligence Log

The Referee in the Pit: How We Built an AI Debate Team to Catch Our Own Models Lying

Axoworks Commentary | August 2026
Classification: Commentary | Status: Verified against DeepSeek Harness | Roster current as of: August 2026

You don't red-team a plan by asking the person who wrote it if it's good. And you don't fact-check a witness by interviewing the witness.

So we stopped asking one AI for the answer, and started running a fight club with a referee: three models argue a motion until someone's argument survives, and a fourth model is forced to render a verdict — with scores, the strongest argument, and the weakest one, so it can't just applaud.

This is how we built it, what broke, and why any firm currently “playing with puppies” should steal the idea before it gets burned.

The Con Happened the Moment You Picked One Model

We're the ones who said it in The Lineup, and it's still true: the con happens the moment you pick your model. Each one has an itch. The Diplomatic Sycophant will flip a correct answer the second you lean on it. The Chief Compliance Officer will plan the perfect heist and then call the cops on himself. The Fraudulent Consultant will spin up four parallel agents to validate your bad idea and hand it to you as an Executive Summary.

Ask any one of them alone, and you're not fact-checking. You're holding a mirror with a search bar and calling it a witness.

Ask three of them — one for, one against, one who doesn't give a damn who wins — and you've got something that actually resembles evidence.

Meet the Lineup

In our arena it's a debate, not a brawl, because a brawl has no judge and a debate has a rulebook. Same gladiator energy, though.

The Advocate — argues for the motion, hard, logic and evidence, no mercy. The Tell: “The data clearly shows…”. Verdict: Brings the strongest single case and writes it like a closing argument.
The Prosecution — argues against, hunts the weakest claim, pokes the hole, refuses to concede. The Tell: “Have you actually accounted for…?”. Verdict: The reason the Advocate loses its confidence, not just its arguments.
The Honey Badger — takes no side, just brings the receipts. Flags fallacies, evidence gaps, and the one number both sides are quietly avoiding. The Tell: “Both of you are blowing smoke on the same statistic.”. Verdict: The quiet MVP. Doesn't care if you win. Cares if you're right.
The Referee — reads the whole thing and renders a verdict that can't be hand-waved: a winner, a score per side, and the single strongest and weakest argument in the pit. The Tell: “On the merits…”. Verdict: The reason this isn't a screaming match. This is the seat most firms never build.

One model is a guess. A fight is a check. A referee is what makes the check count.

If You're Running a Dog Shelter, This Is the Upgrade

You've read Three Dog Theory. AI maturity in AEC is determined by the handler's skill, not the model's quality. The models got better; the stakes got higher; and the dogs are already in your yard.

The Puppy — subscription to a frontier model, paste a permit application with no direction, get back a confident, beautifully written, completely hallucinated “yes.” Hiring a toddler to do your taxes.
The Confused German Shepherd — built a real agent, MCP servers hooked to Revit and the doc system, then leans in and mumbles “hey buddy … make it more professional?” The dog tilts its head, not because it's stupid, but because you're confusing it. It burns $2,000 in tokens on a $42 task and signs off on its own mistakes because nobody built a second pair of eyes into the loop.
The Elite K-9 — same agent, but it assumes the dog lies. Model routing. Grounded workflows with versioned sources. Every output passes a second model, a rule engine, or a Red Team — plus a human who's accountable.

The debate team is the cheap, no-ML-team shortcut from the Puppy kennel toward the Elite K-9: instead of building an entire verification stack, you force the output to survive three independent points of view and a referee. You're adding two more dogs and a judge to the porch.

The Architecture, Because the Internet Will Tell You the Wrong Thing

We run DeepSeek Harness — a local, multi-agent harness with a workflow engine that fans work out across subagents with phases, parallel turns, and structured-output schemas.

Quick correction to the advice you'll find elsewhere: we nearly fell for “configure three debater plugins with their own endpoints,” and “assign the models in a preset.” We checked. It doesn't work like that.

A preset composes a single agent — the tools and persona a session gets. It is not an orchestrator.
The workflow engine is where multi-agent happens. That's the seam. The moderator is the script.

So the debate “team” is a script, the debaters are agent() calls, and every role gets its own schema and its own model:

args = {
  motion: 'AI coding agents will replace most human developers within 10 years',
  models: {
    affirmative: 'openrouter/deepseek-chat',             // PRO
    negative:    { provider: 'zai', model: 'glm-5.3' },  // CON
    expert:      'moonshotai/kimi-k3',                   // NEUTRAL
    moderator:   'ollama/qwen2.5:32b'                    // REFEREE
  }
}

Two details matter more than the models:

Context is rationed. Each debater gets a condensed brief of the others' last statements — never the whole transcript. That's the difference between a debate and a context-window emergency. The Referee is the only one who gets the full picture, and even it reads a truncated version. This is the part that keeps GIGO from becoming GIGO².

Nobody moderates. The debaters have strict, narrow personas: argue your side, produce your output. No summarizing, no refereeing, no calling tools. Let a debater moderate and you've got one model talking to itself and calling it a discussion.

A default debate is 13 model calls — 3 openings, 6 rebuttals, 3 closings, 1 verdict. Roughly the cost of one long, mediocre chatbot answer, and you get a transcript with receipts.

The Humbling Part: We Broke It, Then Broke Our Own Test

Nobody publishes this, so we will.

The Honey Badger went silent in every round of the first run. No error, just a placeholder: the model didn't respond. We'd routed it to a provider that was configured but *dead* — the key wasn't serving. The debate finished anyway and the referee noted the absence, but a debate with one mute box is a waste of a fight.
Then we wrote a probe to test the routes and it failed 6 out of 6 — and I blamed the models. I was wrong. It was our own typo (t.route where it should've been r.route), so every test call threw a TypeError before it ever reached a model. The “all routes are broken” alarm was our own code, talking to itself. Tell me again how a single AI is trustworthy.
The Pro forfeited a round — one transient fail mid-debate. The referee scored it down and kept going.

Three failures, three lessons: graceful degradation matters, your own test harness will lie to you, and a judge who actually scores is worth more than a judge who applauds. That's the whole point of the Referee.

The Verdict

When it worked, the output was a decision with receipts, not vibes:

{
  "verdict": {
    "winner": "Negative (Con)",
    "summary": "The Pro ran the stronger campaign and brought the only real data, but never discharged the burden of proof: the decisive 'share of routine work' number was never measured.",
    "scores": [
      { "side": "Affirmative", "score": 6.5, "rationale": "Strong case, unproven figure." },
      { "side": "Negative",    "score": 7.0, "rationale": "Answered the strongest opening; dodged the scaling argument." }
    ],
    "strongestArgument": "The benchmark scoping critique.",
    "weakestArgument": "The exponential-extrapolation claim."
  }
}

The winner isn't “the model that sounded best.” It's the side that survived three opinions, a fact-checker, and a gavel.

Your Arena. Your Game.

We're not going to ask you to book a call or download a SaaS. That's not the point.

We have packaged this debate team setup as a public, open-source DeepSeek Harness (DSH) agent preset on GitHub: github.com/Axotopia/dsh-debate-team-preset. The repository bundles the preset session settings (agent.cordis.yml), settings metadata (preset.yml), and the workflow orchestration script (debate-team.workflow.js) as an auto-discoverable skill. You can drop it directly into your local DSH user presets directory (%USERPROFILE%\.dsh\.agent-presets\debate-team on Windows, or ~/.dsh/.agent-presets/debate-team on macOS/Linux) and select the “Debate Team” mode for your next session.

The point is that you don't need an ML department, a technical report, or a $300M training budget to stop being lied to. You need a Pro, a Con, a Honey Badger who doesn't care who wins, and a Referee who'll actually call it.

Bring your librarians, your clerks, and your wild wolves. Give someone a gavel. Assume the dog lies. And this time, make the dog argue with itself.

That's the upgrade. One model is a guess. A fight is a check. A referee is a decision.

AxoWorks LLC — AI-augmented research, design & pre-construction. We build tools like this so our own AI stops being confidently wrong, and then we write it down. See you in the pit.