The Enterprise-Grade Multi-Agent Orchestration Framework. Website: https://swarms.ai

Swarms Website • Documentation • Swarms Marketplace • 中文

## Overview > > Swarms, The Enterprise-Grade Production-Ready Multi-Agent Orchestration Framework Swarms is the most reliable, scalable, and adaptive multi-agent orchestration framework available today. We provide a comprehensive suite of production-ready, prebuilt multi-agent architectures, including sequential, concurrent, and hierarchical systems. Additionally, Swarms offers backward compatibility with leading agent frameworks and interoperability with protocols such as MCP, x402, skills, and much more. ## 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 $ uv pip install swarms ``` ### Using poetry ```bash $ poetry add swarms ``` ### From source ```bash # Clone the repository $ git clone https://github.com/kyegomez/swarms.git $ cd swarms $ pip install -r requirements.txt ``` --- ## Environment Configuration [Learn more about the environment configuration here](https://docs.swarms.world/environment-setup) ``` 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/api/agent) ```python from swarms import Agent # Initialize a new agent agent = Agent( model_name="gpt-5.4", # Specify the LLM max_loops="auto", # Set the number of interactions interactive=True, # Enable interactive mode for real-time feedback temperature=None, ) # Run the agent with a task agent.run("What are the key benefits of using a multi-agent system?") ``` ### Autonomous Agent with `max_loops="auto"` Setting `max_loops="auto"` lets the agent decide for itself when the task is complete — it keeps reasoning and acting until it reaches a stopping condition, rather than halting after a fixed number of iterations. This is the recommended mode for open-ended, multi-step tasks where the number of steps isn't known in advance. ```python from swarms import Agent agent = Agent( agent_name="Autonomous-Research-Agent", agent_description="An autonomous agent that conducts multi-step research independently.", system_prompt=( "You are an autonomous research agent. Break down complex tasks into steps, " "execute each step thoroughly, and signal completion only when the full task is done." ), model_name="gpt-5.4", max_loops="auto", # Agent decides when it's done — no fixed iteration cap autosave=True, verbose=True, ) # The agent will keep looping — planning, executing, and reflecting — until it # determines the task is fully complete. result = agent.run( "Research the current state of quantum computing, identify the top three " "hardware approaches, and summarize the key challenges each faces." ) print(result) ``` **When to use `max_loops="auto"`:** - Open-ended research or analysis tasks - Tasks that require iterative refinement (e.g., write → review → revise) - Any workflow where the number of steps depends on intermediate results **When to use a fixed `max_loops` value:** - Latency-sensitive or cost-sensitive production pipelines - Tasks with a well-defined, bounded number of steps ## MCP Integration The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets agents easily access external tools and data by pointing to an MCP server URL, which automatically provides tools to the agent as needed. Agents become MCP-enabled by setting `mcp_url` or `mcp_urls`, and can use tools from one or many servers with no manual configuration. Free and public MCP servers like [DeepWiki](https://mcp.deepwiki.com/mcp) work out of the box, offering immediate access to useful agent tools. ```python from swarms import Agent agent = Agent( agent_name="MCP-Agent", model_name="claude-sonnet-5", mcp_url="https://mcp.deepwiki.com/mcp", max_loops=1, temperature=None, max_tokens=16_000, reasoning_effort=None, ) print( agent.run( "Use your tools to explain what the kyegomez/swarms repository does." ) ) ``` ### Serve an Agent as an MCP Server The reverse direction works too. `MCPDeployer` turns any agent, or any swarm, into an MCP server that other agents and MCP hosts can call, with an auth layer in front of it. Each target becomes one tool; pass a list or a dict to serve several from one server. [See the MCPDeployer examples](examples/mcp/mcp_deployer/) ```python from swarms import Agent, MCPDeployer researcher = Agent( agent_name="Researcher", agent_description="Answers research questions with a short summary.", model_name="gpt-5.4", max_loops=1, ) # Serves http://127.0.0.1:8000/mcp as the tool "researcher". MCPDeployer(researcher, api_keys=["sk-local-dev"], port=8000).run() ``` Any other agent can then use it by pointing at the URL with the key: ```python from swarms import Agent from swarms.schemas.mcp_schemas import MCPConnection client = Agent( agent_name="Client", model_name="gpt-5.4", mcp_url=MCPConnection(url="http://127.0.0.1:8000/mcp", api_key="sk-local-dev"), max_loops=2, ) client.run("Use the researcher tool to summarise the state of solid-state batteries.") ``` Auth can be static API keys, your own `auth` callable that reads the request headers, or an `mcp` `TokenVerifier` with required scopes. A server with no auth configured refuses to start unless you pass `allow_anonymous=True`. Transports: streamable HTTP (default), SSE, or stdio for desktop MCP hosts. | Example | What it shows | |---|---| | [single_agent_api_key.py](examples/mcp/mcp_deployer/single_agent_api_key.py) | One agent behind a static key | | [multiple_agents_one_server.py](examples/mcp/mcp_deployer/multiple_agents_one_server.py) | Two agents, a `SequentialWorkflow` and two functions as separate tools | | [custom_auth_per_tenant.py](examples/mcp/mcp_deployer/custom_auth_per_tenant.py) | Your own async auth callable reading an `x-tenant` header | | [token_verifier_with_scopes.py](examples/mcp/mcp_deployer/token_verifier_with_scopes.py) | `TokenVerifier` with required scopes | | [background_server_and_client_agent.py](examples/mcp/mcp_deployer/background_server_and_client_agent.py) | Serve, call from a second agent, and stop, all in one process | | [All MCPDeployer examples](examples/mcp/mcp_deployer/) | Every target kind, auth mode and transport | ### 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/api/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-5.4", ) # 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-5.4", ) # 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) ``` ----- ## Available Multi-Agent Architectures `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** | |---|---|---| | **[SequentialWorkflow](https://docs.swarms.world/api/sequential-workflow)** | Agents execute tasks in a linear chain; the output of one agent becomes the input for the next. | Step-by-step processes such as data transformation pipelines and report generation. | | **[ConcurrentWorkflow](https://docs.swarms.world/api/concurrent-workflow)** | Agents run tasks simultaneously for maximum efficiency. | High-throughput tasks such as batch processing and parallel data analysis. | | **[AgentRearrange](https://docs.swarms.world/api/agent-rearrange)** | Dynamically maps complex relationships (e.g., `a -> b, c`) between agents. | Flexible and adaptive workflows, task distribution, and dynamic routing. | | **[GraphWorkflow](https://docs.swarms.world/api/graph-workflow)** | Orchestrates agents as nodes in a Directed Acyclic Graph (DAG). | Complex projects with intricate dependencies, such as software builds. | | **[MixtureOfAgents (MoA)](https://docs.swarms.world/api/mixture-of-agents)** | Utilizes multiple expert agents in parallel and synthesizes their outputs. | Complex problem-solving and achieving state-of-the-art performance through collaboration. | | **[GroupChat](https://docs.swarms.world/api/group-chat)** | Agents collaborate and make decisions through a conversational interface. | Real-time collaborative decision-making, negotiations, and brainstorming. | | **[ForestSwarm](https://docs.swarms.world/api/forest-swarm)** | Dynamically selects the most suitable agent or tree of agents for a given task. | Task routing, optimizing for expertise, and complex decision-making trees. | | **[HierarchicalSwarm](https://docs.swarms.world/api/hierarchical-swarm)** | Orchestrates agents with a director who creates plans and distributes tasks to specialized worker agents. | Complex project management, team coordination, and hierarchical decision-making with feedback loops. | | **[HeavySwarm](https://docs.swarms.world/api/heavy-swarm)** | Implements a five-phase workflow with specialized agents (Research, Analysis, Alternatives, Verification) for comprehensive task analysis. | Complex research and analysis tasks, financial analysis, strategic planning, and comprehensive reporting. | | **[SwarmRouter](https://docs.swarms.world/api/swarm-router)** | A universal orchestrator that provides a single interface to run any type of swarm with dynamic selection. | Simplifying complex workflows, switching between swarm strategies, and unified multi-agent management. | Learn more about all of the 60+ Multi-Agent Structures we have available [here](/docs/MULTI_AGENT_STRUCTURES.md) ----- ### SequentialWorkflow A `SequentialWorkflow` executes tasks in a strict order, forming a pipeline where each agent builds upon the work of the previous one. `SequentialWorkflow` is Ideal for processes that have clear, ordered steps. This ensures that tasks with dependencies are handled correctly. ```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-5.4", ) # 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-5.4", ) # 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) ``` ----- ### ConcurrentWorkflow A `ConcurrentWorkflow` runs multiple agents simultaneously, allowing for parallel execution of tasks. This architecture drastically reduces execution time for tasks that can be performed in parallel, making it ideal for high-throughput scenarios where agents work on similar tasks concurrently. ```python from swarms import Agent, ConcurrentWorkflow # Create agents for different analysis tasks market_analyst = Agent( agent_name="Market-Analyst", system_prompt="Analyze market trends and provide insights on the given topic.", model_name="gpt-5.4", max_loops=1, ) financial_analyst = Agent( agent_name="Financial-Analyst", system_prompt="Provide financial analysis and recommendations on the given topic.", model_name="gpt-5.4", max_loops=1, ) risk_analyst = Agent( agent_name="Risk-Analyst", system_prompt="Assess risks and provide risk management strategies for the given topic.", model_name="gpt-5.4", max_loops=1, ) # Create concurrent workflow concurrent_workflow = ConcurrentWorkflow( agents=[market_analyst, financial_analyst, risk_analyst], max_loops=1, ) # Run all agents concurrently on the same task results = concurrent_workflow.run( "Analyze the potential impact of AI technology on the healthcare industry" ) print(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/api/agent-rearrange). This architecture is perfect for orchestrating dynamic workflows where agents might work in parallel, in sequence, or in any combination you choose. ```python from swarms import Agent, AgentRearrange # Define agents researcher = Agent(agent_name="researcher", model_name="gpt-5.4") writer = Agent(agent_name="writer", model_name="gpt-5.4") editor = Agent(agent_name="editor", model_name="gpt-5.4") # 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 swarm outputs = rearrange_system.run("Analyze the impact of AI on modern cinema.") print(outputs) ``` ### GraphWorkflow `GraphWorkflow` orchestrates agents as nodes in a Directed Acyclic Graph (DAG). Each node is an agent and each edge declares a dependency, so a node only runs after every upstream node has finished. A topological sort guarantees correct execution order, while independent branches run in parallel automatically. This makes `GraphWorkflow` the right choice when your workflow has fan-out / fan-in patterns, conditional dependencies, or any structure that doesn't fit a strict line or a flat parallel batch. [Learn more about GraphWorkflow](https://docs.swarms.world/api/graph-workflow) ```python from swarms import Agent, GraphWorkflow, Node, Edge, NodeType # Define agents researcher = Agent(agent_name="Researcher", system_prompt="Research the given topic and produce key findings.", model_name="gpt-5.4") writer = Agent(agent_name="Writer", system_prompt="Write a clear article from the research provided.", model_name="gpt-5.4") reviewer = Agent(agent_name="Reviewer", system_prompt="Review the article for accuracy and clarity.", model_name="gpt-5.4") publisher = Agent(agent_name="Publisher", system_prompt="Format the final reviewed article for publication.", model_name="gpt-5.4") # Build the graph: Researcher -> Writer -> Reviewer -> Publisher workflow = GraphWorkflow() workflow.add_node(Node(id="researcher", type=NodeType.AGENT, agent=researcher)) workflow.add_node(Node(id="writer", type=NodeType.AGENT, agent=writer)) workflow.add_node(Node(id="reviewer", type=NodeType.AGENT, agent=reviewer)) workflow.add_node(Node(id="publisher", type=NodeType.AGENT, agent=publisher)) workflow.add_edge(Edge(source="researcher", target="writer")) workflow.add_edge(Edge(source="writer", target="reviewer")) workflow.add_edge(Edge(source="reviewer", target="publisher")) workflow.set_entry_points(["researcher"]) workflow.set_end_points(["publisher"]) # Run the graph results = workflow.run("Produce a short article on the rise of small language models.") print(results) ``` `GraphWorkflow` excels at: - **Complex Dependencies**: Express any DAG, including fan-out, fan-in, and diamond patterns - **Automatic Parallelism**: Independent branches execute concurrently without extra configuration - **Per-node Observability**: Hook into node completion via callbacks for streaming and progress tracking ---- ### 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/api/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, SwarmRouter, SwarmType # Define a few generic agents writer = Agent(agent_name="Writer", system_prompt="You are a creative writer.", model_name="gpt-5.4") editor = Agent(agent_name="Editor", system_prompt="You are an expert editor for stories.", model_name="gpt-5.4") reviewer = Agent(agent_name="Reviewer", system_prompt="You are a final reviewer who gives a score.", model_name="gpt-5.4") # 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-5.4" ) 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. ------- ### AutoSwarmBuilder: Autonomous Agent Generation The `AutoSwarmBuilder` automatically generates specialized agents and their workflows based on your task description. Simply describe what you need, and it will create a complete multi-agent system with detailed prompts and optimal agent configurations. [Learn more about AutoSwarmBuilder](https://docs.swarms.world/api/auto-swarm-builder) ```python from swarms import AutoSwarmBuilder import json # Initialize the AutoSwarmBuilder swarm = AutoSwarmBuilder( name="My Swarm", description="A swarm of agents", verbose=True, max_loops=1, return_agents=True, model_name="gpt-5.4", ) # Let the builder automatically create agents and workflows result = swarm.run( task="Create an accounting team to analyze crypto transactions, " "there must be 5 agents in the team with extremely extensive prompts. " "Make the prompts extremely detailed and specific and long and comprehensive. " "Make sure to include all the details of the task in the prompts." ) # The result contains the generated agents and their configurations print(json.dumps(result, indent=4)) ``` The `AutoSwarmBuilder` provides: - **Automatic Agent Generation**: Creates specialized agents based on task requirements - **Intelligent Prompt Engineering**: Generates comprehensive, detailed prompts for each agent - **Optimal Workflow Design**: Determines the best agent interactions and workflow structure - **Production-Ready Configurations**: Returns fully configured agents ready for deployment - **Flexible Architecture**: Supports various swarm types and agent specializations This feature is perfect for rapid prototyping, complex task decomposition, and creating specialized agent teams without manual configuration. ------- ### 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/examples/mixture-of-agents-example) ```python from swarms import Agent, MixtureOfAgents # Define expert agents financial_analyst = Agent(agent_name="FinancialAnalyst", system_prompt="Analyze financial data.", model_name="gpt-5.4") market_analyst = Agent(agent_name="MarketAnalyst", system_prompt="Analyze market trends.", model_name="gpt-5.4") risk_analyst = Agent(agent_name="RiskAnalyst", system_prompt="Analyze investment risks.", model_name="gpt-5.4") # 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-5.4" ) # 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` is an asynchronous, self-selecting groupchat. All agents listen in parallel; for each broadcast message, every other agent runs a forced `respond(score, message)` function call to decide whether to chime in, and replies above `threshold` are broadcast. The chat ends when `max_loops` messages have been posted or no message arrives for `idle_timeout` seconds. There is no turn order — multiple agents can react to the same message at the same time, and silent agents stay silent. ```python from swarms import Agent, GroupChat, RESPOND_TOOL # Every agent MUST carry RESPOND_TOOL so the chat can ask it whether to speak. tech_optimist = Agent( agent_name="TechOptimist", system_prompt="Argue for the benefits of AI in society.", model_name="gpt-5.4", max_loops=1, persistent_memory=False, tools_list_dictionary=[RESPOND_TOOL], ) tech_critic = Agent( agent_name="TechCritic", system_prompt="Argue against the unchecked advancement of AI.", model_name="gpt-5.4", max_loops=1, persistent_memory=False, tools_list_dictionary=[RESPOND_TOOL], ) chat = GroupChat( agents=[tech_optimist, tech_critic], max_loops=10, # hard cap on total messages posted threshold=0.5, # min decision score (0..1) to publish a reply idle_timeout=8.0, # seconds of silence before stopping ) result = chat.run("Let's discuss the societal impact of artificial intelligence.") print(result) ``` ---- ### HierarchicalSwarm `HierarchicalSwarm` implements a director-worker pattern where a central director agent creates comprehensive plans and distributes specific tasks to specialized worker agents. The director evaluates results and can issue new orders in feedback loops, making it ideal for complex project management and team coordination scenarios. ```python from swarms import Agent, HierarchicalSwarm # Define specialized worker agents content_strategist = Agent( agent_name="Content-Strategist", system_prompt="You are a senior content strategist. Develop comprehensive content strategies, editorial calendars, and content roadmaps.", model_name="gpt-5.4" ) creative_director = Agent( agent_name="Creative-Director", system_prompt="You are a creative director. Develop compelling advertising concepts, visual directions, and campaign creativity.", model_name="gpt-5.4" ) seo_specialist = Agent( agent_name="SEO-Specialist", system_prompt="You are an SEO expert. Conduct keyword research, optimize content, and develop organic growth strategies.", model_name="gpt-5.4" ) brand_strategist = Agent( agent_name="Brand-Strategist", system_prompt="You are a brand strategist. Develop brand positioning, identity systems, and market differentiation strategies.", model_name="gpt-5.4" ) # Create the hierarchical swarm with a director marketing_swarm = HierarchicalSwarm( name="Marketing-Team-Swarm", description="A comprehensive marketing team with specialized agents coordinated by a director", agents=[content_strategist, creative_director, seo_specialist, brand_strategist], max_loops=2, # Allow for feedback and refinement verbose=True ) # Run the swarm on a complex marketing challenge result = marketing_swarm.run( "Develop a comprehensive marketing strategy for a new SaaS product launch. " "The product is a project management tool targeting small to medium businesses. " "Coordinate the team to create content strategy, creative campaigns, SEO optimization, " "and brand positioning that work together cohesively." ) print(result) ``` The `HierarchicalSwarm` excels at: - **Complex Project Management**: Breaking down large tasks into specialized subtasks - **Team Coordination**: Ensuring all agents work toward unified goals - **Quality Control**: Director provides feedback and refinement loops - **Scalable Workflows**: Easy to add new specialized agents as needed --- ### HeavySwarm `HeavySwarm` implements a sophisticated 5-phase workflow inspired by X.AI's Grok heavy implementation. It uses specialized agents (Research, Analysis, Alternatives, Verification) to provide comprehensive task analysis through intelligent question generation, parallel execution, and synthesis. This architecture excels at complex research and analysis tasks requiring thorough investigation and multiple perspectives. ```python from swarms import HeavySwarm # Pip install swarms-tools from swarms_tools import exa_search swarm = HeavySwarm( name="Gold ETF Research Team", description="A team of agents that research the best gold ETFs", worker_model_name="claude-sonnet-4-20250514", show_dashboard=True, question_agent_model_name="gpt-5.4", loops_per_agent=1, agent_prints_on=False, worker_tools=[exa_search], random_loops_per_agent=True, ) prompt = ( "Find the best 3 gold ETFs. For each ETF, provide the ticker symbol, " "full name, current price, expense ratio, assets under management, and " "a brief explanation of why it is considered among the best. Present the information " "in a clear, structured format suitable for investors. Scrape the data from the web. " ) out = swarm.run(prompt) print(out) ``` The `HeavySwarm` provides: - **5-Phase Analysis**: Question generation, research, analysis, alternatives, and verification - **Specialized Agents**: Each phase uses purpose-built agents for optimal results - **Comprehensive Coverage**: Multiple perspectives and thorough investigation - **Real-time Dashboard**: Optional visualization of the analysis process - **Structured Output**: Well-organized and actionable results This architecture is perfect for financial analysis, strategic planning, research reports, and any task requiring deep, multi-faceted analysis. [Learn more about HeavySwarm](https://docs.swarms.world/api/heavy-swarm) --- ### Social Algorithms **Social Algorithms** provide a flexible framework for defining custom communication patterns between agents. You can upload any arbitrary social algorithm as a callable that defines the sequence of communication, enabling agents to talk to each other in sophisticated ways. [Learn more about Social Algorithms](https://docs.swarms.world/api/social-algorithms) ```python from swarms import Agent, SocialAlgorithms # Define a custom social algorithm def research_analysis_synthesis_algorithm(agents, task, **kwargs): # Agent 1 researches the topic research_result = agents[0].run(f"Research: {task}") # Agent 2 analyzes the research analysis = agents[1].run(f"Analyze this research: {research_result}") # Agent 3 synthesizes the findings synthesis = agents[2].run(f"Synthesize: {research_result} + {analysis}") return { "research": research_result, "analysis": analysis, "synthesis": synthesis } # Create agents researcher = Agent( agent_name="Researcher", agent_description="Expert in comprehensive research and information gathering.", model_name="gpt-5.4" ) analyst = Agent( agent_name="Analyst", agent_description="Specialist in analyzing and interpreting data.", model_name="gpt-5.4" ) synthesizer = Agent( agent_name="Synthesizer", agent_description="Focused on synthesizing and integrating research insights.", model_name="gpt-5.4" ) # Create social algorithm social_alg = SocialAlgorithms( name="Research-Analysis-Synthesis", agents=[researcher, analyst, synthesizer], social_algorithm=research_analysis_synthesis_algorithm, verbose=True ) # Run the algorithm result = social_alg.run("The impact of AI on healthcare") print(result.final_outputs) ``` Perfect for implementing complex multi-agent workflows, collaborative problem-solving, and custom communication protocols. --- ## Documentation The full documentation lives at **[docs.swarms.world](https://docs.swarms.world)**. Below are the resources most useful when building with Swarms — both for humans and for AI coding assistants. | Resource | Link | What it's for | |---|---|---| | **Main documentation** | [docs.swarms.world](https://docs.swarms.world) | Guides, API reference, tutorials | | **`llms.txt` (LLM-ingestible docs)** | [docs.swarms.world/llms.txt](https://docs.swarms.world/llms.txt) | A single, machine-readable index of the entire documentation, formatted for LLMs and AI IDEs (Cursor, Claude Code, etc.) to consume in one fetch | | **MCP integration guide** | [docs.swarms.world/mcp](https://docs.swarms.world/mcp) | How to connect a Swarms `Agent` to any [Model Context Protocol](https://modelcontextprotocol.io) server, auto-discover its tools, and call them from a swarm | | **API reference** | [docs.swarms.world/api](https://docs.swarms.world/api) | Per-class reference for `Agent`, `SequentialWorkflow`, `ConcurrentWorkflow`, `AgentRearrange`, `GraphWorkflow`, `SwarmRouter`, and every multi-agent architecture | | **Environment setup** | [docs.swarms.world/environment-setup](https://docs.swarms.world/environment-setup) | API keys, model providers, and configuration options | > **Tip for AI coding assistants:** point your tool (Claude Code, Cursor, Windsurf, Continue, etc.) at `https://docs.swarms.world/llms.txt`. It will pull the entire docs index in one shot and write idiomatic Swarms code without per-question lookups. --- ## Using Swarms with AI Coding Assistants The repo ships with a [`CLAUDE.md`](./CLAUDE.md) at the root — a focused guide that teaches Claude Code, Cursor, and other AI coding assistants how to build with Swarms. It covers the `Agent` primitive, every multi-agent architecture (`SequentialWorkflow`, `ConcurrentWorkflow`, `AgentRearrange`, `GraphWorkflow`, `MixtureOfAgents`, `HierarchicalSwarm`, `SwarmRouter`, and more), tools, streaming, memory, MCP integration, and the patterns to reach for in each situation. Drop `CLAUDE.md` (or symlink it as `AGENTS.md` / `.cursorrules`) into any project that depends on `swarms` and your assistant will write idiomatic Swarms code on the first try — no extra prompting required. --- ## 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 here](https://docs.swarms.world/community/features) | 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 | ## Supported Protocols & Integrations Swarms seamlessly integrates with industry-standard protocols and open specifications, unlocking powerful capabilities for tool integration, payment processing, distributed agent orchestration, and model interoperability. | Protocol | Description | Documentation | |----------|-------------|---------------| | **[MCP (Model Context Protocol)](https://docs.swarms.world/integrations/mcp)** | Standardized protocol for AI agents to interact with external tools and services through MCP servers. Enables dynamic tool discovery and execution. | [MCP Integration Guide](https://docs.swarms.world/integrations/mcp) | | **[X402](https://docs.swarms.world/examples/integrations/x402-payment)** | Cryptocurrency payment protocol for API endpoints. Enables monetization of agents with pay-per-use models. | [X402 Quickstart](https://docs.swarms.world/examples/integrations/x402-payment) | | **[Swarms Marketplace](https://swarms.world)** | Platform for discovering and sharing production-ready prompts, agents, and tools. Enables automatic prompt loading from the marketplace and publishing your own prompts directly from code. | [Marketplace Tutorial](https://docs.swarms.world/integrations/marketplace) | | **[Open Responses](https://www.openresponses.org/)** | Open-source specification and ecosystem for multi-provider, interoperable LLM interfaces based on the OpenAI Responses API. Provides a unified schema and tooling for calling language models, streaming results, and composing agentic workflows—independent of provider. | [Open Responses Website](https://www.openresponses.org/) | | **[Agent Skills](https://docs.swarms.world/agents/agent-skills)** | Lightweight, markdown-based format for defining modular, reusable agent capabilities introduced by Anthropic. Enables specialization of agents without modifying code by loading skill definitions from simple SKILL.md files. | [Agent Skills Documentation](https://docs.swarms.world/agents/agent-skills) | --- ## Examples Explore comprehensive examples and tutorials to learn how to use Swarms effectively [HERE](examples/README.md) --- ## Contribute to Swarms Swarms is an open-source, community-driven framework aiming to accelerate a fully autonomous world by providing robust infrastructure for deploying and orchestrating millions of agents. By contributing, you can help advance multi-agent AI, collaborate with passionate peers, shape the agent economy, and enhance your expertise. Learn more about how you can make a meaningful impact in our [Contributor's Guide](https://docs.swarms.world/community/contributing). ### How to Contribute 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/community/contributing-to-docs). 4. **Join the Discussion:** To participate in roadmap discussions and connect with other developers, join our community on [**Discord**](https://discord.gg/EamjgSaEQf). 5. **Use WARP for Every Commit, PR and Issue:** All contributors, people and AI agents alike, must write commit messages, PR titles and issue titles in the WARP (Warp Speed Protocol) shorthand: `[TYPE][Function/FileName][Short Description]`, for example `[FIX][Agent._run][Raise AgentLLMError after retry exhaustion]`. The full spec is the [**WARP Git Message Skill**](https://swarms.world/prompt/32d1e7b4-34da-4035-bc05-d18f8e71a2f1). Issues and PRs that skip WARP are triaged after the ones that use it, so expect a delay without it. ### Thank You to Our Contributors Thank you for contributing to swarms. Your work is extremely appreciated and recognized.

## We're Hiring Swarms is hiring. We're building the infrastructure for a world of autonomous agents, and we're looking for engineers, researchers, and operators who want to ship at the frontier of multi-agent AI. - **Open roles:** [swarms.ai/hiring](https://swarms.ai/hiring) - **Get in touch:** email [kye@swarms.world](mailto:kye@swarms.world) to learn more ## Join the Discord Join thousands of agent builders and AI engineers in the **[Swarms Discord](https://discord.gg/EamjgSaEQf)** for technical support, project showcases, collaboration, and the latest swarms ecosystem updates. [Join the Swarms Discord →](https://discord.gg/EamjgSaEQf) ----- ## Join the Swarms Community! 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/EamjgSaEQf) | | Twitter | Latest news and announcements | [@swarms_corp](https://twitter.com/swarms_corp) | | 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/swarms_calendar) | | 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 = {Kye Gomez and Pliny and Zack Bradshaw and Ilumn and Harshal and the 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 Swarms is licensed under the Apache License 2.0. [Learn more here](./LICENSE) Source: https://github.com/kyegomez/swarms

@x402swarmss

x402 on swarms