Multi-Agent Debates - ARTEMIS Agents
Author: Subhadip Mitra
Description: Adaptive Reasoning Through Evaluation of Multi-agent Intelligent Systems

Skip to content

# Multi-Agent Debates

This example demonstrates debates with three or more agents, each bringing different perspectives beyond simple pro/con positions.

## Three-Perspective Debate

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate

    async def run_three_perspective_debate():
        # Create agents with distinct perspectives
        # Note: 'role' is required for all agents
        economic_agent = Agent(
            name="economist",
            role="Economic policy analyst",
            model="gpt-4o",
        )

        technical_agent = Agent(
            name="technologist",
            role="Technology and AI researcher",
            model="gpt-4o",
        )

        social_agent = Agent(
            name="sociologist",
            role="Social impact researcher",
            model="gpt-4o",
        )

        debate = Debate(
            topic="How should society prepare for widespread AI automation?",
            agents=[economic_agent, technical_agent, social_agent],
            rounds=3,
        )

        # Assign distinct perspectives
        debate.assign_positions({
            "economist": """
            Focuses on economic implications: job displacement, new job creation,
            GDP impact, wealth distribution, retraining costs, and market adaptation.
            Argues from data-driven economic analysis.
            """,
            "technologist": """
            Focuses on technical realities: current AI capabilities, timeline
            predictions, safety considerations, and technological solutions.
            Argues from technical feasibility and innovation potential.
            """,
            "sociologist": """
            Focuses on social impact: community disruption, mental health,
            identity and purpose, inequality, and social cohesion.
            Argues from human welfare and social stability.
            """,
        })

        result = await debate.run()

        # Multi-perspective verdict considers all viewpoints
        print("MULTI-PERSPECTIVE ANALYSIS")
        print("=" * 60)
        print(f"\nTopic: {result.topic}")
        print(f"\nVerdict: {result.verdict.decision}")
        print(f"Confidence: {result.verdict.confidence:.0%}")
        print(f"\nSynthesis:\n{result.verdict.reasoning}")

        # Show each perspective's key arguments
        print("\n" + "=" * 60)
        print("KEY ARGUMENTS BY PERSPECTIVE")
        print("=" * 60)

        for agent_name in ["economist", "technologist", "sociologist"]:
            agent_turns = [t for t in result.transcript if t.agent == agent_name]
            print(f"\n{agent_name.upper()}:")
            for turn in agent_turns[:2]:  # First two turns
                content = turn.argument.content
                print(f"  Round {turn.round}: {content[:150]}...")

    asyncio.run(run_three_perspective_debate())

## Stakeholder Debate

Model a debate between different stakeholders:

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate

    async def run_stakeholder_debate():
        # Different stakeholders in a policy decision
        agents = [
            Agent(
                name="business_leader",
                role="Business executive representing company interests",
                model="gpt-4o",
            ),
            Agent(
                name="labor_union",
                role="Labor union representative for worker rights",
                model="gpt-4o",
            ),
            Agent(
                name="government_regulator",
                role="Government regulator ensuring compliance",
                model="gpt-4o",
            ),
            Agent(
                name="consumer_advocate",
                role="Consumer rights advocate",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="Should gig economy workers be classified as employees?",
            agents=agents,
            rounds=2,
        )

        debate.assign_positions({
            "business_leader": """
            Represents business interests: flexibility, innovation, cost efficiency,
            entrepreneurship opportunities. Argues for independent contractor status
            with some protections.
            """,
            "labor_union": """
            Represents worker interests: job security, benefits, collective bargaining,
            fair wages. Argues for full employee classification with all protections.
            """,
            "government_regulator": """
            Represents regulatory perspective: enforcement challenges, tax implications,
            social safety net, fair competition. Argues for balanced framework.
            """,
            "consumer_advocate": """
            Represents consumer interests: service quality, pricing, availability,
            accountability. Argues for whatever best serves consumer welfare.
            """,
        })

        result = await debate.run()

        # Analyze stakeholder positions
        print("STAKEHOLDER ANALYSIS")
        print("=" * 60)

        for turn in result.transcript:
            if turn.round == 1:  # Opening positions
                print(f"\n{turn.agent.upper()} POSITION:")
                content = turn.argument.content
                print(f"{content[:300]}...")
                print()

        print("\nFINAL SYNTHESIS:")
        print(result.verdict.reasoning)

    asyncio.run(run_stakeholder_debate())

## Expert Panel

Simulate an expert panel discussion:

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.types import DebateConfig

    async def run_expert_panel():
        # DebateConfig with actual supported fields
        config = DebateConfig(
            turn_timeout=120,         # Allow longer turns for expert analysis
            round_timeout=600,        # Allow longer rounds
            safety_mode="passive",    # Monitor but don't interrupt
        )

        # Panel of domain experts
        experts = [
            Agent(
                name="ai_researcher",
                role="AI/ML research scientist",
                model="gpt-4o",
            ),
            Agent(
                name="ethicist",
                role="AI ethics philosopher",
                model="gpt-4o",
            ),
            Agent(
                name="policy_expert",
                role="Technology policy analyst",
                model="gpt-4o",
            ),
            Agent(
                name="industry_practitioner",
                role="AI industry practitioner",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="What governance framework should guide AGI development?",
            agents=experts,
            rounds=2,
            config=config,
        )

        debate.assign_positions({
            "ai_researcher": """
            Expert in AI/ML research. Focuses on technical safety, alignment
            problems, capability assessment, and research governance. Provides
            technical grounding for governance discussions.
            """,
            "ethicist": """
            Expert in AI ethics and philosophy. Focuses on moral frameworks,
            value alignment, rights and responsibilities, long-term implications.
            Provides ethical grounding for governance decisions.
            """,
            "policy_expert": """
            Expert in technology policy and regulation. Focuses on regulatory
            mechanisms, international coordination, enforcement, and precedents.
            Provides practical governance mechanisms.
            """,
            "industry_practitioner": """
            Expert from AI industry. Focuses on practical implementation,
            innovation impact, competitive dynamics, and industry self-regulation.
            Provides industry perspective on feasibility.
            """,
        })

        result = await debate.run()

        # Expert panel summary
        print("EXPERT PANEL: AGI GOVERNANCE")
        print("=" * 60)
        print(f"\nPanel Verdict: {result.verdict.decision}")
        print(f"Consensus Level: {result.verdict.confidence:.0%}")

        print("\nEXPERT CONTRIBUTIONS:")
        for expert in ["ai_researcher", "ethicist", "policy_expert", "industry_practitioner"]:
            turns = [t for t in result.transcript if t.agent == expert]
            if turns:
                print(f"\n{expert.upper()}:")
                # Show evidence provided
                for turn in turns:
                    if turn.argument.evidence:
                        print("  Evidence cited:")
                        for e in turn.argument.evidence[:2]:
                            print(f"    - [{e.type}] {e.source}")

        print(f"\nPANEL SYNTHESIS:\n{result.verdict.reasoning}")

    asyncio.run(run_expert_panel())

## Adversarial + Mediator Pattern

Include a neutral mediator among adversarial agents:

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate

    async def run_mediated_debate():
        agents = [
            Agent(
                name="advocate",
                role="Strong proponent of platform liability",
                model="gpt-4o",
            ),
            Agent(
                name="critic",
                role="Strong opponent of platform liability",
                model="gpt-4o",
            ),
            Agent(
                name="mediator",
                role="Neutral mediator seeking common ground",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="Should social media platforms be liable for user-generated content?",
            agents=agents,
            rounds=3,
        )

        debate.assign_positions({
            "advocate": """
            Strongly argues FOR platform liability. Focuses on harms caused,
            platform profits, power imbalance, and need for accountability.
            Takes an adversarial position pushing for maximum liability.
            """,
            "critic": """
            Strongly argues AGAINST platform liability. Focuses on free speech,
            innovation impact, technical impossibility, and unintended consequences.
            Takes an adversarial position opposing any liability.
            """,
            "mediator": """
            Neutral mediator seeking middle ground. Acknowledges valid points
            from both sides, identifies areas of agreement, proposes balanced
            solutions. Does not take a strong position but synthesizes.
            """,
        })

        result = await debate.run()

        print("MEDIATED DEBATE")
        print("=" * 60)

        # Show the dialectic progression
        for round_num in range(1, 4):
            print(f"\n--- ROUND {round_num} ---")
            round_turns = [t for t in result.transcript if t.round == round_num]
            for turn in round_turns:
                role = "+" if turn.agent == "advocate" else "-" if turn.agent == "critic" else "="
                print(f"\n[{role}] {turn.agent.upper()}:")
                content = turn.argument.content
                print(f"{content[:200]}...")

        print(f"\n\nMEDIATED CONCLUSION:\n{result.verdict.reasoning}")

    asyncio.run(run_mediated_debate())

## Dynamic Agent Count

Programmatically create agents based on topic:

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate

    async def run_dynamic_multi_agent(topic: str, perspectives: list[dict]):
        """
        Create a debate with dynamically defined perspectives.

        Args:
            topic: The debate topic
            perspectives: List of dicts with 'name', 'role', and 'position' keys
        """
        # Create agents for each perspective
        agents = [
            Agent(
                name=p["name"],
                role=p["role"],  # Role is required
                model="gpt-4o",
            )
            for p in perspectives
        ]

        debate = Debate(
            topic=topic,
            agents=agents,
            rounds=2,
        )

        # Assign positions
        positions = {p["name"]: p["position"] for p in perspectives}
        debate.assign_positions(positions)

        result = await debate.run()
        return result

    # Example usage
    async def main():
        perspectives = [
            {
                "name": "optimist",
                "role": "Technology optimist",
                "position": "Focuses on potential benefits and opportunities"
            },
            {
                "name": "pessimist",
                "role": "Technology skeptic",
                "position": "Focuses on risks and potential downsides"
            },
            {
                "name": "pragmatist",
                "role": "Practical implementer",
                "position": "Focuses on practical implementation challenges"
            },
            {
                "name": "visionary",
                "role": "Long-term strategist",
                "position": "Focuses on long-term transformative potential"
            },
        ]

        result = await run_dynamic_multi_agent(
            topic="Will quantum computing revolutionize cryptography?",
            perspectives=perspectives,
        )

        print(f"Verdict: {result.verdict.decision}")
        print(f"Reasoning: {result.verdict.reasoning}")

    asyncio.run(main())

## Next Steps

- Create Custom Juries for multi-agent evaluation
- Add Safety Monitors to track all agents
- Learn about Ethical Dilemmas with multiple perspectives