● Open-source agent orchestration
Open Swarm is an open-source platform for running swarms of AI agents on infrastructure you control — one platform that scales from a laptop to a Kubernetes cluster. Bring any agent harness, any model, your own keys. Your data stays home.
$ docker compose up -d ✔ controller healthy — orchestrates, never calls an LLM ✔ postgres · redis · chromadb healthy ✔ 12 bot nodes joined the mesh → cockpit ready at http://localhost:35457
Hosted agent platforms are powerful — and they come with their models, their cloud, and their data terms. Open Swarm closes that gap for businesses and individuals alike: the same swarm-scale automation, on hardware and accounts you own.
Point it at your life and it connects immediately — lights, thermostats, calendars, inboxes, files, money — into one encrypted store on your own hardware. Then wire anything to anything: a signal from one connector can drive actions across all the rest, and none of it leaves your house.
# a cross-domain rule: money watches, house celebrates when: finance.net-worth: above $1,000,000 # your own bank link then: - home.lights: flash # every room, on and off - notify.text: "go look at the app" - notify.call: voice announcement - notify.email: milestone recap
Sign in to your own Google, SmartThings, bank, and social accounts. Tokens are encrypted per user on your machine — no third party in the middle.
The finance bot watches the number; the home bot owns the lights; notifications fan out. Data, devices, and workflows compose — connect, don't code.
Everything lands in a per-user encrypted store you host. Nothing posts, sends, or dials without passing your approval gate first.
Applications — built on the framework, some of the 30+ in the repo
Paper or real. Talk an idea through with the assistant and it becomes a monitored strategy: backtest it just by describing it, wire it into the signals already flowing through your swarm, and run it paper-first. Going live is a deliberate double opt-in — every position watched, one kill switch to halt everything.
On the builder's own monitored book: about 4%/month over the market on average. Your results are your own — nothing here is financial advice.
You place the order. Add things to your cart in chat; the swarm hunts the best price and deep-links the filled cart into Walmart or Amazon. It never holds your payment details and never buys on its own — the last click is always yours.
Two things live here: the framework — the rails below — and the applications built on top of it, like the ones above. Open Swarm doesn't compete with agent frameworks or model vendors — it wraps them. Neutrality is the product: best-of-breed gets re-decided on every call, and no single vendor can hold your workflows hostage.
Claude Code, Codex CLI, Gemini CLI, Cline, and CrewAI run as first-class runtimes behind one interface. A single ticket can flow across vendors — one bot drafts, another reviews, a third documents — sharing one workspace.
40+ providers wired in — Anthropic, OpenAI, Google, Bedrock, Groq, Cerebras, Mistral, and more — plus fully local inference via Ollama, LM Studio, and LiteLLM. Bring your own keys, or run models that never touch the internet.
A connector marketplace with hundreds of definitions and a live-proven core — Gmail, GitHub, Slack, Jira, LinkedIn, and more. OAuth per user, tokens encrypted at rest, capabilities scoped per bot. Adding a provider is configuration, not a rewrite.
Declare ticket types and multi-stage pipelines in a manifest, or draw them in Workflow Studio. Stages can require an explicit human approval before anything posts, sends, or changes production. The human stays in the loop by design.
OIDC single sign-on, database-enforced row-level security on every tenant table, AES-256-GCM per-user token encryption, and a token broker so bots receive short-lived scoped credentials — never the master key.
Each LLM call is metered per bot, per provider, per model, per ticket — real cost accounting in your own Postgres. And Token Chase captures calls as replayable frames, so cheaper model-and-harness lanes can be graded against the original for equivalence before you switch.
Open Swarm doesn't ask your team to switch tools. It sits between the pieces, and any component can be subbed out or integrated — a model, a harness, a connector, an entire workflow engine.
Jira, ServiceNow, or your own queue. Nobody migrates anything — the source of truth stays the source of truth.
A swarm bot picks the ticket up, pulls context through your connectors and runbook RAG, does the work on your infrastructure, and passes your approval gates.
Resolution, artifacts, and the cost of producing them post back to the original ticket. Your team never left their tool.
A workflow step can be anything. Another workflow engine. An external process. A different vendor's agent. A human approval. The swarm genuinely doesn't care what a step runs — the wrapper owns the integration, so every part stays replaceable and no single vendor ever holds the whole.
The separation is strict: the controller routes tickets, phases, and approvals — it never calls an LLM. Bot nodes own all model execution, each running its own harness against its own provider, collaborating over a Redis mesh.
One ticket, many vendors. Because every harness sits behind the same interface, a single piece of work can move across them — a Codex bot drafts, a Claude bot reviews, a Gemini bot writes the runbook — with every call metered and every artifact in one shared workspace. No other orchestrator treats the harness itself as a swappable layer.
Unretouched screens from the current pre-release build. It still wears the project's working name in the chrome — the rebrand hasn't reached the app yet, and we'd rather show you that than restage a screenshot.
One Docker image boots as controller or bot node. What changes between a laptop demo and a datacenter deployment is the substrate — never the platform. And we label what's shipped versus what's ahead, because honest engineering is a feature.
One command via Docker Compose: controller, Postgres, Redis, ChromaDB, and bot nodes on localhost. A zero-keys demo mode boots the full stack with no accounts at all — kick the tires before you connect anything.
The same compose stack on a box you own, with OIDC sign-on, per-user isolation, and edge nodes that enlist remote machines into the mesh. Multiple users, one accountable swarm.
K8s manifests for the full stack ship in the repo today. The scale-out path — agent work as Argo Workflows batch jobs, GitOps delivery, in-cluster model serving so data never leaves the datacenter — is designed and being proven out.
Self-hosting isn't a deployment detail — it's the security model. Nothing leaves your infrastructure unless a workflow you approved sends it.
Connector tokens and API keys are encrypted at rest with AES-256-GCM, keyed to the individual user. A token broker hands bots short-lived, single-user credentials — the master key never leaves the controller.
Row-level security is live across every tenant table and forced on — the application runs as a least-privilege role, so one user's data is invisible to another even if application code gets it wrong.
OIDC authentication against your identity provider — Keycloak works out of the box. Anything that touches files, personas, or model execution is auth-gated; a mock-auth mode keeps local development friction-free.
Agents draft; you decide. Nothing posts to social, sends an email, or changes a production system without an explicit approval step in the workflow. Autonomy where it's safe, a gate where it isn't.
Vendor CLIs are brilliant and boxed in. Open Swarm gives them a neutral runtime: run them side by side on your own hardware, where they inherit your connectors, your security controls, your cost ledger — and collaborate over the mesh. Add a module; the platform does the rest.
An app declares its bots, personas, tools, ticket types, and UI surface in a single manifest. Hot-load it into a running swarm — no redeploy. The core stays undifferentiated; the manifest is the DNA.
A harness adapter implements run() and an optional health check; CLI-spawn harnesses inherit shared subprocess plumbing from a base class. The Gemini CLI harness landed as one ~300-line adapter.
Connectors are declarative specs with per-user brokered auth. Import them from OpenAPI definitions in bulk, scope their capabilities per bot, and let every app you build reuse them.
Describe a business process in plain language and the Forge interviews you, then packs a complete single-purpose bot — persona, manifest, tools, knowledge base — and registers it into the live swarm.
# a working app, one manifest name: support-triage ticketTypes: - id: support-triage workflow: workerBot: triage-bot bots: - id: triage-bot harnessType: claude-code # or codex-cli, gemini-cli… persona: personas/triage.yaml connectors: [zendesk, slack] ui: ribbon: { tab: Support } # hot-load into the running swarm POST /api/swarm/apps/load
The premise, proven
Little Monsters — the study coach in the app list above — accelerates learning for students with learning disabilities, and it was built by students with disabilities; a dyslexic teenage girl led it. Record a lecture and it becomes notes, slides, and flashcards; assignments track themselves; ask a question and get help — on a laptop or a phone.
And because it's a packed bot, it's boxed in: the deterministic persona framework locks down cheating — it tutors, explains, and quizzes, but it won't do the work for the student. That was this platform's founding premise: building an app that's scalable, secure, and safe should be easy enough that anyone with a real problem can do it. The manifest declared her app; the platform carried the auth, the isolation, the bots, and the UI. Yours gets the same rails.
Close the gap between agentic AI and the people it works for — make swarm-scale automation something you run, not something you rent.
Any individual or business can operate enterprise-grade agent swarms on infrastructure they control — laptop to datacenter — with no vendor able to hold their data, keys, or workflows hostage.
Your keys, your data, your hardware. Every design decision starts from the premise that the user — not the platform, not a vendor — owns the substrate. If a feature requires surrendering that, it doesn't ship.
We don't bet your workflows on one framework or one model. Harnesses and providers stay interchangeable, so best-of-breed is re-decided on every call — and vendors compete for your work.
Docs describe what's built; the roadmap says what isn't. Shipped, in-progress, and planned are labeled — on this page too. Overclaiming is a bug.
MIT-licensed, source-first, grassroots. No pricing page, no sales funnel, no enterprise edition holding the good parts back. Free means free.
Swarms draft, analyze, and prepare; people approve what leaves the building. Autonomy is earned per workflow, never assumed.
WorkflowTemplate plus a namespace-per-tenant manifest, both schema-valid against the live Argo CRDs; running them needs the one-shot batch entrypoint, GitOps delivery, and TerraformThe evidence wall: every claim in the shipped column maps to a machine-generated live proof in the repo, re-run nightly with a 26-hour freshness cap — a capability without fresh proof loses its score. The roadmap lives next to the code with today-vs-target status per item. If this page and the repo ever disagree, the repo wins.
A note from the builder
Open Swarm is pre-release, and today it's one engineer's personal project. Where it honestly stands: better than most of what you can rent, and not yet what it becomes when a community pitches in from every side. The foundation is solid — a real platform with real nightly proofs, not a demo — and the whole point of shipping it open is that it doesn't have to stay a one-person effort.
Clone the repo, bring the stack up, open the cockpit. The zero-keys demo mode means you can watch the swarm work before connecting a single account. When you're ready, plug in your own keys — they stay yours.
The repository opens at public launch. Open Swarm is pre-release and MIT-licensed — when the source lands, it lands free, with every claim on this page backed by a live proof that regenerates nightly.
$ git clone github.com/emeraldcoastsystemsgroup/openswarm $ cd openswarm && docker compose up -d → cockpit at http://localhost:35457