- Home
- Skills
- Agents & Orchestration
- Multi Agent Debate Coordinator
Works with the AI Agents you already use
Multi Agent Debate Coordinator
Orchestrate adversarial LLM debate and consensus protocols to reduce hallucinations and verify complex conclusions.
$15
Multi Agent Debate Coordinator
Example session with this skill installed
I need a Python controller to run a three-agent debate about the feasibility of a new microservices migration plan. Include a proponent, a skeptic, and a judge.
- Read your context and instructions
- Compiled the multi agent debate
I have generated a structured multi-agent debate controller in Python. This script defines the Proponent, Skeptic, and Judge personas and manages the three-round synchronous orchestration flow.
Multi-Agent Debate Controller (Python)
import os
from typing import List, Dict
class DebateCoordinator:
def __init__(self):
self.rounds = ["Claims", "Cross-Examination", "Synthesis"]
self.agents = {
"proponent": "Focus on scalability and velocity benefits of microservices.",
"skeptic": "Focus on operational complexity and distributed system failures.",
"judge": "Evaluate empirical consistency and logical validity."
}
self.history: List[Dict] = []
def run_debate(self, topic: str):
print(f"Starting debate on: {topic}")
# Round 1: Claims
self._execute_round("Claims", ["proponent", "skeptic"])
# Round 2: Cross-Examination
self._execute_round("Cross-Examination", ["proponent", "skeptic"])
# Round 3: Synthesis & Judgment
conclusion = self._evaluate_consensus()
return conclusion
def _execute_round(self, round_name: str, active_agents: List[str]):
for agent in active_agents:
# Logic for calling LLM with agent-specific system prompt
prompt = self.agents[agent]
print(f"[{round_name}] {agent.capitalize()} is processing...")
# Placeholder for LLM integration
self.history.append({"round": round_name, "agent": agent, "content": "..."})
def _evaluate_consensus(self) -> str:
print("[Judge] Finalizing synthesis...")
# Logic for Judge agent to verify claims against stopping criteria
return "Consensus Reached: Migration feasible with localized state management."
if __name__ == "__main__":
coordinator = DebateCoordinator()
result = coordinator.run_debate("Microservices Migration Plan v1")
print(f"Final Result: {result}")
Next steps
- Insert your LLM provider API calls into the
_execute_roundhelper method. - Define specific stopping criteria in the
_evaluate_consensusmethod to handle stubborn adversarial loops. - Reference
references/technical-guide.mdfor advanced state management patterns.
Connects securely to your tools. The creator never sees your data.
About this skill
Standard LLM prompting often results in confident hallucinations or narrow reasoning bias. This skill implements structured adversarial protocols to force multiple agent personas into a rigorous debate, verifying complex conclusions before they reach your application.
What it does
- Persona Configuration defines distinct agents with adversarial viewpoints such as Proponent, Skeptic, and Fact-Checker.
- Synchronous Orchestration executes structured rounds covering initial claims, cross-examination, and final synthesis.
- Automated Judging implements a neutral Judge Agent to evaluate logical validity and empirical consistency across turns.
- Convergence Control establishes strict stopping criteria to reach consensus and prevent infinite argumentation loops.
How it works
- Agent Setup: Define the specific personas and adversarial roles required for the problem domain.
- Debate Execution: Run the multi-turn communication flow between the configured agents.
- Logic Verification: The Judge Agent reviews the interaction history for fallacies or inconsistent data.
- Synthesis: Generate a final verified conclusion based on the points that survived the cross-examination.
Frameworks & tools
The skill generates orchestration controllers compatible with Python and TypeScript. It follows architectural patterns suitable for multi-agent swarms and MCP servers.
Why this beats prompting it yourself
Manual prompting for debate often leads to "echo chambers" where agents simply agree with each other. This skill provides a deterministic state machine for cross-examination, ensuring skepticism is hard-coded into the workflow to catch errors that single-agent chains miss.
Use cases
- Fact Verification validating high-stakes technical or legal claims against conflicting data sources.
- Strategic Planning stress-testing business proposals by simulating aggressive skeptical counter-arguments.
- Code Review orchestrating a "Security Auditor" vs "Feature Developer" debate to find edge cases.
Known limitations
The skill outputs orchestration logic but does not provide the underlying LLM API access. Performance depends on the reasoning capabilities of the base models used in the swarm.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.
Requires Python or TypeScript environment. Limited to project workspace. Logic only; does not include LLM API credits.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 2 days ago
- Software
- Zero global installationorelevated privileges required.
File System Read/Write (strictly scoped to current project workspace `./`).
Permissions
Target Use Cases: - Orchestrate a multi-agent debate protocol in Python. - Build an adversarial consensus system between AI agents. - Implement a Judge agent evaluating debate arguments.