# Open Multi-Agent

> TypeScript-native AI Agent framework for multi-agent orchestration. Describe a goal and a coordinator agent turns it into a task DAG, parallelizes the independent nodes, and synthesizes a typed, schema-validated result. Drops into any Node.js backend.

Open Multi-Agent (OMA) is a goal-driven agent runtime for TypeScript backends. Instead of wiring a graph of nodes and edges ahead of time, you hand it a goal: a coordinator agent decomposes the goal into a task DAG at runtime, runs the independent nodes in parallel, and returns a typed, schema-validated result. Every agent in a team can name its own model (Anthropic, OpenAI, Gemini, Bedrock, Azure OpenAI, DeepSeek, a local Ollama, or any OpenAI-compatible endpoint), and they cooperate inside one team. Tools and Model Context Protocol (MCP) servers follow a default-deny contract: an agent gets only the capabilities it is granted. The core stays lean — three runtime dependencies — and extra providers, MCP, and the Vercel AI SDK bridge load only when you opt in.

- Install: `npm create oma-app@latest`
- Package: `@open-multi-agent/core` (npm)
- Latest release: v1.14.0
- License: MIT
- Runtime: Node.js 20+ (Node 18 reached end of life on 2025-04-30), three runtime dependencies (Anthropic SDK, OpenAI SDK, Zod)

## Capabilities

- **Goal or explicit DAG**: use `runTeam()` when a coordinator should decompose an outcome, or `runTasks()` when your application already owns the graph.
- **Execution routing and governance**: choose `single` or `team` explicitly, install an `ExecutionRouter`, or declare required roles and order. Automatic routing is deterministic by default; `strategy: 'hybrid'` (v1.14, opt-in) adds at most one no-tool model call that returns a structured task profile for a deterministic policy to consume — the model never picks the topology. The result carries the routing decision and governance conclusion.
- **Event-driven scheduling**: ready tasks dispatch as soon as dependencies complete, with scheduling policies, hard capability requirements, task priority, per-task approval, structured handoffs, and task-scoped results.
- **Adaptive plan recovery**: `recovery.mode: 'repairable'` (v1.14, opt-in) lets a `Replanner` append, retarget, or supersede tasks that have not started, on an outcome barrier, under `onPlanPatch` approval and explicit limits. Repairs are forward-only and append-only — history stays truthful in `result.tasks` and `result.planRevisions`, and `runFromPlan()` rejects repairable recovery because it is exact replay.
- **Fail closed on invalid input**: an invalid task dependency graph, a coordinator plan that failed validation, and task requirements no agent satisfies are all rejected up front (v1.14) instead of executing a partially valid plan.
- **Mix any model in one team**: each agent names its own model. Use built-in providers such as Anthropic, OpenAI, Gemini, Bedrock, Azure OpenAI, and DeepSeek, or any OpenAI-compatible endpoint.
- **Tools and MCP, default-deny**: an agent gets only the tools it is granted. Model Context Protocol servers expose external systems under the same opt-in contract.
- **Streaming and structured output**: stream tokens and node-state transitions as the DAG fills, or await a typed, schema-validated object when the run completes.
- **Cross-provider reasoning**: one thinking config maps to Anthropic thinking, Gemini thinkingConfig, and OpenAI reasoning_effort. Reasoning streams as events, and can be preserved across a provider switch when you opt in.
- **You hold the controls**: inspect the plan (`onPlanReady`), approve one task dispatch (`onTaskDispatch`) or a legacy round (`onApproval`), gate consequential tools (`onToolCall`), verify with `runConsensus`, and cap usage with `maxTokenBudget` or `maxCostBudget` + the application-owned `estimateCost`. Budget checks happen at boundaries, so a run can cross a ceiling by one in-flight model turn.
- **Inspect, persist, and export runs**: task results, routing decisions, execution receipts, TraceRecord v2 stores, the offline Run Viewer, and the optional first-party OpenTelemetry bridge keep evidence inspectable. Telemetry redaction is best-effort; checkpoint and shared-memory values require an explicit persisted-store policy.
- **External agents and evaluation**: run a local process or an ACP coding agent as a member of the same task DAG, and measure completed runs with versioned EvalSets, scorers, CI gates, and best-effort production sampling through `@open-multi-agent/core/eval`.

## Docs

- [Capabilities](https://open-multi-agent.com/capabilities/): the released runtime surface, from goal or DAG through routing, scheduling, governance, recovery, and evidence.
- [Introduction](https://open-multi-agent.com/getting-started/introduction/): what open-multi-agent is, how goal-first orchestration differs from graph-first frameworks, and how the runtime is structured.
- [Quick Start](https://open-multi-agent.com/getting-started/quick-start/): scaffold a project with npm create oma-app, or install the core package and run your first auto-orchestrated team.
- [Three Ways to Run](https://open-multi-agent.com/getting-started/three-ways-to-run/): runAgent, runTeam, and runTasks — plus plan preview, plan replay, and consensus verification.
- [Orchestration Controls](https://open-multi-agent.com/guides/orchestration-controls/): execution topology, declared governance, task dispatch, consequential-tool gates, cancellation, coordinator config, and fan-out.
- [Control costs and budgets](https://open-multi-agent.com/guides/cost-budget-control/): bound a run with maxTokenBudget or maxCostBudget and a caller-owned estimateCost function.
- [Production Checklist](https://open-multi-agent.com/guides/production-checklist/): token budget, timeouts, retries, tool-output limits, loop detection, tracing, and tool grants.
- [Architecture](https://open-multi-agent.com/architecture/): how OMA works — the architecture and the runTeam() execution flow, from a goal to a task DAG to a synthesized result.

## Reference

- [Execution routing](https://open-multi-agent.com/reference/execution-routing/): choose single-agent or team execution through explicit modes, governance policy, custom routers, and auditable decisions.
- [Task scheduling and dispatch](https://open-multi-agent.com/reference/task-scheduling/): event-driven DAG execution, scheduling strategies, structured requirements and handoffs, priority, metadata, and approval modes.
- [Providers](https://open-multi-agent.com/reference/providers/): configure hosted, cloud, and local model providers — built-in shortcuts, OpenAI-compatible endpoints, env vars, and local tool-calling.
- [Tool configuration](https://open-multi-agent.com/reference/tool-configuration/): grant built-in tools (default-deny), presets and allowlists, the filesystem sandbox, custom tools, and MCP.
- [Observability](https://open-multi-agent.com/reference/observability/): TraceRecord v2 sinks, TraceStore implementations, optional OpenTelemetry export, and the offline post-run Run Viewer.
- [Observability migration](https://open-multi-agent.com/reference/observability-migration/): move from onTrace to sinks, stores, and OpenTelemetry in reversible stages without changing runtime results.
- [Observability performance](https://open-multi-agent.com/reference/observability-performance/): reproducible performance budgets, benchmark method, and the current release snapshot.
- [Shared memory](https://open-multi-agent.com/reference/shared-memory/): a namespaced key-value store shared across a team, in-process or via a custom MemoryStore backend.
- [Checkpoint & resume](https://open-multi-agent.com/reference/checkpoint/): opt-in per-run snapshots over any MemoryStore — persist task progress and resume after a crash, abort, or restart with restore().
- [Adaptive recovery](https://open-multi-agent.com/reference/adaptive-recovery/): revise the not-yet-executed part of a task graph after an outcome, with validated, approvable, append-only plan patches.
- [Plan preview & replay](https://open-multi-agent.com/reference/plan-replay/): freeze a reviewed task DAG with createPlanArtifact and execute it later with runFromPlan without calling the coordinator again.
- [Context management](https://open-multi-agent.com/reference/context-management/): keep long runs under the token ceiling with context strategies, tool-result compression, and cross-provider reasoning.
- [Consensus](https://open-multi-agent.com/reference/consensus/): runConsensus proposer-to-judge verification, the per-task verify hook, and the shared token-budget invariant.
- [Model routing](https://open-multi-agent.com/reference/model-routing/): opt-in deterministic policy that routes orchestration phases to different models by phase, agent, task role, priority, or leaf.
- [External agents](https://open-multi-agent.com/reference/external-agents/): run local processes or ACP coding agents inside an OMA task DAG, with explicit permission, usage, and lifecycle boundaries.
- [Evaluation](https://open-multi-agent.com/reference/evaluation/): version EvalSets and scorers, persist results, gate CI, and sample completed production runs without changing business results.
- [CLI](https://open-multi-agent.com/reference/cli/): the JSON-first oma binary for shell and CI — commands, config files, output, and exit codes.

## Solutions

Use-case guides — the common shapes teams build with OMA, each with runnable TypeScript. Hub: [Solutions](https://open-multi-agent.com/solutions/).

- [Run LLM calls in parallel](https://open-multi-agent.com/solutions/parallel-llm-calls/): several specialist agents work at once, return typed output, and an aggregator merges them — the coordinator handles the fan-out.
- [Goal-driven orchestration](https://open-multi-agent.com/solutions/goal-driven-orchestration/): describe the goal instead of wiring the graph; the coordinator decomposes it into a task DAG at runtime and parallelizes it.
- [Mixed-model agent teams](https://open-multi-agent.com/solutions/mixed-model-teams/): each agent names its own provider — Claude, GPT, Gemini, or a local model — cooperating in one run, with cost and latency you can watch.
- [Local agents with Ollama](https://open-multi-agent.com/solutions/local-agents-ollama/): run a multi-agent team fully on your own machine — even the coordinator on a local model, at $0 API cost — or a hybrid that bursts to the cloud.
- [Durable shared memory](https://open-multi-agent.com/solutions/agent-memory/): MemoryStore persists namespaced key-value state and completed-task checkpoints across runs; semantic recall requires a separate memory layer.
- [Vercel AI SDK orchestration](https://open-multi-agent.com/solutions/vercel-ai-sdk-orchestration/): add multi-agent orchestration to an existing AI SDK app; the SDK talks to models while runTeam() decomposes the goal.

## Integrations

Per-provider setup — one env var and a model name to run a team on each. Hub: [Integrations](https://open-multi-agent.com/integrations/).

- [OpenTelemetry](https://open-multi-agent.com/integrations/opentelemetry/): map TraceRecord v2 spans through the optional createOtelTraceSink() adapter to a tracer or provider owned by your application.
- [External agents (ACP)](https://open-multi-agent.com/integrations/external-agents/): put Claude Code or another external coding agent inside the task DAG; permission prompts do not make the subprocess an OMA filesystem sandbox.
- [Anthropic Claude](https://open-multi-agent.com/integrations/anthropic/): Claude via the native Anthropic SDK — set ANTHROPIC_API_KEY and name the model.
- [OpenAI GPT](https://open-multi-agent.com/integrations/openai/): GPT models via the OpenAI API — the default provider, one env var away.
- [Google Gemini](https://open-multi-agent.com/integrations/gemini/): Gemini via the native Google GenAI SDK — one extra install, one env var.
- [DeepSeek](https://open-multi-agent.com/integrations/deepseek/): a built-in, OpenAI-compatible provider — a common pick for cheap, high-volume steps.
- [AWS Bedrock](https://open-multi-agent.com/integrations/bedrock/): Bedrock via the AWS credential chain — no API key; serves Claude, Llama, Mistral, and Cohere.
- [Azure OpenAI](https://open-multi-agent.com/integrations/azure-openai/): Azure OpenAI as a built-in provider — key and endpoint from env.
- [Ollama (local)](https://open-multi-agent.com/integrations/ollama/): a fully local team — no API key, point the base URL at your Ollama server.
- [Any OpenAI-compatible endpoint](https://open-multi-agent.com/integrations/openai-compatible/): Groq, OpenRouter, vLLM, LM Studio, and more via a baseURL.

## Blog

- [Open Multi-Agent v1.14: Repair the Plan, Keep the Record](https://open-multi-agent.com/blog/v1-14-adaptive-recovery-hybrid-routing/): adaptive plan recovery, opt-in hybrid semantic execution routing, DeepSeek V4 Flash reasoning controls, fail-closed validation, and Node.js 20 as the new floor.
- [Best TypeScript Multi-Agent Frameworks in 2026: Choose by Workflow](https://open-multi-agent.com/blog/best-typescript-multi-agent-frameworks-2026/): a source-backed guide to six TypeScript options matched to explicit graphs, agent UIs, handoffs, routed networks, all-in-one apps, and goal-driven task DAGs — a fit guide, not a ranking.
- [Competitive Monitoring: Isolate Each Source Before Comparing Them](https://open-multi-agent.com/blog/competitive-monitoring-contradiction-detection/): one agent per source and typed claims out of each, so contradictions between a vendor post, a community thread, and a news article survive to the report instead of being smoothed away.
- [Support Tickets: A Fixed Pipeline and a Routed Agent Team](https://open-multi-agent.com/blog/customer-support-routing-playbook/): keep the high-volume path on a typed classify → draft → QA graph, let escalations get a coordinator-built team, and put the refund behind a confirmation gate the runtime enforces per call.
- [Incident Postmortems: Parallel Investigation, Serial Judgment](https://open-multi-agent.com/blog/incident-postmortem-parallel-investigation/): logs, deployments, and blast radius start together in a runTasks() DAG, stay unmerged in taskResults, and reach the analyst as validated structured payloads rather than prose.
- [Five Seams That Decide Whether a Workflow Needs a Team](https://open-multi-agent.com/blog/multi-agent-application-patterns-field-note/): find the seams in the work before naming agents — five boundaries that keep reappearing across the runnable recipes, each with a specific runtime mechanism behind it.
- [Translation Drift: Route the Back-Translation to Another Model](https://open-multi-agent.com/blog/translation-quality-cross-model-review/): translate with one provider, back-translate with another through a model-routing rule, and measure the reviewer itself with a versioned EvalSet.
- [Open Multi-Agent v1.13: Route, Govern, Schedule, and Prove the Run](https://open-multi-agent.com/blog/v1-13-execution-routing-governance-scheduling/): execution routing, declared governance, consequential-tool confirmation, event-driven task scheduling, task-scoped results, structured handoffs, and retryable model fallbacks.
- [Open Multi-Agent v1.12.1: Evaluation, Offline Inspection, and a No-Key First Run](https://open-multi-agent.com/blog/v1-12-1-evaluation-zero-key/): versioned EvalSets, scorers, CI gates, online sampling, richer offline run inspection, and a deterministic create-oma-app demo that needs no API key.
- [A 100% Local Multi-Agent Team in TypeScript (Ollama + Gemma, $0 API Cost)](https://open-multi-agent.com/blog/local-multi-agent-team-ollama-gemma/): run a multi-agent team fully on your laptop — even the coordinator is a 5B Gemma over Ollama — with a real per-agent ledger and a hybrid cloud+local variant.
- [From Transcript to Typed Action Items: Three Parallel Agents in TypeScript](https://open-multi-agent.com/blog/meeting-summarizer-parallel-agents/): three specialist agents run in parallel — two return typed Zod output — and a fourth aggregates them into one meeting report.
- [Goal In, DAG Out: How Open-Multi-Agent Turns a Goal into a Task DAG](https://open-multi-agent.com/blog/goal-to-task-dag-coordinator/): how runTeam() hands a goal to a coordinator that builds the task DAG for you, with the mechanism step by step.
- [Give Your TypeScript AI Agents Long-Term Memory with TencentDB-Agent-Memory](https://open-multi-agent.com/blog/agent-long-term-memory-tencentdb/): wiring OMA's MemoryStore to TencentDB-Agent-Memory for a measured cross-run agent memory loop.
- [Goal-Driven Agent Orchestration vs Explicit Graphs: A TypeScript Framework Taxonomy](https://open-multi-agent.com/blog/goal-driven-vs-explicit-graphs/): a taxonomy that compares where a framework places the decomposition cost — runtime tokens vs design-time code.
- [5 walls multi-agent frameworks hit](https://open-multi-agent.com/blog/multi-agent-framework-walls/): the engineering walls frameworks hit, with receipts from Mastra's year-long .network() → Supervisor migration.
- [How to Run a Mixed-Model AI Agent Team in TypeScript?](https://open-multi-agent.com/blog/mixed-model-agent-team/): a walkthrough from a single-model baseline to a mixed-provider team with live cost and latency monitoring.
- [Adding Multi-Agent Orchestration to a Vercel AI SDK App](https://open-multi-agent.com/blog/multi-agent-vercel-ai-sdk/): layering OMA orchestration onto an existing Vercel AI SDK app, sharing a single Next.js API route.

## Changelog

- [Changelog](https://open-multi-agent.com/changelog/): the full release history of `@open-multi-agent/core`, newest first — additions, breaking changes, published package versions, and upgrade notes, mirrored from the GitHub releases. Per-release anchors follow the version, e.g. `/changelog/#v1-14-0`.

## Compare

Honest, sourced comparisons against the main multi-agent frameworks — language, orchestration model, runtime dependencies, token-budget control, and observability, with a fair account of when the other tool is the better choice. Hub: [Compare](https://open-multi-agent.com/compare/).

- [open-multi-agent vs LangGraph](https://open-multi-agent.com/compare/langgraph/): goal-first task-DAG decomposition vs a declarative state graph; TypeScript-native with 3 dependencies and run-level token or estimated-cost ceilings vs LangGraph's deeper persistence and time-travel ecosystem.
- [open-multi-agent vs CrewAI](https://open-multi-agent.com/compare/crewai/): a lean 3-dependency TypeScript runtime vs a batteries-included Python framework of role-based crews; comparable orchestration surface, the choice is the language stack.
- [open-multi-agent vs AutoGen](https://open-multi-agent.com/compare/autogen/): goal-driven TypeScript orchestration vs conversation-driven Python agents (AutoGen is now in maintenance mode, superseded by the Microsoft Agent Framework).
- [open-multi-agent vs the OpenAI Agents SDK](https://open-multi-agent.com/compare/openai-agents-sdk/): provider-neutral, goal-driven orchestration with run-level token or estimated-cost ceilings vs a lightweight, handoffs-based SDK with best-in-class built-in tracing.
- [open-multi-agent vs Mastra](https://open-multi-agent.com/compare/mastra/): a lean 3-dependency goal-driven runtime vs a batteries-included TypeScript framework (workflows, memory, RAG, evals; ~32 core deps built on the Vercel AI SDK).
- [open-multi-agent vs the Vercel AI SDK](https://open-multi-agent.com/compare/vercel-ai-sdk/): different layers — the AI SDK is a lean single-agent toolkit (3 deps); OMA is goal-driven multi-agent orchestration on top, and can run over the AI SDK.
- [open-multi-agent vs VoltAgent](https://open-multi-agent.com/compare/voltagent/): a lean 3-dependency core vs an observability-first framework with a bundled OpenTelemetry stack and supervisor/sub-agent networks (~44 core deps).
- [open-multi-agent vs Inngest AgentKit](https://open-multi-agent.com/compare/inngest-agentkit/): runtime goal decomposition vs deterministic, state-based routing over agent networks running on Inngest.
- [open-multi-agent vs LangChain](https://open-multi-agent.com/compare/langchain/): a lean, goal-driven TypeScript runtime vs the broad LangChain framework and ecosystem (its multi-agent orchestration lives in LangGraph).
- [open-multi-agent vs LlamaIndex](https://open-multi-agent.com/compare/llamaindex/): orchestration-first TypeScript vs a RAG/data-first Python framework that grew agent workflows.
- [open-multi-agent vs Pydantic AI](https://open-multi-agent.com/compare/pydantic-ai/): goal-driven TypeScript orchestration vs a type-safe Python agent framework with first-class OpenTelemetry (Logfire) and a token-usage limit.
- [open-multi-agent vs Google ADK](https://open-multi-agent.com/compare/google-adk/): a lean, provider-neutral TypeScript runtime vs a code-first Python toolkit with explicit workflow agents and a Vertex AI deploy path.
- [open-multi-agent vs Semantic Kernel](https://open-multi-agent.com/compare/semantic-kernel/): TypeScript-native goal-driven orchestration vs Microsoft's C#-first enterprise SDK, now converging into the Microsoft Agent Framework.
- [open-multi-agent and Claude Code's dynamic workflows](https://open-multi-agent.com/compare/claude-dynamic-workflows/): the same bet — the model plans the work at runtime — in two form factors; dynamic workflows run inside Claude Code, OMA is an MIT TypeScript library that runs the goal-to-DAG idea in your own backend, on any model.

## Project

- [GitHub repository](https://github.com/open-multi-agent/open-multi-agent): source, examples, and issues.
- [Examples by goal](https://open-multi-agent.com/examples/): start here, use-case recipes, orchestration, production controls, stack integrations, and models/providers.
- [Showcase](https://open-multi-agent.com/showcase/): open-source projects built with OMA and tools that integrate with it.
- [npm package](https://www.npmjs.com/package/@open-multi-agent/core)

## Optional

- [Full text for LLMs](https://open-multi-agent.com/llms-full.txt): capabilities, use cases, comparisons, and FAQ assembled into one document.