Multi-Agent Orchestration Methods¶

Swarms provides a comprehensive suite of orchestration methods for coordinating multiple AI agents in structured conversations and decision-making processes. These methods enable sophisticated multi-agent interactions like debates, panel discussions, negotiations, and more.

Overview¶

Method	Orchestration Description	Use Case
OneOnOneDebate	Turn-based debates between two agents. Structured debates where two agents alternate turns presenting arguments.	Philosophical discussions, arguments
ExpertPanelDiscussion	Expert panel discussions with a moderator. Multiple experts discuss topics, guided by a moderator.	Professional discussions, expert opinions
RoundTableDiscussion	Round table discussions with multiple participants. Open discussions among several agents, each contributing equally.	Group discussions, brainstorming
InterviewSeries	Structured interviews with follow-up questions. One agent interviews another, with dynamic follow-up questions.	Q&A sessions, information gathering
PeerReviewProcess	Academic peer review processes. Simulated academic review, where agents critique and provide feedback.	Research review, feedback processes
MediationSession	Mediation sessions for conflict resolution. Agents participate in sessions to resolve disputes, often with a mediator.	Dispute resolution, negotiations
BrainstormingSession	Brainstorming sessions for idea generation. Collaborative sessions focused on generating new ideas.	Innovation, problem solving
TrialSimulation	Trial simulations with legal roles. Agents assume legal roles to simulate a courtroom trial.	Legal proceedings, case analysis
CouncilMeeting	Council meetings with voting procedures. Decision-making meetings where agents vote on proposals.	Governance, voting processes
MentorshipSession	Mentorship sessions with feedback loops. One or more agents mentor others, providing feedback and guidance.	Learning, guidance
NegotiationSession	Complex negotiations between parties. Multi-party negotiations to reach agreements or resolve conflicts.	Business deals, agreements

OneOnOneDebate¶

Description¶

Simulates a turn-based debate between two agents for a specified number of loops. Each agent takes turns responding to the other's arguments.

Parameters¶

Parameter	Type	Description	Required	Default
max_loops	int	Number of conversational turns	No	1
agents	List[Agent]	Two agents for debate	Yes	None
img	str	Optional image input	No	None
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes debate between agents

Example¶

Full example: Philosophy Discussion Example

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import OneOnOneDebate

# Create debating agents
agent1 = Agent(name="Philosopher1")
agent2 = Agent(name="Philosopher2")

# Initialize debate
debate = OneOnOneDebate(
    max_loops=3,
    agents=[agent1, agent2]
)

# Run debate
result = debate.run("Is artificial intelligence consciousness possible?")

ExpertPanelDiscussion¶

Description¶

Simulates an expert panel discussion with a moderator guiding the conversation. Multiple experts provide insights on a topic with structured rounds.

Parameters¶

Parameter	Type	Description	Required	Default
max_rounds	int	Number of discussion rounds	No	3
agents	List[Agent]	Expert panel participants	Yes	None
moderator	Agent	Discussion moderator	Yes	None
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes panel discussion

Example¶

Full example: Healthcare Panel Discussion

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import ExpertPanelDiscussion

# Create expert agents
moderator = Agent(name="Moderator")
expert1 = Agent(name="AI_Expert")
expert2 = Agent(name="Ethics_Expert")
expert3 = Agent(name="Neuroscience_Expert")

# Initialize panel
panel = ExpertPanelDiscussion(
    max_rounds=2,
    agents=[expert1, expert2, expert3],
    moderator=moderator
)

# Run panel discussion
result = panel.run("What are the ethical implications of AGI development?")

RoundTableDiscussion¶

Description¶

Simulates a round table where each participant speaks in order, then the cycle repeats. Facilitated discussion with equal participation.

Parameters¶

Parameter	Type	Description	Required	Default
max_cycles	int	Number of speaking cycles	No	2
agents	List[Agent]	Round table participants	Yes	None
facilitator	Agent	Discussion facilitator	Yes	None
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes round table discussion

Example¶

Full example: AI Ethics Debate

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import RoundTableDiscussion

# Create participants
facilitator = Agent(name="Facilitator")
participant1 = Agent(name="Participant1")
participant2 = Agent(name="Participant2")
participant3 = Agent(name="Participant3")

# Initialize round table
roundtable = RoundTableDiscussion(
    max_cycles=2,
    agents=[participant1, participant2, participant3],
    facilitator=facilitator
)

# Run discussion
result = roundtable.run("How can we improve renewable energy adoption?")

InterviewSeries¶

Description¶

Conducts a structured interview with follow-up questions. Systematic Q&A with depth through follow-up questions.

Parameters¶

Parameter	Type	Description	Required	Default
questions	List[str]	Prepared interview questions	No	Default questions
interviewer	Agent	Interviewer agent	Yes	None
interviewee	Agent	Interviewee agent	Yes	None
follow_up_depth	int	Follow-up questions per main question	No	2
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes interview series

Example¶

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import InterviewSeries

# Create agents
interviewer = Agent(name="Interviewer")
interviewee = Agent(name="Expert")

# Prepare questions
questions = [
    "What is your background in AI?",
    "How do you see AI evolving in the next decade?",
    "What are the biggest challenges in AI development?"
]

# Initialize interview
interview = InterviewSeries(
    questions=questions,
    interviewer=interviewer,
    interviewee=interviewee,
    follow_up_depth=2
)

# Run interview
result = interview.run("AI Development and Future Prospects")

PeerReviewProcess¶

Description¶

Simulates academic peer review with multiple reviewers and author responses. Structured feedback and revision process.

Parameters¶

Parameter	Type	Description	Required	Default
reviewers	List[Agent]	Reviewer agents	Yes	None
author	Agent	Author agent	Yes	None
review_rounds	int	Number of review rounds	No	2
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes peer review process

Example¶

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import PeerReviewProcess

# Create agents
author = Agent(name="Author")
reviewer1 = Agent(name="Reviewer1")
reviewer2 = Agent(name="Reviewer2")

# Initialize peer review
review = PeerReviewProcess(
    reviewers=[reviewer1, reviewer2],
    author=author,
    review_rounds=2
)

# Run review process
result = review.run("New Machine Learning Algorithm for Natural Language Processing")

MediationSession¶

Description¶

Simulates a mediation session to resolve conflicts between parties. Facilitated conflict resolution with structured sessions.

Parameters¶

Parameter	Type	Description	Required	Default
parties	List[Agent]	Disputing parties	Yes	None
mediator	Agent	Mediator agent	Yes	None
max_sessions	int	Number of mediation sessions	No	3
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes mediation session

Example¶

Full example: Merger Mediation Session

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import MediationSession

# Create agents
mediator = Agent(name="Mediator")
party1 = Agent(name="Party1")
party2 = Agent(name="Party2")

# Initialize mediation
mediation = MediationSession(
    parties=[party1, party2],
    mediator=mediator,
    max_sessions=3
)

# Run mediation
result = mediation.run("Resolve intellectual property dispute")

BrainstormingSession¶

Description¶

Simulates a brainstorming session where participants build on each other's ideas. Creative idea generation with collaborative building.

Parameters¶

Parameter	Type	Description	Required	Default
participants	List[Agent]	Brainstorming participants	Yes	None
facilitator	Agent	Session facilitator	Yes	None
idea_rounds	int	Number of idea generation rounds	No	3
build_on_ideas	bool	Whether to build on previous ideas	No	True
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes brainstorming session

Example¶

Full example: Pharma Research Brainstorm

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import BrainstormingSession

# Create agents
facilitator = Agent(name="Facilitator")
participant1 = Agent(name="Creative1")
participant2 = Agent(name="Creative2")
participant3 = Agent(name="Creative3")

# Initialize brainstorming
brainstorm = BrainstormingSession(
    participants=[participant1, participant2, participant3],
    facilitator=facilitator,
    idea_rounds=3,
    build_on_ideas=True
)

# Run brainstorming
result = brainstorm.run("Innovative solutions for urban transportation")

TrialSimulation¶

Description¶

Simulates a legal trial with structured phases and roles. Complete legal proceeding simulation with all participants.

Parameters¶

Parameter	Type	Description	Required	Default
prosecution	Agent	Prosecution attorney	Yes	None
defense	Agent	Defense attorney	Yes	None
judge	Agent	Trial judge	Yes	None
witnesses	List[Agent]	Trial witnesses	No	None
phases	List[str]	Trial phases	No	Default phases
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes trial simulation

Example¶

Full example: Medical Malpractice Trial

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import TrialSimulation

# Create agents
judge = Agent(name="Judge")
prosecutor = Agent(name="Prosecutor")
defense = Agent(name="Defense")
witness1 = Agent(name="Witness1")
witness2 = Agent(name="Witness2")

# Initialize trial
trial = TrialSimulation(
    prosecution=prosecutor,
    defense=defense,
    judge=judge,
    witnesses=[witness1, witness2],
    phases=["opening", "testimony", "cross", "closing"]
)

# Run trial
result = trial.run("Patent infringement case")

CouncilMeeting¶

Description¶

Simulates a council meeting with structured discussion and decision-making. Governance process with voting and consensus building.

Parameters¶

Parameter	Type	Description	Required	Default
council_members	List[Agent]	Council participants	Yes	None
chairperson	Agent	Meeting chairperson	Yes	None
voting_rounds	int	Number of voting rounds	No	1
require_consensus	bool	Whether consensus is required	No	False
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes council meeting

Example¶

Full example: Investment Council Meeting

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import CouncilMeeting

# Create agents
chairperson = Agent(name="Chair")
member1 = Agent(name="Member1")
member2 = Agent(name="Member2")
member3 = Agent(name="Member3")

# Initialize council meeting
council = CouncilMeeting(
    council_members=[member1, member2, member3],
    chairperson=chairperson,
    voting_rounds=2,
    require_consensus=True
)

# Run meeting
result = council.run("Vote on new environmental policy")

MentorshipSession¶

Description¶

Simulates a mentorship session with structured learning and feedback. Guided learning process with progress tracking.

Parameters¶

Parameter	Type	Description	Required	Default
mentor	Agent	Mentor agent	Yes	None
mentee	Agent	Mentee agent	Yes	None
session_count	int	Number of sessions	No	3
include_feedback	bool	Whether to include feedback	No	True
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes mentorship session

Example¶

Full example: Startup Mentorship Program

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import MentorshipSession

# Create agents
mentor = Agent(name="Mentor")
mentee = Agent(name="Mentee")

# Initialize mentorship
mentorship = MentorshipSession(
    mentor=mentor,
    mentee=mentee,
    session_count=3,
    include_feedback=True
)

# Run session
result = mentorship.run("Career development in AI research")

NegotiationSession¶

Description¶

Simulates a negotiation with multiple parties working toward agreement. Complex multi-party negotiation with concessions.

Parameters¶

Parameter	Type	Description	Required	Default
parties	List[Agent]	Negotiating parties	Yes	None
mediator	Agent	Negotiation mediator	Yes	None
negotiation_rounds	int	Number of rounds	No	5
include_concessions	bool	Whether to allow concessions	No	True
output_type	str	Format for conversation history	No	"str-all-except-first"

Run Method¶

Method	Parameters	Returns	Description
run	task: str	list	Executes negotiation session

Example¶

Full example: NVIDIA-AMD Executive Negotiation

from swarms.agents import Agent
from swarms.structs.multi_agent_debates import NegotiationSession

# Create agents
mediator = Agent(name="Mediator")
party1 = Agent(name="Company1")
party2 = Agent(name="Company2")

# Initialize negotiation
negotiation = NegotiationSession(
    parties=[party1, party2],
    mediator=mediator,
    negotiation_rounds=4,
    include_concessions=True
)

# Run negotiation
result = negotiation.run("Merger terms negotiation")

Conclusion¶

The multi-agent orchestration methods in Swarms provide powerful frameworks for structuring complex interactions between AI agents. Key benefits include:

Structured Communication: Each method provides a clear framework for organizing multi-agent interactions
Role-Based Interactions: Agents can take on specific roles with defined responsibilities
Flexible Configuration: Customizable parameters for controlling interaction flow
Scalable Architecture: Support for various numbers of participants and interaction rounds
Comprehensive Coverage: Methods for different use cases from debates to negotiations
Professional Output: Consistent formatting and organization of conversation history
Easy Integration: Simple API for incorporating into larger applications