Multi-Agent Debate¶

Debate workflow simulates a multi-turn discussion between different agents, mostly several solvers and an aggregator. Typically, the solvers generate and exchange their answers, while the aggregator collects and summarizes the answers.

We implement the examples in EMNLP 2024, where two debater agents will discuss a topic in a fixed order, and express their arguments based on the previous debate history. At each round a moderator agent will decide whether the correct answer can be obtained in the current iteration.

import asyncio
import os

from pydantic import Field, BaseModel

from agentscope.agent import ReActAgent
from agentscope.formatter import (
    DashScopeMultiAgentFormatter,
    DashScopeChatFormatter,
)
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.pipeline import MsgHub

# Prepare a topic
topic = (
    "The two circles are externally tangent and there is no relative sliding. "
    "The radius of circle A is 1/3 the radius of circle B. Circle A rolls "
    "around circle B one trip back to its starting point. How many times will "
    "circle A revolve in total?"
)


# Create two debater agents, Alice and Bob, who will discuss the topic.
def create_solver_agent(name: str) -> ReActAgent:
    """Get a solver agent."""
    return ReActAgent(
        name=name,
        sys_prompt=f"You're a debater named {name}. Hello and welcome to the "
        "debate competition. It's unnecessary to fully agree with "
        "each other's perspectives, as our objective is to find "
        "the correct answer. The debate topic is stated as "
        f"follows: {topic}.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=False,
        ),
        formatter=DashScopeMultiAgentFormatter(),
    )


alice, bob = [create_solver_agent(name) for name in ["Alice", "Bob"]]

# Create a moderator agent
moderator = ReActAgent(
    name="Aggregator",
    sys_prompt=f"""You're a moderator. There will be two debaters involved in a debate competition. They will present their answer and discuss their perspectives on the topic:
``````
{topic}
``````
At the end of each round, you will evaluate both sides' answers and decide which one is correct.""",
    model=DashScopeChatModel(
        model_name="qwen-max",
        api_key=os.environ["DASHSCOPE_API_KEY"],
        stream=False,
    ),
    # Use multiagent formatter because the moderator will receive messages from more than a user and an assistant
    formatter=DashScopeMultiAgentFormatter(),
)


# A structured output model for the moderator
class JudgeModel(BaseModel):
    """The structured output model for the moderator."""

    finished: bool = Field(
        description="Whether the debate is finished.",
    )
    correct_answer: str | None = Field(
        description="The correct answer to the debate topic, only if the debate is finished. Otherwise, leave it as None.",
        default=None,
    )


async def run_multiagent_debate() -> None:
    """Run the multi-agent debate workflow."""
    while True:
        # The reply messages in MsgHub from the participants will be broadcasted to all participants.
        async with MsgHub(participants=[alice, bob, moderator]):
            await alice(
                Msg(
                    "user",
                    "You are affirmative side, Please express your viewpoints.",
                    "user",
                ),
            )
            await bob(
                Msg(
                    "user",
                    "You are negative side. You disagree with the affirmative side. Provide your reason and answer.",
                    "user",
                ),
            )

        # Alice and Bob doesn't need to know the moderator's message, so moderator is called outside the MsgHub.
        msg_judge = await moderator(
            Msg(
                "user",
                "Now you have heard the answers from the others, have the debate finished, and can you get the correct answer?",
                "user",
            ),
            structured_model=JudgeModel,
        )

        if msg_judge.metadata.get("finished"):
            print(
                "\nThe debate is finished, and the correct answer is: ",
                msg_judge.metadata.get("correct_answer"),
            )
            break


asyncio.run(run_multiagent_debate())

Alice: As the affirmative side, I will argue that when circle A, with a radius one-third of that of circle B, rolls around the outside of circle B without sliding, it will complete 4 revolutions in total.

To understand why, let's consider the circumference of each circle. If we denote the radius of circle B as \( r_B \), then the radius of circle A is \( \frac{1}{3}r_B \). The circumference of a circle is given by \( C = 2\pi r \).

- The circumference of circle B is \( C_B = 2\pi r_B \).
- The circumference of circle A is \( C_A = 2\pi \left(\frac{1}{3}r_B\right) = \frac{2\pi r_B}{3} \).

When circle A rolls around circle B, it travels a distance equal to the circumference of the path it follows, which is the circumference of a circle with a radius equal to the sum of the radii of circles A and B, i.e., \( r_B + \frac{1}{3}r_B = \frac{4}{3}r_B \). Thus, the length of the path is:

- Path length \( L = 2\pi \left(\frac{4}{3}r_B\right) = \frac{8\pi r_B}{3} \).

The number of revolutions circle A makes is the path length divided by the circumference of circle A:

- Number of revolutions \( N = \frac{L}{C_A} = \frac{\frac{8\pi r_B}{3}}{\frac{2\pi r_B}{3}} = \frac{8\pi r_B}{3} \times \frac{3}{2\pi r_B} = 4 \).

Therefore, circle A will make 4 full revolutions as it rolls around circle B once.
Bob: As the negative side, I would like to clarify that while the calculations provided by the affirmative side are mathematically correct, there is a subtle point that needs to be addressed. The calculation of 4 revolutions considers only the linear distance covered and does not account for the rotational motion around the center of circle B.

When circle A rolls around circle B, it not only travels the distance equal to the circumference of the path (which is \( \frac{8\pi r_B}{3} \)), but it also rotates around the center of circle B. This additional rotation is equivalent to one full revolution, as after completing the path, circle A will have rotated once about the center of circle B in addition to the 3 revolutions due to the linear travel.

Therefore, the total number of revolutions made by circle A is 3 (from the linear distance) plus 1 (from the rotation around the center of circle B), which sums up to 4. However, this means that the 4th revolution is not due to rolling along the path but rather from the complete orbit around the larger circle. Thus, if we consider the revolutions due to rolling alone, circle A makes 3 revolutions, not 4.
Aggregator: The debate has concluded, and both sides have provided their arguments. Alice correctly calculated the number of revolutions based on the path length and the circumference of circle A. Bob added a clarification that the 4th revolution is due to the orbit around the larger circle B, which is an important point.

In fact, when circle A rolls around the outside of circle B, it completes 3 full rotations due to the linear distance traveled, and 1 additional rotation due to the orbit around circle B. Therefore, the total number of revolutions made by circle A as it rolls around circle B once is 4.

The correct answer is 4 revolutions. Alice's argument aligns with this conclusion, and although Bob's explanation adds a deeper understanding of the nature of the 4th revolution, the total count remains 4. The debate is now finished.

The debate is finished, and the correct answer is:  4

Multi-Agent Debate¶

Further Reading¶