Open Multi Agent
Open Multi-Agent: MIT-licensed TypeScript framework for self-hosted multi-agent orchestration with durable approvals and verifiable run
If your TypeScript team has to prove what an agent did, OMA is the strongest option here: durable approvals that survive process death plus a run journal you can verify offline byte by byte. It is not the quickest route to a demo, and anyone wanting Python, a hosted dashboard, or a visual canvas should look elsewhere. Plan for a learning curve on the runtime concepts.
Verified 4d ago · liveness 76/100 · cite: rightaichoice.com/tools/open-multi-agent
- TypeScript backend and AI platform teams shipping multi-agent workflows they must audit
- Regulated or security-sensitive automation needing durable approvals and a verifiable run record
- Projects orchestrating mixed cloud, local, or air-gapped models without vendor lock-in
- Engineers who want explicit DAG control alongside optional goal-driven planning
- Python, Java, or other non-TypeScript stacks — there's no cross-language SDK
- Teams shopping for a no-code or low-code agent builder with a visual canvas
- Buyers who want a managed cloud service, hosted dashboard, or vendor-run backend
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Open Multi-Agent if your team is not on TypeScript or you want a managed agent service handling hosting, monitoring, and scaling for you — OMA is a self-hosted library, not SaaS.
The MIT license covers the framework, but you pay your own model providers per token — a runTeam() goal that fans out to four agents can multiply provider spend against a single-agent call.
OMA is MIT-licensed at $0 for the framework, so its real cost is engineering time plus your own model-provider bill. That puts it well below per-seat commercial agent platforms for a TypeScript team with the skills to run a library, and roughly at parity with other open frameworks like LangGraph on software cost — where it differentiates is the governance surface, not the price.
In short
Open Multi Agent — Open Multi-Agent: MIT-licensed TypeScript framework for self-hosted multi-agent orchestration with durable approvals and verifiable run. Best for TypeScript backend and AI platform teams shipping multi-agent workflows they must audit, Regulated or security-sensitive automation needing durable approvals and a verifiable run record, Projects orchestrating mixed cloud, local, or air-gapped models without vendor lock-in. Free to use.
What's new in Open Multi Agent
Checked 3 days agoAcross the latest 2 updates: 1 feature update and 1 changelog entry.
v1.21.1 — runImage() documentation clarified
A documentation-only patch clarifying that an ImageModelError thrown by validate follows normal retry and model-fallback rules, while other error values propagate to the caller. No public API, runtime, or dependency changes.
v1.21.0 adds runImage() and image model adapters
v1.21.0 ships runImage() for chained image generation and editing, four built-in ImageModelAdapters (OpenAI, Seedream, OpenRouter, Black Forest Labs), normalized ImageModelError types, and adaptive thinking on Claude Opus 4.7 and Sonnet 5.
What people actually say about Open Multi Agent — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
44 mentions across 5 sources (Hacker News, YouTube, Product Hunt, GitHub, Lemmy) · researched Aug 3, 2026.
Average across the 5 sources that answered — each source counts once, not each post.
- +TypeScript-native with only 3 runtime dependencies — lightweight and portable.
- +Goal-driven coordinator auto-generates the task DAG, cutting boilerplate significantly.
- +Supports 13+ providers and any OpenAI-compatible endpoint — true mix-and-match.
- +Production guardrails: plan inspection, approval rounds, consensus passes, loop detection.
- +Opt-in tools/MCP servers give fine-grained control over agent capabilities.
- −Documentation is still catching up — advanced features lack clear guides.
- −OpenAI-compatible providers (DeepSeek, Mistral) may have tool-calling glitches.
- −Learning curve for runConsensus, approval rounds, and loop detection is steep.
- −Visual debugging tools are missing — tracing DAG execution is text-heavy.
- −Small ecosystem: few third-party integrations, mostly Vercel AI SDK.
- • No paid tiers, but self-hosting requires infrastructure (e.g., Docker) if you run local models.
- • Time investment for learning and integration is the real cost.
Viability Score
How well maintained and how widely used is Open Multi Agent? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Goal-driven coordination (runTeam) that plans a reviewable task DAG from a goal
- Explicit task graph execution (runTasks) with dependency-driven dispatch, no round barriers
- Single-agent execution (runAgent) with onTaskDispatch hooks for execution routing
- Durable approvals: suspend on plan, ready task, or tool call and decide later with decideApproval
- Append-only run journal with verifyRun() offline verification, returning inconclusive for evicted windows
- Declared governance via governanceIntent, requiredRoles, and requiredOrder judged from the execution receipt
- Adaptive recovery: checkpoint restore, replay of committed tool results, and PlanPatch in repairable mode
- Default-deny tool permissions with egressPolicy bounding built-in adapters
- Mixed model providers including Anthropic, OpenAI, Gemini, Bedrock, Azure OpenAI, DeepSeek, and Ollama
- runImage() for chained image generation and editing with OpenAI, Seedream, OpenRouter, and Black Forest Labs adapters
- Adaptive thinking on Claude Opus 4.7 and Sonnet 5 when thinking is enabled without an explicit budget (v1.21.0)
- OpenAI-compatible endpoint support for self-hosted and niche models
- MCP tool integration and external agents over ACP (Claude Code, Codex, Gemini CLI)
- Video input support via VideoBlock for MiniMax-compatible chat
- Offline Run Viewer with task DAG, assignees, model/token/cost rollups, and tool-call detail
About Open Multi Agent
Open Multi-Agent (OMA) is a self-hosted, MIT-licensed TypeScript runtime for multi-agent orchestration. Instead of a hosted control plane, it hands you a library: cloud, local, or air-gapped models run on your own credentials, with three runtime dependencies and no OMA backend or account in the loop. It targets TypeScript backend and AI platform teams shipping workflows they have to justify later — audit, compliance review, security analysis — not people hunting for a visual drag-and-drop builder. The runtime offers three orchestration shapes. runAgent() executes a single agent; runTasks() executes a graph you wrote yourself; runTeam() takes a goal and lets an optional coordinator plan a reviewable task DAG where ready dependents dispatch as soon as prerequisites finish, with no round barriers. Governance is the differentiator. Approval gates can suspend at the plan, task, or tool-call boundary, with the request persisted beside the checkpoint and bound to a hash of exactly what the reviewer was shown until another process calls decideApproval. Declared governance (governanceIntent with requiredRoles and requiredOrder) judges a run from its execution receipt, never from agent answer text. Evidence is the other half. Turn on the append-only run journal and verifyRun() reads a finished run back cold and offline, checking each block against its named source event and returning inconclusive — not a pass — for an evicted window. The offline Run Viewer turns a completed run into something reviewable: task DAG and assignees, model/token/cost rollups, tool calls. v1.21.0 added runImage() for chained image generation and editing across four built-in adapters (OpenAI, Seedream on Volcengine Ark, OpenRouter, Black Forest Labs), and adaptive thinking on Claude Opus 4.7 and Sonnet 5 when no explicit budget is set; v1.21.1 was a documentation patch clarifying ImageModelError retry behavior. Adoption is real but niche: roughly 7,000 GitHub stars, 2,438 forks, 59 contributors,
Behind the Verdict
The interesting thing about OMA isn't the orchestration API — runAgent, runTasks, and runTeam are straightforward enough. It's the assumption that a run will eventually be questioned. Approval requests persist next to the checkpoint, bound to a hash of what the reviewer actually saw, and wait for a separate process to decide. In practice that means a server restart doesn't vaporize your pending approval, which is more than most agent frameworks can say. Pick OMA when the workflow has consequences: security review, contract analysis, regulated back-office automation, anything where someone will ask six months later why the system did that. Declared governance (governanceIntent, requiredRoles, requiredOrder) is judged from the execution receipt, not from the model's prose — and a run can succeed while still reporting unsatisfied, which is the honest behavior you want. Pass when TypeScript isn't your stack. There's no cross-language SDK, and the Python ecosystem around LangGraph remains easier to staff and Google against. Pass too if you want a canvas, a managed cloud, or a vendor dashboard — OMA is deliberately a library with no backend and no telemetry. Watch the sharp edges. verifyRun() returns inconclusive rather than failure for an evicted window, so you need to decide up front what your CI does with a non-pass. recovery.mode: 'repairable' and PlanPatch only revise what hasn't run, which is the right constraint but narrows how much of a bad plan you can rescue. Tool use is default-deny with egressPolicy bounding built-in adapters, so expect setup work before the first real run. Cost control matters more with a coordinator fanning out parallel agents. maxCostBudget and the token/cost rollups in the Run Viewer are what keep a goal-driven team from spending like a
Researching Open Multi Agent? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Open Multi Agent actually fits — and what changes day-one when you adopt it.
Wire a contract-review DAG with runTasks(): parallel clause extraction feeds a compliance checker, which feeds a summarizer, with a default-deny tool policy so nothing can hit the network without an explicit grant.
Outcome: A reviewable DAG that produces a severity-ranked summary, with every node's tool calls bounded by egressPolicy and the whole run inspectable afterwards in the Run Viewer.
Put a durable approval on the tool call that files a ticket: the run suspends with { action: 'suspend' }, the request persists beside the checkpoint bound to a hash of what the reviewer saw, and a separate process calls decideApproval hours later.
Outcome: A consequential action that cannot execute until a human approves it — and an approval record that binds to exactly the content that was reviewed, not to a mutable message.
Use runTeam() against a goal ('review this service for security vulnerabilities'), let the coordinator decompose it into attack-surface, data-security, and supply-chain reviewers, then turn the run journal on and run verifyRun() after hours to check each block against its source event.
Outcome: A parallel security review plus a run journal that verifies cold and offline, returning inconclusive for any evicted window rather than a false pass.
Use Cases
- Build adaptive customer support that routes to specialist agents based on the goal
- Run contract review with parallel clause extraction, compliance check, and summary
- Automate incident postmortems with parallel investigations feeding root-cause analysis
- Create a fully local multi-agent team using Ollama at zero API cost
- Add multi-agent orchestration to an existing Vercel AI SDK app via a Next.js API route
- Decompose a complex research goal into a task DAG with mixed-model agents
- Run parallel meeting summarization with specialist agents for actions, sentiment, and topics
- Conduct security vulnerability review with parallel attack-surface, data-security, and supply-chain analysis
Models Under the Hood
as of 2026-10-18
Limitations
- Open Multi-Agent is an MIT-licensed TypeScript framework that you self-host, running in your own environment with cloud providers, local models, or fully offline.
- You handle the infrastructure yourself, and the runtime is TypeScript-native, so adopting it as-is requires TypeScript experience.
- It is maintained by YuanASI with community contributions (59 contributors, 7,004 GitHub stars per the about page), and direction is set publicly through GitHub issues and releases.
- The latest release listed is v1.21.3 (Oct 16, 2026), a security fix for a file_write symlink sandbox escape (CVE-2026-108600) affecting versions 1.5.0 through 1.21.2.
as of 2026-10-07
Verification history
We have re-verified Open Multi Agent 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Open Multi Agent tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
MIT License
$0/mo
Ideal for
TypeScript backend and AI platform teams that will self-host, and who value owning the runtime over paying a vendor to run it.
What this tier adds
Starting tier — the entire runtime under MIT at $0, with your only hard costs being model-provider tokens and the infrastructure you run it on.
Where the pricing makes sense
The company stage and team size where Open Multi Agent's pricing actually pencils out — and where peers do it cheaper.
OMA is MIT-licensed at $0 for the framework, so its real cost is engineering time plus your own model-provider bill. That puts it well below per-seat commercial agent platforms for a TypeScript team with the skills to run a library, and roughly at parity with other open frameworks like LangGraph on software cost — where it differentiates is the governance surface, not the price.
Setup time & first value
How long it actually takes to get something useful out of Open Multi Agent — broken out by persona, not the marketing-page minute.
A TypeScript backend engineer who already has an app and a model key can get a first run going in the same afternoon: the quick-start walks a real task DAG with no API key, then a one-line switch to a real model. The platform lead wiring durable approvals and declared governance into an existing pipeline should budget days, not hours, because the reviewer path and decideApproval endpoint are
Switching to or from Open Multi Agent
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From a hand-rolled async orchestrator: replace bespoke promise chaining with runTasks() and keep your existing agent prompts as node definitions.
- →From LangChain/LangGraph (JavaScript): port the graph into OMA task definitions and gain dependency-driven dispatch plus the run journal, at the cost of rewriting the state plumbing.
- →From a hosted agent platform: move the agent logic into a self-hosted OMA runtime on your own credentials and providers, then stand up your own monitoring and log storage.
- →From single-agent scripts: start with runAgent() and graduate to runTeam() only when the goal genuinely needs multiple specialists.
- ↗To LangGraph (Python): rewrite agents in Python to join the larger Python agent ecosystem, trading OMA's governance surface for ecosystem breadth.
- ↗To a hosted agent platform: hand the runtime, scaling, and dashboards to a vendor when self-hosting stops being worth the engineering time.
- ↗To a no-code builder: adopt a visual canvas when the people maintaining the workflow are not engineers.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Open Multi Agent”, and we withheld 6: 6 did not mention Open Multi Agent. We are showing none, because we could not prove any of them are about Open Multi Agent.
Official links
Tools that pair well with Open Multi Agent
Common stack mates teams adopt alongside Open Multi Agent, with the specific reason each pairing earns its keep.
Featured Head-to-Head Comparisons
Open Multi Agent vs Locus Robotics
These tools are not direct competitors. Locus Robotics is a physical warehouse automation solution for high-volume eCommerce and 3PL operations, requiring a RaaS subscription. Open Multi-Agent is a free open-source TypeScript framework for orchestrating AI agents with goal-driven DAG generation. Choose Locus if you need to move physical goods faster; choose OMA if you need to coordinate LLM-based software agents.
Open Multi Agent vs Presto Voice
Presto Voice and Open Multi-Agent serve completely different needs. Presto is a specialized, enterprise-scale drive-thru voice AI for QSR chains seeking revenue lift and operational efficiency—backed by new adoptions like Dairy Queen. Open Multi-Agent is a free, open-source TypeScript framework for developers building multi-agent systems with any LLM, offering cutting-edge goal decomposition and local execution. Choose Presto if you run a chain of drive-thrus; choose Open Multi-Agent if you build software agents.
Open Multi Agent vs Truleo
Choose Truleo if you're a law enforcement agency needing to unify siloed data for investigations. Choose Open Multi-Agent if you're a TypeScript developer building a multi-agent system and want free, flexible orchestration. These tools serve entirely different markets—no direct overlap.
Alternatives to Open Multi Agent
View all
OpenAI Agents SDK
A free, MIT-licensed Python framework from OpenAI for building multi-agent workflows with handoffs, guardrails, and tracing.
Popular in Agent Frameworks & Orchestration
Temporal AI
Durable execution platform that keeps AI agents and long-running workflows alive through crashes, retries, and abandoned sessions.
Frequently Asked Questions
Categories
Best-of guides
Topics
Used Open Multi Agent? Help shape our editorial sentiment research.