Open Multi Agent
From a goal to a task DAG, automatically. TypeScript-native multi-agent orchestration.
Last verified:
What is Open Multi Agent?
Open Multi Agent is a TypeScript-native multi-agent orchestration framework designed to automate complex AI workflows with a single function call. The core innovation is its goal-driven coordinator that automatically decomposes high-level goals into a task DAG (Directed Acyclic Graph), parallelizes independent tasks, and synthesizes final results. Developed by JackChen and released under MIT license on March 31, 2026, it has rapidly gained over 6,000 GitHub stars.
Open Multi Agent pricing
Pricing model: Freemium
Open Multi-Agent is completely free and open-source under the MIT license. There are no paid tiers, subscription plans, or usage-based pricing. The framework can be installed via npm: npm install @jackchen_me/open-multi-agent. Users only pay for the LLM API costs from their chosen providers (Anthropic, OpenAI, Gemini, etc.) and any infrastructure costs for running Node.js. Token budgets are configurable by the user to control spending, but the framework itself has no cost.
Open Multi Agent pros
- Single runTeam() call from goal to result
- Automatic task DAG decomposition from goals
- Parallel execution of independent tasks
- 10 native LLM adapters supported
- Supports mixing different providers in one team
- Only 3 runtime dependencies (minimal footprint)
- TypeScript-native (no Python required)
- Built-in MCP integration for external tools
- 6 built-in tools (bash, file operations, grep, glob)
- Token-by-token streaming on all adapters
- Zod-validated structured outputs with auto-retry
- Live observability with onProgress and onTrace events
- Post-run HTML dashboard for task DAG visualization
- Pluggable shared memory (Redis, Postgres, in-process)
- Supports local models via Ollama, vLLM, LM Studio
- Plan-only mode to preview task DAG without execution
- Context management strategies (sliding-window, summarize, compact)
- Per-task retry with backoff and loop detection
- Token budget controls to cap spend
- MIT license (open source)
- CLI with JSON-first binary for shell/CI
- Active community (6k stars, 2.3k forks)
- Extensive examples and cookbook workflows
Open Multi Agent cons
- TypeScript/Node.js only (no Python support)
- Requires Node.js >= 18 (not compatible with older versions)
- Relatively new project (launched March 2026)
- Limited production case studies compared to established frameworks
- No built-in checkpointing like LangGraph
- Manual workflow wiring needed for complex production topology
- Local model tool-calling can be unreliable with some models
- Highly quantized MoE models may cause repetition loops
- Some providers require additional npm packages (Gemini, Bedrock)
- Learning curve for DAG-based orchestration concepts
- No native checkpointing for long-running workflows
- MCP integration is opt-in rather than default
Frequently asked questions about Open Multi Agent
What is Open Multi-Agent and what problem does it solve?
Open Multi-Agent is a TypeScript-native multi-agent orchestration framework that automatically decomposes high-level goals into task DAGs and orchestrates execution. It solves the complexity of manually coordinating multiple AI agents by providing a single runTeam() function call where you describe the goal and the framework handles task decomposition, parallelization, and result synthesis.
How does automatic task decomposition work?
When you call runTeam(team, goal), a coordinator agent analyzes the goal and decomposes it into a task DAG (Directed Acyclic Graph). The coordinator identifies independent tasks that can run in parallel, respects dependencies between tasks, assigns tasks to appropriate agents based on capabilities, and synthesizes the final result after all tasks complete.
Which LLM providers are supported?
The framework supports 10 native providers: Anthropic (Claude), OpenAI (GPT), Azure OpenAI, AWS Bedrock, Gemini, Grok (xAI), DeepSeek, MiniMax, Qiniu, and GitHub Copilot. It also supports any OpenAI-compatible endpoint including Ollama, vLLM, LM Studio, OpenRouter, Groq, and Mistral via manual baseURL configuration.
What built-in tools are available?
Open Multi-Agent includes 6 built-in tools: bash (execute shell commands with timeout and cwd support), file_read (read file contents with offset/limit for large files), file_write (write/create files with auto-created parent directories), file_edit (edit files by replacing exact string matches), grep (search file contents with regex using ripgrep or Node.js fallback), and glob (find files by glob pattern sorted by modification time).
How does observability work in the framework?
The framework provides three layers of observability: onProgress events for per-task lifecycle events (task_start, task_complete, task_retry, task_skipped, agent_start, agent_complete, budget_exceeded, error), onTrace spans for structured telemetry on LLM calls/tools/tasks with parent IDs/durations/token counts, and a post-run HTML dashboard that renders the executed task DAG with timing, token usage, and per-task status without requiring any server.
Can I use local models with Open Multi-Agent?
Yes, the framework fully supports local models via Ollama, vLLM, LM Studio, and llama.cpp server using OpenAI-compatible APIs. Verified models include Gemma 4, Llama 3.1, Qwen 3, Mistral, and Phi-4. Tool-calling works natively through these servers, and the framework automatically extracts tool calls from text output if the model returns them as text instead of wire format. Use timeoutMs to prevent indefinite hangs with local inference.
What is the difference between Open Multi-Agent and LangGraph?
LangGraph is graph-first: you compile a declarative graph with nodes, edges, and conditional routing into an invokable. Open Multi-Agent is goal-first: a Coordinator decomposes the goal into a task DAG at runtime, then auto-parallelizes independent tasks. Both achieve orchestrated execution but from opposite directions. LangGraph excels at fixed production topology with mature checkpointing, while OMA excels at goal-driven orchestration without enumerating every step.
How do I control token costs and prevent runaway spending?
The framework provides multiple cost controls: maxTokenBudget on the orchestrator to hard-cap spend, maxTurns per agent to bound conversations, contextStrategy (sliding-window/summarize/compact/custom) to manage conversation length, maxToolOutputChars to cap tool output costs, and compressToolResults to reduce output size. You configure these in OrchestratorConfig and AgentConfig before going live.
What is PlanOnly mode and when should I use it?
PlanOnly mode is activated by passing planOnly: true to runTeam(). The coordinator decomposes the goal into a task DAG but no task agents execute. The result carries populated tasks (without metrics) and only the coordinator's token usage. Use it for asserting on the task DAG in integration tests, previewing cost before a real run, or understanding how the framework would break down a goal without actually executing it.
How do I implement shared memory between agents?
Teams can share a namespaced key-value store by setting sharedMemory: true for the default in-process store, or implement the MemoryStore interface and pass it via sharedMemoryStore for Redis, Postgres, Engram, or custom backends. Keys are namespaced as <agentName>/<key> before reaching the store. Later agents can see earlier agents' findings through this shared memory, enabling collaborative workflows where agents build on each other's work.