🚀I Built a Multi-Agent AI Debate Arena with LangGraph and Groq🚀

Ever wondered what happens when you let AI argue with itself?

I built AI Debate Arena — a terminal app where four AI agents (a moderator, a pro debater, a con debater, and a judge) run a full structured debate on any topic you give them, powered by LangGraph and Groq.

Here's how it works and what I learned building it.

🧠 The Concept

The idea is simple: instead of one AI giving you a balanced answer on a topic, what if multiple agents each had a role and a perspective — and had to argue, rebut, and decide?

Four agents, one state machine:

🔧 The Stack

• 
  LangGraph — for the state machine / agent orchestration


• 
  Groq + llama-3.1-8b-instant — for fast LLM inference


• 
  Rich — for the live typewriter-style terminal UI

🗂️ Project Structure

I split the project across 4 files for clean separation of concerns:

debate-arena/

├── main.py           # Entry point, user input, terminal display

├── agents.py         # State definition, LLM, agent functions

├── connections.py    # Graph nodes, edges, routing logic

└── prompts.py        # All prompt templates

🖥️ Terminal UI with Rich

After the graph finishes, the full history list is played back with a live typewriter effect using Rich:

def typewriter_panel(role, content):

    colors = {

        "moderator": "cyan",

        "pro": "green",

        "con": "red",

        "judge": "magenta"

    }

    text = Text()

    with Live(Panel(text, title=role.upper(), border_style=colors.get(role, "white")), refresh_per_second=30) as live:

        for char in content:

            text.append(char)

            sleep(0.005)

            live.update(Panel(text, title=role.upper(), border_style=colors.get(role, "white")))

Each role gets its own colour — cyan for the moderator, green for pro, red for con, magenta for the judge.

🧪 Running It

pip install -r requirements.txt

python main.py

Enter the topic: AI will replace software engineers

Enter maximum rounds: 3

Then watch the debate unfold in your terminal.

💡 What I Learned

LangGraph's conditional edges are powerful. Once I understood that routing is just a function that returns a string key, wiring up complex agent flows became intuitive.

Shared state is everything. All four agents read from and write to the same State dict. Keeping it well-defined upfront saved a lot of debugging later.

Prompt discipline matters. Telling each agent to "avoid repetition" and "rebut the previous argument" in the prompt made a real difference in output quality.

Groq is fast. Running 3 rounds with 4 agents means 6+ LLM calls — Groq handled this without any noticeable delay.

🔮 What's Next

• Save debate transcripts to a file


• Swap in different models per agent


• Build a web UI with Flask or Streamlit


• Add a third "neutral" debater

The full code is on GitHub: github.com/Sripadh-Sujith/debate-arena

If you build something on top of this or have ideas for improvements, drop them in the comments. Happy to discuss!

Thank You💖