Inspiration

Every AI assistant I use defaults to agreeing with me — that's the sycophancy problem, and it makes people worse thinkers. Real debate training exists for humans (coaches, steelmanning, fallacy drills) but there's no AI sparring partner that actually fights back. Crossfire is the gym for that: an opponent that argues the strongest version of the other side, a referee that calls your fouls, and a judge that scores you honestly.

What it does

You state a position. Crossfire takes the other side across structured debate rounds:

  • Steelmanning opponent — argues the strongest version of the opposing case. 4 personas (The Skeptic, The Lawyer, The Contrarian, The Economist) x 3 difficulties (Friendly / Rigorous / Hostile).
  • Real-time fallacy referee — flags strawman, ad hominem, false dilemma, appeal to authority, bandwagon, slippery slope, and begging the question in your moves, with plain-language fixes.
  • Live evidence checks — every factual claim in every move is extracted and searched against the live web via Tavily. Each claim gets a verdict (verified / disputed / unverifiable) grounded in real source URLs.
  • Mid-debate side-switch — flip sides and Crossfire argues YOUR position better than you did, then shows you exactly where your original case was weak.
  • Impartial judge + report card — round-by-round scorecard, winner verdict, and a personal report card tracking your fallacy profile and evidence hygiene.
  • Sparring record — longitudinal SQLite memory: debates, rounds, flips, recurring fallacies, and evidence trends across sessions, so you can see yourself improving (or not).

How we built it

Multi-agent system. Every agent call goes through Nebius Token Factory's OpenAI-compatible API, with NVIDIA Nemotron-3 models routed by job — the fast/cheap model where speed matters, the big reasoner where depth matters:

  • Opponent: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B — fast, sharp rebuttals keep rounds snappy.
  • Analyst (fallacy referee): nvidia/Nemotron-3-Ultra-550b-a55b — deep reasoning for precise fallacy detection.
  • Judge: nvidia/Nemotron-3-Ultra-550b-a55b — long-context reasoning over full debate history for fair verdicts.
  • Fact-check claim extraction: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B — quick structured extraction before web verification.

Tavily powers the evidence layer: real runtime search per claim (not a mock), keyless tier works out of the box, higher limits with an API key. This is the feature that makes the "evidence hygiene" report card mean something — every factual claim in a live debate resolves to a verdict backed by source URLs, judged in real time.

Backend: FastAPI + SQLite (WAL mode). Frontend: React + Vite, dark arena design with Clash Display + Satoshi type. Deployed as a single Docker service behind Caddy HTTPS on an Azure VM. A mock backend (CROSSFIRE_LLM=mock) runs the full loop offline for development. Repo is public, MIT licensed, README documents setup and the Nebius/NVIDIA integration.

Challenges we ran into

  • Free hosting died honestly — Fly.io, Render, Koyeb, and Zeabur all wanted a credit card for verification. Repurposed a personal Azure student-credit VM instead: Docker single-service + Caddy + nip.io HTTPS, all scripted.
  • The Token Factory client crashed the app at import when the API key was missing. Fixed with lazy initialization — the app boots in tokenfactory mode and raises a clear error only on live calls.
  • Tuning the fallacy referee to call fouls precisely without nagging every move, and making evidence verdicts actually traceable to URLs instead of vibes.

Accomplishments that we're proud of

  • A complete multi-agent debate loop that runs end-to-end on live models — opponent, referee, fact-checker, and judge as separate agents with routed models.
  • Per-claim web verification with real sources, the feature that makes the "evidence hygiene" report card mean something.
  • The side-switch: watching it argue your own position better than you did is the single best demo moment.
  • Shipped solo, live URL, public repo — a finished product, not a pitch deck.

What we learned

  • Model routing is the whole game: Ultra-550B where reasoning depth decides the outcome, Nano-30B where latency decides it.
  • Sycophancy is the default and has to be engineered out — steelmanning prompts need to be ruthlessly explicit about what "strongest opposing case" means.
  • An OpenAI-compatible endpoint makes all of this portable: one env var swaps the entire backend.

What's next for Crossfire

  • Voice sparring with Nemotron-3-Nano-Omni
  • Shareable sparring records + debate-team drills
  • More personas and languages (the Nano models' multilingual support makes Arabic sparring realistic)

Built With

Share this project:

Updates

Submission history