Multi-agent debate from scratch without AI framework

Have you ever wondered what it would look like if multiple AI agents with opposing viewpoints engaged in a real-time debate? What if one supported a proposition, another opposed it, and a third remained neutral—each taking turns, mimicking human tone, and steering the conversation forward?

In this post, we'll walk through how to implement a multi-agent debate system using large language models. This system creates a back-and-forth exchange between proponent, opponent, and neutral agents with autonomous agent transition.

We do this all from scratch. No agent orchestration libraries like LangChain or LangGraph. Just API calls and software engineering.

Links to the code: Google Colab Notebook, NbViewer, Source NB

Why Multi-Agent Debate?

Multi-agent systems open the door to structured reasoning and self-play -- all of which are foundational for building intelligent AI agents that learn through interaction.

Debating agents are particularly interesting for:

• Testing LLM reasoning and consistency
• Synthesizing different perspectives on complex topics
• Creating compelling, autonomous dialogue systems

Let's dive into the code that brings this concept to life.

The Building Blocks

The notebook contains two main components:

• DebateContext: Manages the state of the debate and the current agent who is speaking.
• Agent: Represents each debating agent (Proponent, Opponent, Neutral). Each agent can be thought as a different state. They may have different viewpoints, configured using system prompt.

We use LiteLLM as the LLM abstraction layer, making it easy to switch models. In this case, we're using OpenAI's gpt-4o-mini.

Setup & Agent Instructions

MODEL = "openai/gpt-4o-mini"
MAX_TOKENS = 500

Each agent is guided by a system prompt that shapes their behavior:

PRO_AGENT_INSTRUCTIONS = (
    "You are an agent debating with other agents about a proposition"
    "that you agree with: {proposition}..."
) 
CON_AGENT_INSTRUCTIONS = (
    "You are an agent debating with other agents about a proposition"
    "that you disagree with: {proposition}..."
)
NEUTRAL_AGENT_INSTRUCTIONS = (
    "You are an agent debating with other agents about a proposition"
    "that you feel neutral about: {proposition}..."
)

Each instruction includes:

• Role-based persona
• Agreement stance
• Tone guide (mimic real people)
• Transition directive (e.g., Transition to opponent)

DebateContext: The Debate Orchestrator

class DebateContext:
    def __init__(self, proposition: str):
        self.proposition = proposition
        self.agents = {
            "proponent": Agent(...),
            "opponent": Agent(...),
            "neutral": Agent(...),
        }
        self.current_agent = self.agents["proponent"]
        self.messages = []

The DebateContext maintains:

• An agent registry (like states in a state machine)
• Debate history stored in messages array
• The currently active agent state

It handles the turn-by-turn logic through self.current_agent.debate().

Agent: A State

Each Agent executes a single round of conversation in this example. But you can imagine in more advanced use cases each Agent can call tools, reason, and call other tools in ReAct fashion.

After LLM completion, it stores the message in context.messages and handoff control to the next agent. We achieve this transition by using regex string matching to parse the choice of the next agent's name and map it to an actual Agent object using the agent registry context.agents.

class Agent:
    def __init__(
        self,
        name: str,
        instructions: str,
        context: DebateContext
    ) -> None:
        self.name = name
        self.instructions = instructions
        self.context = context

    def debate(self) -> str:
        # Prepend the system prompt to the messages history
        messages = [
            {"role": "system", "content": self.instructions}
        ] + self.context.messages
        response = litellm.completion(
            model=MODEL,
            max_tokens=MAX_TOKENS,
            messages=messages,
        )
        content = response.choices[0].message.content
        print(f"{content}\n")

        # Update the messages history
        self.context.messages.append(
            {"role": "assistant", "content": f"{content}"}
        )

        # State transition using string matching
        match = re.search(
            r"transition to (proponent|opponent|neutral)",
            content,
            re.IGNORECASE
        )
        if match:
            next_agent = match.group(1).lower()
            self.context.current_agent = (
                self.context.agents[next_agent]
            )
        else:
            raise ValueError(f"Invalid transition: {content}")

        return content

Notable points:

• Prepends system instructions to guide generation.
• Appends its response to the shared message history.

There we go, we have a rudimentary agent state machine.

Try it Yourself

Simply open the Google Colab Notebook, config the proposition you'd like the agents to debate on, and lastly run all the cells.

Make sure your API key is stored via google.colab.userdata or adapt the notebook to load it from environment variables locally.