MajorityVoting

Overview

The MajorityVoting module provides a sophisticated multi-loop consensus building system for agents. Unlike simple majority voting, this system enables iterative consensus building where agents can refine their responses across multiple loops, with each subsequent loop considering the previous consensus. This approach leads to more robust and well-reasoned final decisions by leveraging the collective intelligence of multiple specialized agents.

Installation

pip install -U swarms

Architecture

Key Concepts

Multi-Loop Consensus Building: An iterative process where agents can refine their responses across multiple loops, with each loop building upon the previous consensus.
Agents: Specialized entities (e.g., models, algorithms) that provide expert responses to tasks or queries.
Consensus Agent: An automatically created agent that analyzes and synthesizes responses from all agents to determine the final consensus.
Conversation History: A comprehensive record of all agent interactions, responses, and consensus building across all loops.
Concurrent Execution: Agents run simultaneously for improved performance and efficiency.

Attributes

Optional[str]

default:"None"

Unique identifier for the majority voting system. When omitted, one is generated as majority-voting-<32 hex characters>.

str

default:"MajorityVoting"

Name of the majority voting system.

str

default:"A multi-loop majority voting system for agents"

Description of the system.

List[Agent]

required

A list of agents to be used in the majority voting system.

bool

default:"False"

When True, each run writes the conversation to conversation_history.json in a workspace directory, {WORKSPACE_DIR}/swarms/MajorityVoting/{name}-{timestamp}/. The directory path is available as swarm_workspace_dir.

bool

default:"False"

Whether to enable verbose logging.

int

default:"1"

Maximum number of consensus building loops. Must be greater than 0.

OutputType

default:"dict"

Output format passed to history_output_formatter, for example "dict", "list", "str", "json", or "final". "dict" returns the message list, including the task.

str

default:"CONSENSUS_AGENT_PROMPT"

System prompt for the consensus agent.

str

default:"Consensus-Agent"

Name for the automatically created consensus agent.

str

Description for the consensus agent.

str

default:"gpt-5.4"

Model name for the consensus agent.

dict

default:"{}"

Additional keyword arguments passed to the consensus agent’s Agent constructor.

The constructor validates the configuration and raises ValueError if agents is empty or None, or if max_loops is 0 or less.

Methods

run()

Executes the multi-loop majority voting system for a single task and returns the consensus result.

def run(self, task: str, streaming_callback: Optional[Callable[[str, str, bool], None]] = None, *args, **kwargs) -> Any

Parameters:

task (str): The task or question to be analyzed by the agent panel
streaming_callback (Optional[Callable[[str, str, bool], None]]): Optional callback invoked as (agent_name, chunk, is_final) while the consensus agent streams its response. Only the consensus agent’s output is streamed, and is_final is always False.
*args, **kwargs: Accepted for compatibility and ignored. They are not forwarded to the agents.

Returns: The conversation formatted according to output_type Process Flow:

Starts a fresh conversation and adds the task to it, so a reused instance never carries an earlier task’s votes
For each loop (up to max_loops):
- Runs all voters concurrently. Each voter receives the shared conversation as typed chat turns: the task as a user turn, its own earlier answers as assistant turns, and peers’ answers and earlier consensus as user turns labelled with the speaker’s name
- Records each voter’s final answer (not its whole transcript) under the voter’s name. A voter that raises is recorded with the exception in place of an answer
- Runs the consensus agent on the same typed history and records its answer
Saves the conversation to the workspace when autosave=True
Returns the conversation in the specified output format

batch_run()

Executes the majority voting system for multiple tasks sequentially. Each task starts from a fresh conversation.

def batch_run(self, tasks: List[str], *args, **kwargs) -> List[Any]

Parameters:

tasks (List[str]): List of tasks or questions to be processed
*args (Any): Variable length argument list passed to each task execution
**kwargs (Any): Arbitrary keyword arguments passed to each task execution

Returns: List of consensus results, one for each input task

run_concurrently()

Executes the majority voting system for multiple tasks concurrently in a thread pool. Each task runs on its own shallow copy of the instance, so the tasks never share a conversation. The copies share the same voter and consensus agents.

def run_concurrently(self, tasks: List[str], *args, **kwargs) -> Union[List[Any], Dict[Any, Any]]

Parameters:

tasks (List[str]): List of tasks or questions to be processed
max_workers (int, keyword): Number of threads. Defaults to os.cpu_count()
*args, **kwargs: Forwarded to each task’s run call

Returns: List of consensus results in input order, so element i is the vote for tasks[i]

reliability_check()

Performs validation checks on the majority voting system configuration.

def reliability_check(self) -> None

Raises:

ValueError: If agents list is empty or None
ValueError: If max_loops is less than or equal to 0

Consensus Agent

The MajorityVoting system automatically creates a specialized consensus agent that analyzes and synthesizes responses from all participating agents. This consensus agent:

Comprehensively evaluates each agent’s response across accuracy, depth of analysis, relevance, clarity, and unique perspectives
Performs comparative analysis by identifying overlapping themes, divergent viewpoints, and strengths/weaknesses
Builds consensus by identifying the most effective responses and synthesizing best elements
Delivers actionable results that are fair, balanced, evidence-based, and well-supported

The consensus agent can be customized through the constructor parameters:

consensus_agent_prompt: Custom system prompt
consensus_agent_name: Name for the agent
consensus_agent_description: Description
consensus_agent_model_name: Model to use
additional_consensus_agent_kwargs: Additional configuration

Usage Examples

Financial Analysis with Specialized Agents

from swarms import Agent, MajorityVoting

# Technical Analysis Agent
TECHNICAL_ANALYSIS_PROMPT = """
You are a Quantitative Technical Analysis Specialist with deep expertise in
market chart patterns, technical indicators, and algorithmic trading signals.
Focus on price action, volume analysis, and statistical patterns.
Provide specific price levels, timeframes, and probability assessments.
Include risk management parameters (stop losses, take profits, position sizing).
"""

# Fundamental Analysis Agent
FUNDAMENTAL_ANALYSIS_PROMPT = """
You are a Quantitative Fundamental Analysis Specialist with expertise in
financial statement analysis, valuation models, and company performance metrics.
Focus on intrinsic value, financial health, and long-term investment potential.
Calculate and interpret key financial ratios and metrics.
"""

# Risk Management Agent
RISK_MANAGEMENT_PROMPT = """
You are a Quantitative Risk Management Specialist with expertise in portfolio
optimization, risk metrics, and hedging strategies. Focus on risk-adjusted
returns, diversification, and capital preservation.
Calculate comprehensive risk metrics and performance ratios.
"""

# Initialize specialized agents
technical_agent = Agent(
    agent_name="Technical-Analysis-Quant",
    system_prompt=TECHNICAL_ANALYSIS_PROMPT,
    max_loops=1,
    model_name="gpt-5.4",
)

fundamental_agent = Agent(
    agent_name="Fundamental-Analysis-Quant",
    system_prompt=FUNDAMENTAL_ANALYSIS_PROMPT,
    max_loops=1,
    model_name="gpt-5.4",
)

risk_agent = Agent(
    agent_name="Risk-Management-Quant",
    system_prompt=RISK_MANAGEMENT_PROMPT,
    max_loops=1,
    model_name="gpt-5.4",
)

# Create the majority voting swarm
swarm = MajorityVoting(
    name="Quant-Analysis-Swarm",
    description="Analysis of current market conditions with investment recommendations.",
    agents=[technical_agent, fundamental_agent, risk_agent],
)

# Run the analysis
result = swarm.run(
    "Analyze the current market conditions and provide investment recommendations "
    "for a $40k portfolio. Focus on AI and technology sectors with emphasis on "
    "risk management and diversification."
)

print("Quant Analysis Results:")
print(result)

Investment Analysis with Consensus Agent

from swarms import Agent, MajorityVoting

# Initialize multiple specialized agents
agents = [
    Agent(
        agent_name="Market-Analysis-Agent",
        agent_description="Market trend analyst",
        system_prompt="You are a market analyst specializing in identifying growth opportunities and market trends.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Risk-Assessment-Agent",
        agent_description="Risk analysis expert",
        system_prompt="You are a risk assessment expert focused on evaluating investment risks and volatility.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Portfolio-Strategy-Agent",
        agent_description="Portfolio optimization specialist",
        system_prompt="You are a portfolio strategist focused on diversification and long-term growth strategies.",
        max_loops=1,
        model_name="gpt-5.4"
    )
]

# Create majority voting system (consensus agent is automatically created)
investment_system = MajorityVoting(
    name="Investment-Analysis-System",
    description="Multi-agent investment analysis with consensus evaluation",
    agents=agents,
    verbose=True,
    output_type="dict"
)

# Execute investment analysis
result = investment_system.run(
    task="""Analyze the following investment scenario and provide recommendations:
    - Budget: $50,000
    - Risk tolerance: Moderate
    - Time horizon: 5-7 years
    - Focus areas: Technology, Healthcare, Renewable Energy
    Provide specific ETF/index fund recommendations with allocation percentages."""
)

print("Investment Analysis Results:")
print(result)

Content Creation with Batch Processing

from swarms import Agent, MajorityVoting

# Initialize content creation agents with different styles
content_agents = [
    Agent(
        agent_name="Creative-Writer",
        system_prompt="You are a creative writer who produces engaging, story-driven content with vivid descriptions.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Technical-Writer",
        system_prompt="You are a technical writer who focuses on clarity, accuracy, and structured information.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="SEO-Optimized-Writer",
        system_prompt="You are an SEO specialist who creates content optimized for search engines while maintaining quality.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Conversational-Writer",
        system_prompt="You are a conversational writer who creates relatable, engaging content that connects with readers.",
        max_loops=1,
        model_name="gpt-5.4"
    )
]

# Create majority voting system
content_system = MajorityVoting(
    name="Content-Creation-System",
    description="Multi-style content creation with majority voting",
    agents=content_agents,
    verbose=True,
    output_type="str"
)

# Define multiple content tasks
content_tasks = [
    "Write a blog post about the benefits of renewable energy adoption",
    "Create social media content for a new fitness app launch",
    "Develop a product description for eco-friendly water bottles",
    "Write an email newsletter about artificial intelligence trends"
]

# Execute batch processing
batch_results = content_system.batch_run(content_tasks)

print("Batch Content Creation Results:")
for i, result in enumerate(batch_results, 1):
    print(f"\nTask {i} Result:")
    print(result[:500] + "..." if len(str(result)) > 500 else result)

Research Analysis with Concurrent Processing

from swarms import Agent, MajorityVoting

# Initialize research agents with different methodologies
research_agents = [
    Agent(
        agent_name="Quantitative-Researcher",
        system_prompt="You are a quantitative researcher who analyzes data, statistics, and numerical evidence.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Qualitative-Researcher",
        system_prompt="You are a qualitative researcher who focuses on patterns, themes, and contextual understanding.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Literature-Review-Specialist",
        system_prompt="You are a literature review specialist who synthesizes existing research and identifies knowledge gaps.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Methodology-Expert",
        system_prompt="You are a methodology expert who evaluates research design, validity, and reliability.",
        max_loops=1,
        model_name="gpt-5.4"
    ),
    Agent(
        agent_name="Ethics-Reviewer",
        system_prompt="You are an ethics reviewer who ensures research practices are responsible and unbiased.",
        max_loops=1,
        model_name="gpt-5.4"
    )
]

# Create majority voting system for research
research_system = MajorityVoting(
    name="Research-Analysis-System",
    description="Concurrent multi-perspective research analysis",
    agents=research_agents,
    verbose=True,
    output_type="list"
)

# Define research questions for concurrent analysis
research_questions = [
    "What are the environmental impacts of electric vehicle adoption?",
    "How does remote work affect employee productivity and well-being?",
    "What are the economic implications of universal basic income?",
    "How can AI be used to improve healthcare outcomes?",
    "What are the social effects of social media on mental health?"
]

# Execute concurrent research analysis
concurrent_results = research_system.run_concurrently(research_questions)

print("Concurrent Research Analysis Results:")
print(f"Total questions analyzed: {len(concurrent_results)}")
for i, result in enumerate(concurrent_results, 1):
    print(f"\nResearch Question {i}:")
    print(f"Result: {str(result)[:300]}...")

Majority Voting with Custom Streaming

The callback receives the consensus agent’s output as it streams. Voters are not streamed.

from swarms import Agent, MajorityVoting


def streaming_callback(agent_name: str, chunk: str, is_final: bool):
    print(chunk, end="", flush=True)


# Each voter needs its own Agent instance and a unique name.
voters = [
    Agent(
        agent_name=f"Financial-Analyst-{i}",
        agent_description="Personal finance advisor agent",
        system_prompt="You are a personal finance advisor focused on ETFs and index funds.",
        max_loops=1,
        model_name="gpt-5.4",
    )
    for i in range(3)
]

swarm = MajorityVoting(agents=voters)

swarm.run(
    "Create a markdown table of high-growth AI investment opportunities "
    "for a $40k budget across ETFs and index funds.",
    streaming_callback=streaming_callback,
)
print()

Usage Patterns

Single Task Analysis

result = swarm.run("What are the key risks in the current market?")

To change sampling settings, set them on each voter Agent or pass them to the consensus agent through additional_consensus_agent_kwargs. run ignores extra keyword arguments.

Batch Processing

# Process multiple sectors
sectors = ["Technology", "Healthcare", "Energy", "Finance"]
tasks = [f"Analyze {sector} sector opportunities" for sector in sectors]
results = swarm.batch_run(tasks)

Concurrent Processing

# Process multiple research questions concurrently
questions = [
    "What are the environmental impacts of AI?",
    "How will quantum computing affect cryptography?",
    "What are the economic implications of space exploration?"
]
results = swarm.run_concurrently(questions)

Performance Considerations

Consideration	Description
Sequential Processing (`batch_run`)	Tasks are processed one after another, not in parallel
Concurrent Processing (`run_concurrently`)	Tasks run in a thread pool, one thread per CPU core by default (`max_workers`)
Independent Conversation History	Each task starts from its own fresh conversation
Shared Agents	Concurrent tasks share the same voter agents, so each voter may serve several tasks at once
Memory Usage	Scales with the number of tasks and the length of each conversation

Source Code

View the source code on GitHub

Core Classes

Multi-Agent Harnesses

Tools & Utilities

Deployment

MajorityVoting

Overview

Installation

Architecture

Key Concepts

Attributes

Methods

run()

batch_run()

run_concurrently()

reliability_check()

Consensus Agent

Usage Examples

Financial Analysis with Specialized Agents

Investment Analysis with Consensus Agent

Content Creation with Batch Processing

Research Analysis with Concurrent Processing

Majority Voting with Custom Streaming

Usage Patterns

Single Task Analysis

Batch Processing

Concurrent Processing

Performance Considerations

Source Code

​Overview

​Installation

​Architecture

​Key Concepts

​Attributes

​Methods

​run()

​batch_run()

​run_concurrently()

​reliability_check()

​Consensus Agent

​Usage Examples

​Financial Analysis with Specialized Agents

​Investment Analysis with Consensus Agent

​Content Creation with Batch Processing

​Research Analysis with Concurrent Processing

​Majority Voting with Custom Streaming

​Usage Patterns

​Single Task Analysis

​Batch Processing

​Concurrent Processing

​Performance Considerations

​Source Code

Overview

Installation

Architecture

Key Concepts

Attributes

Methods

run()

batch_run()

run_concurrently()

reliability_check()

Consensus Agent

Usage Examples

Financial Analysis with Specialized Agents

Investment Analysis with Consensus Agent

Content Creation with Batch Processing

Research Analysis with Concurrent Processing

Majority Voting with Custom Streaming

Usage Patterns

Single Task Analysis

Batch Processing

Concurrent Processing

Performance Considerations

Source Code