open-multi-agent

Project Url: JackChen-me/open-multi-agent

Introduction: TypeScript multi-agent framework — one runTeam() call from goal to result. Auto task decomposition, parallel execution. 3 dependencies, deploys anywhere Node.js runs.

More: Author ReportBugs

Tags:

Open Multi-Agent

Describe the goal, not the graph.
Multi-agent orchestration that runs in your own environment.

Website · Docs · npm · Discussions

English · 中文

open-multi-agent is an AI agent orchestration framework for TypeScript backends that drops into any Node.js app. It runs dynamic workflows: a coordinator turns one goal into a task DAG at runtime, a deterministic scheduler executes it across the team, and the whole run stays data you can inspect, approve, and replay. The dashboard above is the built-in offline Run Viewer replaying a real run.

Requires Node.js 20 or newer. For production, use a currently maintained Node.js LTS release.

Scaffold a PR review agent, security analysis agent, or teaching DAG:

npm create oma-app@latest my-oma

In an interactive terminal, that one command selects a starter and runtime, installs dependencies, and runs a deterministic local demo. The demo needs no API key and makes no model request: scripted model responses drive the real OMA scheduler, result aggregation, and offline dashboard. The Core package guide covers the flags and runtime choices.

Or add OMA to an existing backend:

npm install @open-multi-agent/core

import { OpenMultiAgent } from '@open-multi-agent/core'

const model = process.env.OMA_MODEL ?? 'gpt-5.4'

const oma = new OpenMultiAgent({ defaultProvider: 'openai', defaultModel: model })

const team = oma.createTeam('research-team', {
  name: 'research-team',
  agents: [
    { name: 'researcher', systemPrompt: 'Find the relevant facts.' },
    { name: 'analyst', systemPrompt: 'Compare evidence and identify tradeoffs.' },
  ],
  sharedMemory: true,
})

const result = await oma.runTeam(team, 'Compare three approaches and recommend one.')

// Nothing above declares a task graph. The coordinator planned one at runtime,
// and the finished run is data you can read back.
for (const task of result.tasks ?? []) {
  console.log(`[${task.status}] ${task.title} → ${task.assignee ?? 'unassigned'}`, task.dependsOn)
}

console.log(result.agentResults.get('coordinator')?.output)
console.log(result.totalTokenUsage)

Set OPENAI_API_KEY to run this example. Providers covers other hosted models, local servers, OpenAI-compatible endpoints, and AI SDK providers.

runTeam() plans from a goal, runAgent() runs a single agent, and runTasks() executes an explicit pipeline. The Core package guide walks through all three modes, provider and credential setup, and the production checklist. The example index lists 50+ runnable examples across basics, cookbook workflows, patterns, providers, and integrations.

Why OMA

OMA combines dynamic orchestration with the control, evidence, and recovery paths needed to move multi-agent systems from prototype to production.

Dynamic orchestration. Describe the goal and let the coordinator build the task DAG, assign work, and synthesize the result at runtime. There is no hand-wired graph to maintain.
Controlled execution. Preview and approve plans or individual dispatches and freeze approved plans for replay. Declare required roles and order when topology cannot drift, and verify outputs with multi-agent consensus.
Reliability. Resume interrupted runs from checkpoints, or opt into append-only plan repair at task outcome barriers. Retries, timeouts, loop detection, and token and cost budgets keep execution bounded.
Observability and evaluation. Follow each run through stable identity, execution receipts, and traces. Replay the task DAG and span waterfall in the offline Run Viewer, or export through the optional OpenTelemetry adapter. The same records feed versioned EvalSets, offline reports, CI gates, and production sampling.
Safety and privacy. Tools are default-deny, individual calls are gated, and explicit privacy controls apply to telemetry and persisted state.
Open runtime. Process and ACP backends put Claude Code, Gemini CLI, and Codex on the same task DAG, shared memory, and budgets as LLM agents. Mix cloud and local models, natively integrated Chinese providers, OpenAI-compatible endpoints, and AI SDK providers, with a fallback parser for local models that emit tool calls as text. Run on your own infrastructure and credentials, locally, offline, or air-gapped.

Built with OMA

open-multi-agent launched 2026-04-01 under MIT. Known users and integrations to date:

temodar-agent by Ali Sünbül. WordPress security analysis platform running OMA's built-in tools (bash, file_*, grep) inside a Docker runtime. Confirmed production use.
Mark Galyan runs OMA fully offline on local quantized models, using the coordinator and context compaction to keep autonomous agent loops alive under tight VRAM limits. Contributor since the framework's first month.
PR-Copilot by kidoom. AI pull-request review assistant running an OMA review team, with defineTool repo-context tools and a custom ContextStrategy for token-aware diff compression.
StuFlow by znc15. Terminal AI coding assistant on OMA's orchestration core, driving runAgent / runTasks / runTeam with a custom coordinator, paired with DeepSeek.
Reports to Charts Studio. Turns documents and research tables into slide-ready charts, using a five-role extraction council with structured outputs and deterministic validation.

Integrations

Engram: "Git for AI memory." Syncs knowledge across agents instantly and flags conflicts. (repo, ~80 stars)
@agentsonar/oma: Sidecar detecting cross-run delegation cycles, repetition, and rate bursts.
CodingScaffold: Agentic-coding scaffold that lists OMA as an optional orchestration backend, with a runTeam workflow template.
Bilig WorkPaper: Formula-workbook MCP server with a reciprocal OMA integration for editing inputs, recalculating formulas, verifying readback, and persisting WorkPaper JSON.
baize-oma: HTTP adapter exposing OMA runAgent() and runTeam() as Baize slot capabilities.

Using open-multi-agent in production or a side project? Open a discussion and we will list it here. Built an integration? The integration guide covers how to get listed. For a deep integration, see the Featured partner program.

When OMA fits

OMA is designed for TypeScript teams that want the task graph to emerge from the goal at runtime.

Choose a graph-first framework when the workflow must be authored node by node. Use an LLM toolkit alone when one agent call is enough. OMA sits at the orchestration layer when several agents, dependencies, approvals, or recovery steps must work together.

For a named head-to-head against LangGraph, Mastra, CrewAI, the Vercel AI SDK, and others, see the comparison page.

Packages

@open-multi-agent/core: Orchestration runtime, tools, memory, checkpoints, traces, CLI, and offline Run Viewer.
@open-multi-agent/otel: Optional enterprise integration for production teams with a centralized OpenTelemetry stack.
create-oma-app: Scaffolder behind npm create oma-app; starter templates with a no-key local demo.

Core users can store traces locally and inspect them with the offline Run Viewer. Install the OTel package only when OMA traces should appear in the same monitoring system as the rest of your application.

Commercial support

Need to embed agent capabilities in an existing product or business system? We help teams scope AI use cases, embed agent capabilities, and support delivery. Email jack@yuanasi.com.

Documentation

Goal	Start here
Install and run	Core package guide · Examples · CLI
Configure models and tools	Providers · Tools and sandbox · External agents
Operate reliably	Observability · Evaluation · Checkpoint and resume · Adaptive recovery · Context management
Control orchestration	Consensus · Execution routing · Model routing · Task scheduling · Plan replay · Shared memory