The Enterprise-Grade Production-Ready Multi-Agent Orchestration Framework
π¦ Twitter
β’
π’ Discord
β’
Swarms Website
β’
π Documentation
β’
Swarms Marketplace
## β¨ Features
Swarms delivers a comprehensive, enterprise-grade multi-agent infrastructure platform designed for production-scale deployments and seamless integration with existing systems. Learn more about the swarms feature set
| Category | Features | Benefits |
|----------|----------|-----------|
| π’ **Enterprise Architecture** | β’ Production-Ready Infrastructure
β’ High Availability Systems
β’ Modular Microservices Design
β’ Comprehensive Observability
β’ Backwards Compatibility | β’ 99.9%+ Uptime Guarantee
β’ Reduced Operational Overhead
β’ Seamless Legacy Integration
β’ Enhanced System Monitoring
β’ Risk-Free Migration Path |
| π€ **Multi-Agent Orchestration** | β’ Hierarchical Agent Swarms
β’ Parallel Processing Pipelines
β’ Sequential Workflow Orchestration
β’ Graph-Based Agent Networks
β’ Dynamic Agent Composition
β’ Agent Registry Management | β’ Complex Business Process Automation
β’ Scalable Task Distribution
β’ Flexible Workflow Adaptation
β’ Optimized Resource Utilization
β’ Centralized Agent Governance
β’ Enterprise-Grade Agent Lifecycle Management |
| π **Enterprise Integration** | β’ Multi-Model Provider Support
β’ Custom Agent Development Framework
β’ Extensive Enterprise Tool Library
β’ Multiple Memory Systems
β’ Backwards Compatibility with LangChain, AutoGen, CrewAI
β’ Standardized API Interfaces | β’ Vendor-Agnostic Architecture
β’ Custom Solution Development
β’ Extended Functionality Integration
β’ Enhanced Knowledge Management
β’ Seamless Framework Migration
β’ Reduced Integration Complexity |
| π **Enterprise Scalability** | β’ Concurrent Multi-Agent Processing
β’ Intelligent Resource Management
β’ Load Balancing & Auto-Scaling
β’ Horizontal Scaling Capabilities
β’ Performance Optimization
β’ Capacity Planning Tools | β’ High-Throughput Processing
β’ Cost-Effective Resource Utilization
β’ Elastic Scaling Based on Demand
β’ Linear Performance Scaling
β’ Optimized Response Times
β’ Predictable Growth Planning |
| π οΈ **Developer Experience** | β’ Intuitive Enterprise API
β’ Comprehensive Documentation
β’ Active Enterprise Community
β’ CLI & SDK Tools
β’ IDE Integration Support
β’ Code Generation Templates | β’ Accelerated Development Cycles
β’ Reduced Learning Curve
β’ Expert Community Support
β’ Rapid Deployment Capabilities
β’ Enhanced Developer Productivity
β’ Standardized Development Patterns |
## Install π»
### Using pip
```bash
$ pip3 install -U swarms
```
### Using uv (Recommended)
[uv](https://github.com/astral-sh/uv) is a fast Python package installer and resolver, written in Rust.
```bash
# Install uv
$ curl -LsSf https://astral.sh/uv/install.sh | sh
# Install swarms using uv
$ uv pip install swarms
```
### Using poetry
```bash
# Install poetry if you haven't already
$ curl -sSL https://install.python-poetry.org | python3 -
# Add swarms to your project
$ poetry add swarms
```
### From source
```bash
# Clone the repository
$ git clone https://github.com/kyegomez/swarms.git
$ cd swarms
# Install with pip
$ pip install -e .
```
---
## Environment Configuration
[Learn more about the environment configuration here](https://docs.swarms.world/en/latest/swarms/install/env/)
```
OPENAI_API_KEY=""
WORKSPACE_DIR="agent_workspace"
ANTHROPIC_API_KEY=""
GROQ_API_KEY=""
```
### π€ Your First Agent
An **Agent** is the fundamental building block of a swarmβan autonomous entity powered by an LLM + Tools + Memory. [Learn more Here](https://docs.swarms.world/en/latest/swarms/structs/agent/)
```python
from swarms import Agent
# Initialize a new agent
agent = Agent(
model_name="gpt-4o-mini", # Specify the LLM
max_loops=1, # Set the number of interactions
interactive=True, # Enable interactive mode for real-time feedback
)
# Run the agent with a task
agent.run("What are the key benefits of using a multi-agent system?")
```
### π€ Your First Swarm: Multi-Agent Collaboration
A **Swarm** consists of multiple agents working together. This simple example creates a two-agent workflow for researching and writing a blog post. [Learn More About SequentialWorkflow](https://docs.swarms.world/en/latest/swarms/structs/sequential_workflow/)
```python
from swarms import Agent, SequentialWorkflow
# Agent 1: The Researcher
researcher = Agent(
agent_name="Researcher",
system_prompt="Your job is to research the provided topic and provide a detailed summary.",
model_name="gpt-4o-mini",
)
# Agent 2: The Writer
writer = Agent(
agent_name="Writer",
system_prompt="Your job is to take the research summary and write a beautiful, engaging blog post about it.",
model_name="gpt-4o-mini",
)
# Create a sequential workflow where the researcher's output feeds into the writer's input
workflow = SequentialWorkflow(agents=[researcher, writer])
# Run the workflow on a task
final_post = workflow.run("The history and future of artificial intelligence")
print(final_post)
```
-----
## ποΈ Swarm Architectures for Production Workflows
`swarms` provides a variety of powerful, pre-built multi-agent architectures enabling you to orchestrate agents in various ways. Choose the right structure for your specific problem to build efficient and reliable production systems.
| **Architecture** | **Description** | **Best For** | **Documentation** |
|---|---|---|---|
| **SequentialWorkflow** | Agents execute tasks in a linear chain; one agent's output is the next one's input. | Step-by-step processes like data transformation pipelines, report generation. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/sequential_workflow/) |
| **ConcurrentWorkflow** | Agents run tasks simultaneously for maximum efficiency. | High-throughput tasks like batch processing, parallel data analysis. | [Docs](https://www.google.com/search?q=https://docs.swarms.world/en/latest/swarms/structs/concurrent_workflow/) |
| **AgentRearrange** | Dynamically maps complex relationships (e.g., `a -> b, c`) between agents. | Flexible and adaptive workflows, task distribution, dynamic routing. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/) |
| **GraphWorkflow** | Orchestrates agents as nodes in a Directed Acyclic Graph (DAG). | Complex projects with intricate dependencies, like software builds. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/graph_workflow/) |
| **MixtureOfAgents (MoA)** | Utilizes multiple expert agents in parallel and synthesizes their outputs. | Complex problem-solving, achieving state-of-the-art performance through collaboration. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/moa/) |
| **GroupChat** | Agents collaborate and make decisions through a conversational interface. | Real-time collaborative decision-making, negotiations, brainstorming. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/group_chat/) |
| **ForestSwarm** | Dynamically selects the most suitable agent or tree of agents for a given task. | Task routing, optimizing for expertise, complex decision-making trees. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/forest_swarm/) |
| **SpreadSheetSwarm**| Manages thousands of agents concurrently, tracking tasks and outputs in a structured format. | Massive-scale parallel operations, large-scale data generation and analysis. | [Docs](https://docs.swarms.world/en/latest/swarms/structs/spreadsheet_swarm/) |
-----
### SequentialWorkflow
A `SequentialWorkflow` executes tasks in a strict order, forming a pipeline where each agent builds upon the work of the previous one.
**Description:** Ideal for processes that have clear, ordered steps. This ensures that tasks with dependencies are handled correctly.
```python
from swarms import Agent, SequentialWorkflow
# Initialize agents for a 3-step process
# 1. Generate an idea
idea_generator = Agent(agent_name="IdeaGenerator", system_prompt="Generate a unique startup idea.", model_name="gpt-4o-mini")
# 2. Validate the idea
validator = Agent(agent_name="Validator", system_prompt="Take this startup idea and analyze its market viability.", model_name="gpt-4o-mini")
# 3. Create a pitch
pitch_creator = Agent(agent_name="PitchCreator", system_prompt="Write a 3-sentence elevator pitch for this validated startup idea.", model_name="gpt-4o-mini")
# Create the sequential workflow
workflow = SequentialWorkflow(agents=[idea_generator, validator, pitch_creator])
# Run the workflow
elevator_pitch = workflow.run()
print(elevator_pitch)
```
-----
### ConcurrentWorkflow (with `SpreadSheetSwarm`)
A concurrent workflow runs multiple agents simultaneously. `SpreadSheetSwarm` is a powerful implementation that can manage thousands of concurrent agents and log their outputs to a CSV file.
**Description:** Use this for high-throughput tasks that can be performed in parallel, drastically reducing execution time.
```python
from swarms import Agent, SpreadSheetSwarm
# Define a list of tasks (e.g., social media posts to generate)
platforms = ["Twitter", "LinkedIn", "Instagram"]
# Create an agent for each task
agents = [
Agent(
agent_name=f"{platform}-Marketer",
system_prompt=f"Generate a real estate marketing post for {platform}.",
model_name="gpt-4o-mini",
)
for platform in platforms
]
# Initialize the swarm to run these agents concurrently
swarm = SpreadSheetSwarm(
agents=agents,
autosave_on=True,
save_file_path="marketing_posts.csv",
)
# Run the swarm with a single, shared task description
property_description = "A beautiful 3-bedroom house in sunny California."
swarm.run(task=f"Generate a post about: {property_description}")
# Check marketing_posts.csv for the results!
```
---
### AgentRearrange
Inspired by `einsum`, `AgentRearrange` lets you define complex, non-linear relationships between agents using a simple string-based syntax. [Learn more](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/)
**Description:** Perfect for orchestrating dynamic workflows where agents might work in parallel, sequence, or a combination of both.
```python
from swarms import Agent, AgentRearrange
# Define agents
researcher = Agent(agent_name="researcher", model_name="gpt-4o-mini")
writer = Agent(agent_name="writer", model_name="gpt-4o-mini")
editor = Agent(agent_name="editor", model_name="gpt-4o-mini")
# Define a flow: researcher sends work to both writer and editor simultaneously
# This is a one-to-many relationship
flow = "researcher -> writer, editor"
# Create the rearrangement system
rearrange_system = AgentRearrange(
agents=[researcher, writer, editor],
flow=flow,
)
# Run the system
# The researcher will generate content, and then both the writer and editor
# will process that content in parallel.
outputs = rearrange_system.run("Analyze the impact of AI on modern cinema.")
print(outputs)
```
----
### SwarmRouter: The Universal Swarm Orchestrator
The `SwarmRouter` simplifies building complex workflows by providing a single interface to run any type of swarm. Instead of importing and managing different swarm classes, you can dynamically select the one you need just by changing the `swarm_type` parameter. [Read the full documentation](https://docs.swarms.world/en/latest/swarms/structs/swarm_router/)
This makes your code cleaner and more flexible, allowing you to switch between different multi-agent strategies with ease. Here's a complete example that shows how to define agents and then use `SwarmRouter` to execute the same task using different collaborative strategies.
```python
from swarms import Agent
from swarms.structs.swarm_router import SwarmRouter, SwarmType
# Define a few generic agents
writer = Agent(agent_name="Writer", system_prompt="You are a creative writer.", model_name="gpt-4o-mini")
editor = Agent(agent_name="Editor", system_prompt="You are an expert editor for stories.", model_name="gpt-4o-mini")
reviewer = Agent(agent_name="Reviewer", system_prompt="You are a final reviewer who gives a score.", model_name="gpt-4o-mini")
# The agents and task will be the same for all examples
agents = [writer, editor, reviewer]
task = "Write a short story about a robot who discovers music."
# --- Example 1: SequentialWorkflow ---
# Agents run one after another in a chain: Writer -> Editor -> Reviewer.
print("Running a Sequential Workflow...")
sequential_router = SwarmRouter(swarm_type=SwarmType.SequentialWorkflow, agents=agents)
sequential_output = sequential_router.run(task)
print(f"Final Sequential Output:\n{sequential_output}\n")
# --- Example 2: ConcurrentWorkflow ---
# All agents receive the same initial task and run at the same time.
print("Running a Concurrent Workflow...")
concurrent_router = SwarmRouter(swarm_type=SwarmType.ConcurrentWorkflow, agents=agents)
concurrent_outputs = concurrent_router.run(task)
# This returns a dictionary of each agent's output
for agent_name, output in concurrent_outputs.items():
print(f"Output from {agent_name}:\n{output}\n")
# --- Example 3: MixtureOfAgents ---
# All agents run in parallel, and a special 'aggregator' agent synthesizes their outputs.
print("Running a Mixture of Agents Workflow...")
aggregator = Agent(
agent_name="Aggregator",
system_prompt="Combine the story, edits, and review into a final document.",
model_name="gpt-4o-mini"
)
moa_router = SwarmRouter(
swarm_type=SwarmType.MixtureOfAgents,
agents=agents,
aggregator_agent=aggregator, # MoA requires an aggregator
)
aggregated_output = moa_router.run(task)
print(f"Final Aggregated Output:\n{aggregated_output}\n")
```
The `SwarmRouter` is a powerful tool for simplifying multi-agent orchestration. It provides a consistent and flexible way to deploy different collaborative strategies, allowing you to build more sophisticated applications with less code.
-------
### MixtureOfAgents (MoA)
The `MixtureOfAgents` architecture processes tasks by feeding them to multiple "expert" agents in parallel. Their diverse outputs are then synthesized by an aggregator agent to produce a final, high-quality result. [Learn more here](https://docs.swarms.world/en/latest/swarms/examples/moa_example/)
```python
from swarms import Agent, MixtureOfAgents
# Define expert agents
financial_analyst = Agent(agent_name="FinancialAnalyst", system_prompt="Analyze financial data.", model_name="gpt-4o-mini")
market_analyst = Agent(agent_name="MarketAnalyst", system_prompt="Analyze market trends.", model_name="gpt-4o-mini")
risk_analyst = Agent(agent_name="RiskAnalyst", system_prompt="Analyze investment risks.", model_name="gpt-4o-mini")
# Define the aggregator agent
aggregator = Agent(
agent_name="InvestmentAdvisor",
system_prompt="Synthesize the financial, market, and risk analyses to provide a final investment recommendation.",
model_name="gpt-4o-mini"
)
# Create the MoA swarm
moa_swarm = MixtureOfAgents(
agents=[financial_analyst, market_analyst, risk_analyst],
aggregator_agent=aggregator,
)
# Run the swarm
recommendation = moa_swarm.run("Should we invest in NVIDIA stock right now?")
print(recommendation)
```
----
### GroupChat
`GroupChat` creates a conversational environment where multiple agents can interact, discuss, and collaboratively solve a problem. You can define the speaking order or let it be determined dynamically.
**Description:** Ideal for tasks that benefit from debate and multi-perspective reasoning, such as contract negotiation, brainstorming, or complex decision-making.
```python
from swarms import Agent, GroupChat
# Define agents for a debate
tech_optimist = Agent(agent_name="TechOptimist", system_prompt="Argue for the benefits of AI in society.", model_name="gpt-4o-mini")
tech_critic = Agent(agent_name="TechCritic", system_prompt="Argue against the unchecked advancement of AI.", model_name="gpt-4o-mini")
# Create the group chat
chat = GroupChat(
agents=[tech_optimist, tech_critic],
max_loops=4, # Limit the number of turns in the conversation
)
# Run the chat with an initial topic
conversation_history = chat.run(
"Let's discuss the societal impact of artificial intelligence."
)
# Print the full conversation
for message in conversation_history:
print(f"[{message['agent_name']}]: {message['content']}")
```
---
## Documentation
Documentation is located here at: [docs.swarms.world](https://docs.swarms.world)
---
## Guides and Walkthroughs
Here are quick reference guides on how to get started with swarms.
| Section | Description | Links |
|----------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
| Installation | Complete setup guide for Swarms in your environment | [Installation](https://docs.swarms.world/en/latest/swarms/install/install/) |
| Quickstart | Get up and running with your first swarm in minutes | [Get Started](https://docs.swarms.world/en/latest/swarms/install/quickstart/) |
| Agent Internal Mechanisms | Deep dive into how agents work internally | [Agent Architecture](https://docs.swarms.world/en/latest/swarms/framework/agents_explained/) |
| Agent API | Complete reference for the Agent class and its methods | [Agent API](https://docs.swarms.world/en/latest/swarms/structs/agent/) |
| Integrating External Agents | Connect Swarms with other AI frameworks like Griptape and Autogen | [Integrating External APIs](https://docs.swarms.world/en/latest/swarms/agents/external_party_agents/) |
| Creating Agents from YAML | Define and configure agents using YAML configuration files | [Creating Agents from YAML](https://docs.swarms.world/en/latest/swarms/agents/create_agents_yaml/) |
| Why You Need Swarms | Understanding the benefits of multi-agent collaboration | [Why Multi-Agent Collaboration is Necessary](https://docs.swarms.world/en/latest/swarms/concept/why/) |
| Swarm Architectures Analysis | Comprehensive analysis of different swarm patterns and architectures | [Swarm Architectures](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/) |
| Choosing the Right Swarm | Guide to selecting the optimal swarm architecture for your specific business needs | [Business Problem Guide](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/) |
| AgentRearrange Docs | Documentation for dynamic agent rearrangement and workflow optimization | [AgentRearrange API](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/) |
---
## π«Ά Contribute to Swarms
Swarms is built by the community, for the community. We believe that collaborative development is the key to pushing the boundaries of what's possible with multi-agent AI. Your contributions are not only welcomeβthey are essential to our mission. [Learn more about why you should contribute to swarms](https://docs.swarms.world/en/latest/contributors/main/)
### Why Contribute?
By joining us, you have the opportunity to:
* π **Work on the Frontier of agents:** Shape the future of autonomous agent technology and help build a production-grade, open-source framework.
* π€ **Join a Vibrant Community:** Collaborate with a passionate and growing group of agent developers, researchers, and AI enthusiasts.
* π οΈ **Make a Tangible Impact:** Whether you're fixing a bug, adding a new feature, or improving documentation, your work will be used in real-world applications.
* π **Learn and Grow:** Gain hands-on experience with advanced AI concepts and strengthen your software engineering skills.
Discover more about our mission and the benefits of becoming a contributor in our official [**Contributor's Guide**](https://docs.swarms.world/en/latest/contributors/main/).
### How to Get Started
We've made it easy to start contributing. Here's how you can help:
1. **Find an Issue to Tackle:** The best way to begin is by visiting our [**contributing project board**](https://github.com/users/kyegomez/projects/1). Look for issues tagged with `good first issue`βthese are specifically selected for new contributors.
2. **Report a Bug or Request a Feature:** Have a new idea or found something that isn't working right? We'd love to hear from you. Please [**file a Bug Report or Feature Request**](https://github.com/kyegomez/swarms/issues) on our GitHub Issues page.
3. **Understand Our Workflow and Standards:** Before submitting your work, please review our complete [**Contribution Guidelines**](https://github.com/kyegomez/swarms/blob/master/CONTRIBUTING.md). To help maintain code quality, we also encourage you to read our guide on [**Code Cleanliness**](https://docs.swarms.world/en/latest/swarms/framework/code_cleanliness/).
4. **Join the Discussion:** To participate in roadmap discussions and connect with other developers, join our community on [**Discord**](https://discord.gg/jM3Z6M9uMq).
### β¨ Our Valued Contributors
Thank you for contributing to swarms. Your work is extremely appreciated and recognized.
-----
## Connect With Us
Join our community of agent engineers and researchers for technical support, cutting-edge updates, and exclusive access to world-class agent engineering insights!
| Platform | Description | Link |
|----------|-------------|------|
| π Documentation | Official documentation and guides | [docs.swarms.world](https://docs.swarms.world) |
| π Blog | Latest updates and technical articles | [Medium](https://medium.com/@kyeg) |
| π¬ Discord | Live chat and community support | [Join Discord](https://discord.gg/jM3Z6M9uMq) |
| π¦ Twitter | Latest news and announcements | [@kyegomez](https://twitter.com/kyegomez) |
| π₯ LinkedIn | Professional network and updates | [The Swarm Corporation](https://www.linkedin.com/company/the-swarm-corporation) |
| πΊ YouTube | Tutorials and demos | [Swarms Channel](https://www.youtube.com/channel/UC9yXyitkbU_WSy7bd_41SqQ) |
| π« Events | Join our community events | [Sign up here](https://lu.ma/5p2jnc2v) |
| π Onboarding Session | Get onboarded with Kye Gomez, creator and lead maintainer of Swarms | [Book Session](https://cal.com/swarms/swarms-onboarding-session) |
------
## Citation
If you use **swarms** in your research, please cite the project by referencing the metadata in [CITATION.cff](./CITATION.cff).
```bibtex
@misc{SWARMS_2022,
author = {Gomez, Kye and Pliny and More, Harshal and Swarms Community},
title = {{Swarms: Production-Grade Multi-Agent Infrastructure Platform}},
year = {2022},
howpublished = {\url{https://github.com/kyegomez/swarms}},
note = {Documentation available at \url{https://docs.swarms.world}},
version = {latest}
}
```
# License
APACHE
