OverthinkAI — 4-Agent Life Decision Simulator

Inspiration

Six months ago I was stuck.

I'm a second-year CS student running an early-stage AI startup. I had two real options with real deadlines that were mutually incompatible: prepare for GATE CSE 2027 — India's most competitive CS entrance exam, ~140,000 candidates, fewer than 400 IIT MS seats — or go all-in on fastX Studio, where I'm the lead AI/ML engineer.

Every tool I tried gave me a pros/cons list or a motivational push toward "following my passion." Neither was useful. What I needed was something that would argue against me. So we built it.

What It Does

OverthinkAI is a four-agent deliberation engine. Not a chatbot. Not an AI advisor. A structured debate system.

You enter your decision — the paths you're comparing, your resource constraints across seven dimensions adapted from Chanakya's Arthashastra (conviction, advisors, domain knowledge, safety net, capital, execution capacity, allies), your core values, risk tolerance, and time horizon.

Four specialized AI agents then debate your decision:

Realist Agent — fires a live Tavily web search before generating analysis. Grounds every claim in real external data: GATE statistics, startup failure rates from NASSCOM, salary benchmarks from AmbitionBox. No hallucinated numbers.
Visionary Agent — maps the asymmetric upside of each path. What becomes possible (not just probable) on each route.
Ethicist Agent — checks whether each option is coherent with who you actually are, not just what you say you value. Flags the gap between stated values and revealed priorities.
Adversarial Auditor — reads all three outputs and hunts for where they're being sycophantic, overconfident, or aligned too quickly. Computes a conflict score. If it exceeds 65/100, it stops everything.

When the Auditor triggers, graph execution pauses via LangGraph's interrupt_before mechanism. A Human Gate appears. The system cannot proceed until the user manually re-weights their own priorities. This is not a UX checkbox — it is an architectural constraint. The Pydantic response schema has no final_recommendation field with a non-null path value. The AI cannot recommend a path regardless of what the LLM generates.

Output is five structured artifacts rendered in a tab-based decision matrix:

Matrix tab: Per-path tradeoff grid (gain / lose / must accept / becomes harder) + agent disagreements shown in full
Timeline tab: Illustrative uncertainty bands at 30/60/90 days — opacity-faded to communicate that projections degrade, explicitly labeled "not a calibrated forecast"
Actions tab: Low-stakes experiments per path tagged with 30/60/90 day horizons
Questions tab: Open questions only the user can answer + what-if scenarios

How We Built It

Architecture: FastAPI backend + LangGraph multi-agent state machine. Four agent nodes fire sequentially. The Adversarial Auditor reads all three upstream outputs. LangGraph's interrupt_before pauses execution at the Human Gate node. SQLite for in-memory session checkpointing. Deployed on Railway.

LLM stack: Groq API (llama-3.3-70b-versatile) for all agent reasoning — chosen for sub-2-second per-agent response time and generous free-tier rate limits that prevent exhaustion across multi-agent runs. Gemini 1.5 Flash as fallback. Tavily Search API for live web research in the Realist agent.

Frontend: Next.js 14 (App Router), TypeScript, Tailwind CSS. Cyber-Obsidian dark theme (#0F0F11 background). Three-pane workspace: Intake Laboratory → Dialectic Arena → Decision Matrix. Agent cards appear sequentially with color-coded identity (Realist=green, Visionary=blue, Ethicist=purple, Auditor=orange). JWT auth with session history on /profile. Deployed on Vercel.

The scaffold was adapted from our team's existing SwarmOS multi-agent framework, built across three prior hackathons. That gave us working LangGraph orchestration on Day 1 and let us focus four days on the product logic and UI.

Challenges

The sycophancy problem. Early builds had all four agents converging on the same path — usually the one the user's values subtly implied they wanted. We had to design the Adversarial Auditor to treat fast consensus as suspicious, not as validation. Calibrating the conflict threshold (we landed at 65/100) required significant iteration — too sensitive and the gate triggers on every decision; too loose and the auditor is toothless.

Holding the line on no recommendation. Every time we user-tested, testers wanted a "best path" output. The brief explicitly penalizes this. We enforced it at three layers: the synthesizer system prompt prohibits it, the Pydantic schema cannot return a non-null recommendation field, and the frontend TypeScript types have no rendering path for a winner card. Removing the final_recommendation card four hours before deadline was the hardest call we made.

Gate flow reliability. LangGraph's interrupt_before combined with stateful resumption required careful checkpoint management. The Human Gate must block all downstream execution, surface the specific conflict reason, and resume from exactly the right graph state after re-weighting. Getting this to work reliably across multiple concurrent sessions took most of Day 2.

What We Learned

Responsible AI is an architectural decision, not a warning label. The difference between "we added a disclaimer" and "the response schema cannot return a path recommendation regardless of what the LLM generates" is the difference between safety theater and actual safety.

Multi-agent debate produces genuinely different reasoning than a single LLM. The Adversarial Auditor regularly surfaced blind spots that none of the other three agents flagged — particularly irreversibility traps and hidden assumptions shared across all three perspectives. This only emerges when agents are explicitly incentivized to disagree.

And the best demo is your own problem. We ran OverthinkAI on the GATE vs startup decision that inspired it. The Auditor triggered a Human Gate (conflict score: 85/100). After re-weighting and seeing the structured output — I still haven't decided. But I know exactly what question I've been avoiding. That's the product working as intended.