Open source platforms for orchestrating multiple AI agents working together.
Ranked by Discovery Score — our 0-100 composite of adoption, maintenance, community, and license health. How scoring works.
By Erik Loyd, SaaS CEO and former COO/CFO of an AWS Premier Partner.
oh-my-claudecode turns Claude Code into a multi-agent team coordinator. You describe a job in plain language and it dispatches specialized agents that plan, build, review, and test in parallel, passing work between themselves without you driving each step. MIT-licensed, installs through the Claude Code marketplace or as an npm CLI. No server to run. It lives inside your Claude Code session and extends the built-in agent tooling. The canonical mode is now explicit team orchestration via /team syntax, which replaced the older swarm keyword. It also routes compatible work across other CLIs you have installed (Codex, Gemini, Grok, Cursor) to save Anthropic tokens, and extracts reusable skills as it goes. Solo developers get a structured way to run long, multi-step tasks without micromanaging each agent. Small teams get a shared pattern for agent pipelines instead of everyone rolling their own. There is no paid tier and no cloud version. You bring your own Claude Max, Pro, or API key. The catch: it moves extremely fast, and that speed shows. Releases land constantly and keywords get deprecated mid-stream (swarm and autoresearch already went), so a setup that worked last month may need adjusting. Multi-agent pipelines also burn tokens faster than a single prompt, and if you don't trust the autopilot, you will review more code than you write.
Completely free and open source. Optional Gemini/Codex integrations save tokens.
**Free tier:** Fully MIT-licensed. No paid tier, no premium features. **Self-hosted:** Nothing to host in the traditional sense. It runs inside your Claude Code session as a plugin. Optional integrations with Gemini CLI and Codex CLI route compatible tasks to those providers for token savings. **Paid:** None. The creator accepts GitHub sponsorship but all features are free.
qm is Y Combinator's own open source answer to running a fleet of AI agents across a team. It's a "multiplayer agent harness for work": every person gets an isolated workspace with personal and shared scopes, you drive it from Slack or a web UI, and it can run background and scheduled agent jobs. This is YC Labs code, not a fan project trading on the name, the release is announced on ycombinator.com and served from qm.ycombinator.com. The interesting part is the multiplayer framing. Instead of each developer babysitting one agent in a terminal, qm treats agents as shared, always-on coworkers with their own scopes and cron schedules. For a team already leaning on coding agents, it's a free way to run them coordinated instead of siloed. Solo use works too, but the design clearly targets groups. The catch is that it's brand new. The commit history is short and the stars arrived fast, which means the code is early and production-readiness is unproven. The pedigree is real and the idea is sharp, but pilot it on non-critical work before you wire it into how your team actually ships.
Free and open source, straight from Y Combinator. Brand new, so treat it as early.
Free and open source under MIT, released by Y Combinator Labs. No paid tier and no hosted version, you run it yourself. Expect the usual early-project cost: fast-moving code and rough edges rather than a locked-down release.
Omnigent puts one layer over all your AI coding agents so switching between them stops being a rewrite. Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, and custom agents defined in YAML run through a single harness with shared policy controls, and you can mix several in one session or swap mid-conversation. Agent choice becomes a config line. Apache 2.0. Access has broadened past the terminal: browser, phone, and desktop all reach the same session, which is the feature that matters when an agent has been grinding for twenty minutes and you walked away from your desk. Install is a single curl command, or Python 3.12+ manually. Run the server locally, or deploy it with Docker Compose to Render, Railway, Fly.io, Modal, or Cloudflare. The sandbox story is the other reason to look. Agent execution can be pushed into Modal, Daytona, E2B, or Kubernetes instead of running against your filesystem, with credentials hidden from the agent. Solo developers running two or three agents get the policy controls alone worth the setup. Small and medium teams get the most from shared sessions and remote access. Large teams should read the policy model closely first. The catch is that a meta-harness inherits every underlying harness's quirks and adds its own. Each agent still has features the abstraction does not fully expose, and when something breaks you have two layers to debug. The project moves fast with a large open issue queue, so pin your version.
Free and Apache 2.0 with no paid tier. Your bill is the underlying agent subscriptions you already pay, plus per-second charges if you opt into cloud sandboxes.
### What's Free All of it. Apache 2.0. Multi-agent orchestration, policy controls, the security sandbox, real-time collaboration, and access from terminal, browser, phone, and desktop. No paid tier and no hosted commercial offering from the project. ### Deployment Cost - **Local**: $0. Run the server on your own machine. - **Self-hosted cloud**: Docker Compose deploys to Render, Railway, Fly.io, Hugging Face Spaces, Modal, Cloudflare, or Databricks. Expect $5-20/mo on a small instance. ### The Real Cost Two meters, and neither belongs to Omnigent. First, the agents themselves: you still pay Anthropic, OpenAI, or whoever for every token the underlying agent burns, and running multiple agents in one session multiplies that rather than dividing it. Second, optional cloud sandboxes (Modal, Daytona, E2B) bill per second of execution. ### The $0 Path Run the server locally, sandbox to a local container, and pay only your existing agent subscriptions. That covers most solo and small-team use with no new bill at all. ### The Real Consideration Version churn, not money. This is a fast-moving project with a large open issue and pull request queue. Pin your version and read release notes before upgrading.
Multica manages a fleet of AI coding agents like they're people you hired. Instead of babysitting one agent in your terminal, you assign issues to agents, group them into squads under a leader, watch their progress live, and schedule recurring jobs. It's runtime-agnostic, so it drives Claude Code, Codex, Copilot CLI, Cursor Agent, Gemini, and others rather than locking you to one. You can self-host it, and for internal use across your own team that's free. The stack is a Go backend, a Next.js frontend, and Postgres with pgvector, so standing it up yourself is real ops work, not a one-click install. Recent versions added the headline pieces: squads for routing work to a stable group of agents, a catalog of agent templates you can spin up in one click, and autopilots for scheduled recurring tasks. It's iterating fast, with near-daily releases. For a solo developer or a small team that wants to run several coding agents in parallel with real visibility into what each one is doing, this is a genuinely useful control layer, and the self-hosted version is free for your own organization. The thing to read carefully is the license. It's a modified Apache 2.0: you can use it internally all you want, but you can't offer Multica as a hosted service to other people or strip its logo without a commercial license, and there's a managed cloud at multica.ai for teams that don't want to self-host. The catch is that this is source-available, not classic open source, and it's young. If you're a developer running it for your own team, none of the restrictions touch you and it's free. If you're thinking about building a product on top of it or reselling it, that's exactly what the commercial clause is there to stop. Know which side of that line you're on before you commit.
Free to self-host for your own team. The modified-Apache license blocks reselling it or offering it as a hosted service without a commercial deal.
**Free (self-hosted, internal use):** The full platform is source-available under a modified Apache 2.0 license. Run it for your own organization, across multiple workspaces, at no cost. Go backend, Next.js frontend, Postgres plus pgvector. **Restricted:** You may not offer Multica as a hosted service to third parties, embed it in a commercial product, or remove its logo without a commercial license. This is the line between source-available and true open source. **Paid (cloud):** A managed offering at multica.ai for teams that would rather not run the stack themselves, plus commercial licensing for anyone who needs the resale or SaaS rights the open license withholds. **The trade:** Free and self-hostable for internal use, with a commercial clause aimed squarely at resellers and SaaS builders.
Cumora is team chat where the AI agents are on the roster, not in a sidebar. Same DMs, same group rooms, same Kanban board and calendar as the humans. Each agent carries a persona, a private workspace of files and notes, and memory of past conversations, and on a cadence you set they wake up, read the room, and decide whether to DM someone or start a thread. Agents DM each other too, and you can watch those conversations without joining them. MIT licensed, from the developer behind avante.nvim, so the polish is not accidental. Self-hosting is lighter than the architecture diagram suggests. The real minimum is Postgres, Redis, and one npm command, with an OpenAI key as the only hard-required variable; everything else has a local default or quietly disables itself. Cloudflare Workers for email, R2 storage, push notifications, and per-agent Kubernetes pods are optional feature groups you turn on when you want them, not the price of admission. Lighter still is BYOA: pair your own Mac or VPS with the cumora agent CLI and the agent's brain becomes your local Claude Code or Codex install on your existing subscription. The server never sees your provider keys. Solo builders should run BYOA and skip the server entirely. Small teams get the most out of it, since the premise is agents coordinating in rooms rather than one person prompting one box. Larger teams can self-host on Postgres and Redis without much drama, but there is no hosted price to plan around yet, so budget for running it yourself. The catch is maturity. This is a first release, the cloud is invite-only and free during preview, and nothing says what happens when the preview ends. The agent-initiative feature is also the thing most likely to annoy you: agents that wake on a timer and start their own conversations are great until four of them fill a room overnight. Start with two and turn the cadence down.
Free today, in every sense: MIT self-hosted and a free invite-only cloud preview. No hosted price has been announced, so do not plan a budget around it yet.
### Free Tier Everything today. The repo is MIT, and the Cumora cloud is free during an invite-only preview covering the desktop (macOS, Windows, Linux), web, and mobile clients. No pricing has been announced for after the preview, so treat the free cloud as temporary. ### Self-Hosted More approachable than the architecture diagram implies. Postgres, Redis, and a Node service is the working minimum, which fits on a single $10-20/mo VPS. An OpenAI key is the only hard-required variable. Cloudflare Workers, R2, push, and per-agent Kubernetes pods are optional groups that add cost only if you enable them. BYOA is cheaper still: run the agent daemon on a Mac or a $5-10/mo VPS and the brain is your existing Claude Code or Codex subscription, with no model bill on top. ### Paid Nothing is charged today. Managed per-agent pods and an `llm_calls` cost ledger already exist in the codebase, which is what a product builds before it charges, so expect the hosted tier to be priced per agent or per LLM spend. Plan for that if you are evaluating the cloud path rather than self-hosting.
Lody is a shared workspace for the coding agents your team already pays for. Connect a laptop, server or cloud VM with one command, then hand work to it from desktop, mobile, web or a script. It speaks the Agent Client Protocol, so Claude Code, Codex, Cursor, Cline and Goose all plug in. Apache 2.0. The free tier is real, not a demo: two workspaces, three team members, 200 sessions per workspace and 30 turns per session, with the mobile apps included. Sessions get their own Git worktrees so parallel agents do not collide, and the pull request panel syncs diff comments back into GitHub Review. Plus runs $10 per seat monthly, or $8 billed yearly, discounted to $60 per seat per year through September 30. That lifts every cap. Solo: free covers you. Small teams: the 30-turn ceiling pushes you over, not the seat count. Large teams: Enterprise, because SSO lives there alone. The catch is that the open source half is the client. The workspace syncing your sessions runs on Lody's servers, the docs carry no self-host path, and end-to-end encryption is still listed as coming soon. The project is moving toward local-first. It is not there yet.
Free tier holds 3 members and caps sessions at 30 turns. Plus is $10 per seat monthly, and SSO is Enterprise only.
**Free tier:** Two workspaces, 200 sessions per workspace, 30 turns per session, and up to 3 team members. Includes the native iOS and Android apps, push notifications, mobile diff review and approvals, all 40-plus supported agent runtimes, bring-your-own-keys, multi-device management, GitHub repository and PR context, and the embedded terminal and diff viewer. Described as free forever, not a trial. **Self-hosted:** Not available today. The desktop app, CLI, and shared UI packages are Apache 2.0 in the repository, but `npx lody daemon start` authenticates against Lody's service before a machine joins a workspace, and the documentation has no self-host guide. The repo does carry an optional-cloud protocol package and the project uses Loro CRDTs with a stated goal of full local-first operation, so this may change. **Paid:** Plus is $10 per seat per month billed monthly, or $8 per seat per month billed yearly. An early-bird offer through September 30 locks $60 per seat per year for that workspace. Plus removes the workspace, session, turn and member limits, and bills only for accepted members. End-to-end encryption is listed as coming soon on this tier. Enterprise is custom-priced and is the only tier with SSO and access controls, along with custom contracts, invoicing, procurement support and a dedicated support channel. Lody charges nothing for AI tokens on any tier.
SAGE decides which agent should do the next piece of work after execution has already started. Agent discovery tells a system who exists; it does not answer whether the agent currently working should continue alone, recruit a collaborator, or hand the whole task off. SAGE scores those three routes in one objective under permission, budget, and deadline constraints. MIT, Python, and it sits above the A2A protocol rather than replacing it. The design choices are more interesting than the pitch. Trust is learned per agent and per requirement rather than as one reputation score, so strength at coding does not imply strength at research. Teams get credit for covering the requirements still outstanding, not for collecting high-ranked but redundant agents. Every decision emits assignments, topology, cost, latency, risk, and a readable rationale. Free with nothing above it. The costs are the model calls your agents were already making, plus routing overhead from scoring candidate teams before each decision. The catch is that this is research output, not production infrastructure. It was published in August 2026 by a small lab, the benchmarks are its own, and the learned outcome model is described as a stand-in for a real reward model later. Read ALGORITHM.md before wiring it into anything that matters.
Free and MIT with nothing to buy. Treat it as a reference implementation rather than production infrastructure.
### Free MIT licensed, the full router, the algorithm write-up, and the benchmark harness. No paid tier, no hosted service, no enterprise edition. ### Self-Hosted Costs It is a Python library, not a service. Compute is trivial next to the agents it routes between. The A2A infrastructure around it is your own problem and your own bill. ### The Real Cost Model tokens, in two places. The agents doing the work cost what they always did. SAGE adds its own overhead: scoring candidate teams, running beam search over team prefixes, and updating the learned outcome model after execution. On a small agent pool that overhead is noise. On a large one, measure it, because the routing layer scoring every mid-execution decision is not free. ### When to Pay Nothing to buy. The question is whether to adopt research code at all. Treat it as a reference implementation of a routing objective worth stealing ideas from, not as a dependency you pin in production.
Sol-advisor packages an opinion about how AI coding work should be split: a read-only advisor model that reviews, an implementation lane that writes code, and an optional third lane for task-based work. It's a plugin for OpenAI's Codex ecosystem, installs with one command, and it's MIT licensed and free. There's more engineering here than the prompt pack it might sound like: a dependency-free MCP server with real test coverage, fail-closed defaults (no fallback models, no arbitrary write paths), and a consent flow that previews every file before it writes anything. Adapters exist for Cursor, VS Code, and Copilot, but this is Codex-first, and every other client is a second-class path. Use it if you're on Codex and want a mandatory fresh-context review before code gets accepted, without designing that workflow yourself. Skip it if you're not: the honest alternative is configuring Codex's own custom agents by hand, and Claude Code users already have subagents and skills natively. The catch: the review lane means paying a large reasoning model to examine work you already paid another model to do, and the whole thing is a young solo project welded to specific model IDs and a plugin spec OpenAI could change any week.
Free plugin. The cost is structural: a mandatory second model reviewing everything the first one wrote, on your token bill.
**Free:** The plugin, MIT licensed. One-command install into Codex; Bun is the only prerequisite. **Self-hosted:** Nothing to run beyond the bundled MCP server, which starts with the plugin. **The real cost:** Model usage on your OpenAI/Codex subscription or API bill. The architecture is deliberately token-hungry: every implementation pass gets a fresh-context review by a second large model, so you pay roughly twice per unit of accepted work. That's the point, not a bug, but budget for it.
AgentSpace is a shared workspace where humans and AI agents work as one team, instead of you driving a single agent in isolation. The idea: give agents defined roles, permissions, and an audit trail, then let them coordinate in channels the way a human team would. Most agent frameworks assume one person and one agent; AgentSpace is built for a group running several agents with governance around them. Apache 2.0 licensed. The interesting piece is AgentRouter, which routes tasks across different agent runtimes, Claude Code, Codex, OpenCode, and others, through one normalized interface, so you are not locked to a single backend. There is a digital employee board that makes agents visible and shareable across an org, a permission and approval system that puts a human checkpoint in front of sensitive actions, and full logging of everything an agent does. You can self-host it or use the hosted platform. This is early, and it is aimed at founder teams and small orgs that want to put agents to work without losing track of what they are doing. The audit trail and approval gates are the real draw; running multiple agents with no oversight gets dangerous fast. Self-host it for full control of the infrastructure, or take the hosted option if you would rather not run it yourself. The catch is maturity. This is a young project moving fast, and multi-agent coordination is still proving itself across the whole industry, not just here. The governance framing is genuinely useful, but expect rough edges, and verify the hosted tier's pricing before you depend on it, since that is not clearly published yet.
Free to self-host under Apache 2.0. A hosted platform exists for teams that don't want the ops, but its pricing isn't clearly published yet, so verify before you rely on it.
### What's Free The core platform. Apache 2.0 licensed, so you can self-host the whole thing (AgentRouter, the agent board, permissions, audit logging) at no licensing cost. No feature paywall is documented on the open-source side. ### Self-Hosted Run it on your own infrastructure for full control. As a young project it is moderate ops: expect to wire up the agent runtimes you use (Claude Code, Codex, OpenCode) and manage upgrades on a fast-moving codebase. ### Paid Cloud Option There is a hosted platform for teams that would rather not run the infrastructure. Pricing is not clearly published yet; confirm it before building a workflow around the hosted tier. ### vs Alternatives - **Single-agent setups (raw Claude Code, Codex)**: simpler, but no shared workspace or governance. - **CrewAI / AutoGen**: multi-agent orchestration libraries, more code-first, less of a managed workspace. - **AgentSpace**: leans into roles, approvals, and audit trails for teams.
Claude-peers-mcp is an MCP server that lets multiple Claude Code instances message each other in real time. If you run parallel Claude sessions (one on the frontend, one on the backend, one writing tests), this creates a direct communication channel between them so they can coordinate without you copy-pasting context between terminals. The way it works: you spin up the MCP server, connect each Claude Code instance to it, and they can send and receive messages from each other ad-hoc, like a group chat between your AI assistants. One session can ask another about an API contract it just wrote, or flag a dependency change that affects the other's work. It removes you as the bottleneck in multi-agent workflows. The catch: very new and tightly coupled to Claude Code's MCP ecosystem. It does not work with other AI agents or coding assistants. Coordinating AI sessions is still experimental territory, so expect rough edges and limited documentation. If you only run one Claude session at a time, you do not need this.
Free. Requires Claude Code (which has its own subscription).
Open source, no paid tier. Works as an MCP server within Claude Code. No separate hosting needed; it runs alongside your Claude Code sessions.
MiroFish-Offline runs multi-agent AI simulations and predictions completely offline using a Neo4j knowledge graph and Ollama for local LLM inference. It's a simulation engine where multiple AI agents interact, predict outcomes, and build up a knowledge base over time. This is niche but powerful for scenarios like market simulation, scenario planning, or research where you can't send data to external APIs. Everything runs locally: the database, the models, the agents. The catch: AGPL-3.0 license (if you modify it and offer it as a service, you must open source your changes). Requires Neo4j and Ollama running locally. That's a real setup commitment. And 'offline multi-agent simulation' is a small but growing niche.
Free for internal use. AGPL means service use requires open-sourcing your modifications.
Fully open source under AGPL-3.0. No paid tier, no hosted version. Everything runs on your machine. The AGPL license means if you modify it and offer it as a service, you must release your source code, but for internal use, it's completely free. You'll need Neo4j (free Community Edition works) and Ollama (free) installed locally.