Swarms Logo

One stack to build, deploy, monitor, and sell AI agents

Write AI agents in Swarms Python or Swarms Rust. Deploy them through the Swarms API, monitor every run in Swarms Cloud, and sell them on the Swarms Marketplace, keeping 90% of every sale.

Start buildingSee each layer
Pythonpip install swarmsRustcargo add swarms-rsAPIapi.swarms.worldCloudcloud.swarms.worldMarketplaceswarms.world

Build

Write the agent in Swarms Python or Swarms Rust.

AI agent infrastructure, layer by layer

Open-source frameworks to build agents, a hosted API to run them, telemetry to watch them, and a marketplace to sell them. Start with the piece you need today; each one hands off to the next when your agent outgrows it.

Build

Swarms Python

The core framework. Agents, tools, memory, and multi-agent architectures in plain Python.

  • Sequential, concurrent, hierarchical, graph, group chat, and more architectures
  • Any provider: OpenAI, Anthropic, Gemini, Groq, DeepSeek, Ollama, vLLM
  • Tools, MCP servers, and vector memory built in
  • Publish an agent to the Marketplace from its constructor
pip install -U swarms
View on GitHubDocumentation
workflow.py
from swarms import Agent, SequentialWorkflow

researcher = Agent(
    agent_name="Researcher",
    system_prompt="Research the topic and list the key facts.",
    model_name="gpt-4.1",
)

writer = Agent(
    agent_name="Writer",
    system_prompt="Turn the research into a short brief.",
    model_name="gpt-4.1",
)

workflow = SequentialWorkflow(agents=[researcher, writer])
print(workflow.run("Where is battery storage heading in 2027?"))

Build

Swarms Rust

The same agent model in Rust, for services where latency, memory, and concurrency matter.

  • Memory-safe with no garbage collector, async on Tokio
  • Concurrent, sequential, and graph workflows
  • MCP support over STDIO and SSE
  • OpenAI, DeepSeek, and any OpenAI-compatible endpoint
cargo add swarms-rs
View on GitHubdocs.rs
main.rs
use swarms_rs::llm::provider::openai::OpenAI;
use swarms_rs::structs::concurrent_workflow::ConcurrentWorkflow;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = OpenAI::new(std::env::var("OPENAI_API_KEY")?)
        .set_model("gpt-4.1");

    let planner = client.agent_builder()
        .agent_name("Planner")
        .system_prompt("Break the work into clear steps.")
        .build();

    let solver = client.agent_builder()
        .agent_name("Solver")
        .system_prompt("Execute the plan and return the answer.")
        .build();

    let workflow = ConcurrentWorkflow::builder()
        .name("Plan and Solve")
        .agents(vec![Box::new(planner), Box::new(solver)])
        .build();

    let result = workflow.run("Design a rate limiter").await?;
    println!("{}", serde_json::to_string_pretty(&result)?);
    Ok(())
}

Deploy

Swarms API

Hosted multi-agent orchestration over REST. Send agent configs and a task, get the result back.

  • 16 swarm architectures behind one endpoint
  • 2,000+ models with one API key
  • Batch endpoints for thousands of tasks per job
  • SDKs for Python, TypeScript, Go, and Java
pip install swarms-client
Get an API keyAPI reference
swarm.py
import os
import requests

response = requests.post(
    "https://api.swarms.world/v1/swarm/completions",
    headers={"x-api-key": os.environ["SWARMS_API_KEY"]},
    json={
        "name": "Market Research Swarm",
        "swarm_type": "MixtureOfAgents",
        "task": "Build a quarterly outlook for semiconductors.",
        "agents": [
            {"agent_name": "Macro Analyst", "model_name": "gpt-4.1"},
            {"agent_name": "Equity Analyst", "model_name": "claude-opus-5"},
        ],
    },
)

result = response.json()
print(result["outputs"], result["usage"])

Monitor

Swarms Cloud

The monitoring and telemetry layer. Every run your agents make, with its logs, tokens, cost, and context use.

  • Searchable logs for every request, by agent, endpoint, ID, time, or task text
  • A page for every completion with the exact request, response, tokens, and cost
  • Per-agent activity, spend, and context-window use, run by run
  • Token usage by day, week, or month, with an end-of-month spend projection
Open Swarms CloudWhat is Swarms Cloud?
cloud.swarms.world/historyPaused
Runs today
487
Tokens
616,887
Spend
$3.11
TimeAgentTokensCostStatus

Research-Agent

agent-454021

Model
gpt-4.1
Input tokens
520
Output tokens
702
Cost
$0.0067
Context used
0.12%
Status
Succeeded

Every request your agents make through the Swarms API lands here. Select a run to see what Cloud records about it.

Monetize

Swarms Marketplace

Where agents, prompts, tools, MCP servers, and skills are bought and sold.

  • Publish for free and keep 90% of every sale
  • Buyers pay by card in 100+ countries, or in crypto
  • Tokenize an agent on Solana and earn on every trade
  • 6,000+ listings, with a public API and an MCP server
Open the MarketplaceHow selling works
publish_agent.py
from swarms import Agent

agent = Agent(
    agent_name="Compliance Checker",
    agent_description="Reviews documents for regulatory issues",
    model_name="gpt-4.1",
    publish_to_marketplace=True,
    tags=["compliance", "legal"],
)

# Validated and listed on swarms.world when it runs.
agent.run("Review this vendor agreement for GDPR issues.")
A $20.00 salecard or crypto
You keep $18.00Platform fee $2.00

Take one AI agent from first line of code to first sale

The same research agent built, deployed, monitored, and sold on Swarms. Watch it run, or pick a step.

Write the agent in Swarms Python or Swarms Rust and run it locally against any model.

zsh
$ pip install -U swarms
✓ Successfully installed swarms
$ cat research_agent.py
from swarms import Agent
agent = Agent(
agent_name="Research-Agent",
system_prompt="Summarize each paper in three bullets.",
model_name="gpt-4.1",
max_loops=1,
)
agent.run("Summarize this week's agent papers")
$ python research_agent.py
✓ Research-Agent finished in 1 loop

Everything an AI agent team needs, mapped to the stack

19 jobs that come up when you build, deploy, monitor, and sell agents, and the part of the stack that handles each one. Open a row to see how.

Need
Build
Deploy
Monitor
Monetize

Questions about the Swarms stack

What builders ask before they pick a framework, deploy their first agent, or list it for sale.

What is the Swarms stack?

The Swarms stack is a set of five products that cover the full life of an AI agent. Swarms Python and Swarms Rust are open-source frameworks for building agents and multi-agent systems. The Swarms API deploys and runs them, Swarms Cloud monitors every run, and the Swarms Marketplace is where you sell them. The hosted products share one account and one API key.

Should I build my AI agents in Python or Rust?

Start with Swarms Python if you want the widest choice of multi-agent architectures, model providers, tools, and examples. Choose Swarms Rust for services where latency, memory use, and concurrency matter: it is memory-safe, has no garbage collector, and runs async on Tokio. Both support MCP servers and OpenAI-compatible model endpoints.

Install Swarms

How do I deploy an AI agent with Swarms?

Send the agent's configuration and a task to the Swarms API at api.swarms.world, as plain REST from any language or through the SDKs for Python, TypeScript, Go, and Java. The API runs single agents, 16 multi-agent architectures, and batch jobs of thousands of tasks on hosted infrastructure, and returns token usage with every response.

About the Swarms API

How do I monitor AI agents in production?

Swarms Cloud logs every request your agents make through the Swarms API. Search runs by agent, endpoint, ID, time, or task text, open any completion to see its exact request, response, tokens, and cost, and track spend and context-window use per agent, with a projection of where the month's spend will land.

What is Swarms Cloud?

Which models and multi-agent architectures does the Swarms API support?

One API key reaches 2,000+ models from providers including OpenAI, Anthropic, Google, xAI, DeepSeek, and Meta. The API offers 16 swarm architectures, among them sequential and concurrent workflows, hierarchical swarms, graph workflows, group chat, and mixture of agents. Switching models is a one-line change to model_name.

How do I make money from an AI agent?

Publish it on the Swarms Marketplace at swarms.world. Listing is free, and you keep 90% of every sale, whether the buyer pays by card through Stripe or in crypto. You can also launch the agent as a token on Solana and earn a share of every trade, or use Vault Mode to give access to token holders instead of charging a price.

How the Marketplace works

What can I sell on the Swarms Marketplace?

Agents, prompts, tools, MCP servers, and skills. Agents ship as code with their dependencies, prompts are text-only instructions, tools are typed Python functions, MCP servers give other agents tool access, and skills are SKILL.md instruction packs. A Swarms Python agent can be published straight from code by setting publish_to_marketplace=True.

How much does it cost to get started?

Swarms Python and Swarms Rust are free and open source. Swarms Cloud starts on a Free plan where you pay only for usage, and new accounts get $5 in API credits. Pro ($19.99 a month) and Premium ($100 a month) raise limits and unlock more features, and every plan pays the same price per token.

See pricing

Ready to build?

Sign up now and get $5 in free API credits. Join the marketplace and start building with Swarms.

Sign Up NowJoin Marketplace