Agent Swarm is an MIT-licensed, self-hosted orchestration engine that runs a lead agent delegating goals to worker agents inside isolated Docker containers, built for teams that want their company to become AI-native while keeping the work on their own infrastructure.

What it is

Agent Swarm describes itself as an open-source operating system for AI work. It is written in TypeScript and sits in the agentic framework and orchestration space. A lead agent takes tasks from Slack, GitHub or GitLab, issue trackers, email, or the API, then plans and delegates them to workers running a harness of the operator's choice: Claude Code, Codex, pi, opencode, Devin, or ACP agents. Those workers execute in isolated Docker containers with their own development environments, and a persistent brain holds memory through vector search plus identity in SOUL and CLAUDE.md files, so context and learnings survive across sessions. Completed work ships as pull requests, Slack replies, or email replies.

The concrete problem it solves is that agentic coding sessions do not outlive their own context. Driving one assistant per task means repeated setup, lost learnings, and manual shuttling of output between a chat window, a tracker, and a repository. Agent Swarm replaces that loop with an orchestration layer that holds shared memory and identity across sessions, schedules recurring work, and puts review gates and human-in-the-loop activation in front of changes. It does not replace the coding harnesses themselves; it coordinates them.

Key capabilities

• A lead agent receives intake from Slack, GitHub and GitLab, Linear, Jira, email, and the API or CLI.
• Memory and identity persist across sessions through vector search and identity files such as SOUL and CLAUDE.md.
• Schema-validated task results through send-task for callers that need structured JSON output, and deferred tasks through defer-task that wake when all or any watched tasks reach an outcome, or when a deadline arrives.
• Workflows, schedules, scripts, and apps cover recurring work.
• Extensions provide trusted TypeScript hooks, installed as drafts and activated by an operator.
• Realtime rooms handle shared page state, presence, and live channels, alongside dashboard file attachments added by paste, drag-and-drop, or file picker.
• A REST API serves on port 3013 with /docs and /openapi.json.

Who uses it and how

• Teams wiring Slack, GitHub or GitLab, Linear or Jira, and AgentMail so incoming requests become delegated tasks and replies return to the originating channel.
• Engineering groups self-hosting the Docker Compose stack to evaluate the system, then moving to Kubernetes with the OCI Helm chart for production.
• Operators who install extensions as drafts and activate them manually, keeping a human-in-the-loop review gate over new automation.
• Teams that pull external signals into the loop through Sentry, Composio, Serply search, or WhatsApp via Kapso.

Getting started

Give a coding agent the operator skill with npx skills add desplega-ai/agent-swarm, or install it as a plugin in Claude Code, Codex, Cursor, Gemini CLI, Antigravity or Factory Droid, OpenCode, pi, Devin, or Kimi. To self-host, clone the repository, copy .env.docker.example to .env, generate the encryption_key, and run docker compose -f docker-compose.example.yml --env-file .env up -d, after which the API listens on http://localhost:3013.

How it compares

The facts provided list no paid products that Agent Swarm replaces, and they name no direct alternative orchestration tool. The harnesses it supports, such as Claude Code, Codex, and Devin, are the workers it coordinates rather than competitors, so on the available evidence it stands alone in this registry.

When to use it — and when not to

A self-hoster operates the whole stack: Docker Compose or Kubernetes, an API on port 3013, an encryption_key, an API key, a harness credential, and all eight agent UUIDs, and the README asks operators to read the Compose checklist before starting. Teams that want a zero-operations hosted product, or whose workflow is a single coding agent on a single repository, should not pick it, because the orchestration layer only pays off with recurring, multi-source work. The repository also states that it evolves every single day, so interfaces and deployment steps should be expected to move.

flowchart LR
    subgraph IN["Tasks come in"]
        direction TB
        S["Slack"]
        G["GitHub / GitLab"]
        E["Email"]
        A["API / CLI"]
    end

    LEAD(["Lead Agent<br/>plans &amp; delegates"])

    subgraph WORKERS["Workers in Docker"]
        direction TB
        W1["Worker"]
        W2["Worker"]
        W3["Worker"]
    end

    subgraph BRAIN["Persistent brain"]
        direction TB
        MEM["Memory<br/>(vector search)"]
        ID["Identity<br/>(SOUL, CLAUDE.md)"]
    end

    subgraph OUT["Work ships"]
        direction TB
        PR["Pull Requests"]
        REPLY["Slack replies"]
        EMAIL["Email replies"]
    end

    IN --> LEAD --> WORKERS
    WORKERS -->|reads context| BRAIN
    WORKERS -->|writes learnings| BRAIN
    WORKERS --> OUT

npx skills add desplega-ai/agent-swarm

git clone https://github.com/desplega-ai/agent-swarm.git && cd agent-swarm
cp .env.docker.example .env  # Set API_KEY, a harness credential, and all eight agent UUIDs.
openssl rand -base64 32 > encryption_key
chmod 600 .env encryption_key
docker compose -f docker-compose.example.yml --env-file .env up -d