AI Frameworks · open-multi-agent

open-multi-agent

Open Multi-Agent is a TypeScript framework that automatically breaks down high-level goals into parallel task workflows (DAGs) and executes them across Claude, ChatGPT, Gemini, DeepSeek, or local models. It replaces hand-wired agent graphs with runtime-adaptive decomposition, keeping the core lightweight while supporting multiple LLM providers.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/open-multi-agent/open-multi-agent

6.5k

GitHub stars

2.4k

Forks

TypeScript

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	open-multi-agent/open-multi-agent
Owner	open-multi-agent
Primary language	TypeScript
License	MIT — OSI-approved
Stars	6.5k
Forks	2.4k
Open issues	14
Latest release	v1.9.0 (2026-07-03)
Last updated	2026-07-06
Source	https://github.com/open-multi-agent/open-multi-agent

What open-multi-agent is

A multi-agent orchestration engine for Node.js that uses a Coordinator agent to decompose goals into task DAGs at runtime, auto-parallelizes independent tasks, and executes deterministically with provider abstraction. Core dependencies minimal; mainstream providers (Anthropic, OpenAI) built-in; Gemini, Bedrock, MCP, and Vercel AI SDK as opt-in peer dependencies.

Quickstart

Get the open-multi-agent source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/open-multi-agent/open-multi-agent.git2cd open-multi-agent3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Goal-Driven Multi-Step Workflows

When you want to declare a high-level objective and have the framework automatically decompose it into parallel subtasks, rather than hand-coding a DAG.

Multi-LLM Coordination

Applications needing to route sub-tasks to different models (Claude for planning, ChatGPT for coding, local models for cost-sensitive work) with unified orchestration.

Node.js Backend Integration

TypeScript/Node.js services embedding autonomous agent teams without external Python services or container orchestration overhead.

Implementation considerations

Project is ~3 months old (launched 2026-04-01); while actively maintained (latest v1.9.0 on 2026-07-03), long-term API stability unknown—pin versions and monitor releases.
Coordinator agent cost: every goal invocation spawns an LLM call to decompose the DAG; monitor token usage for high-frequency goals.
Context compaction mentioned but not detailed in excerpt; review actual implementation for VRAM/token limits under sustained agent loops.
opt-in peer dependencies require explicit installation (Gemini, Bedrock, MCP); validate that all desired providers are available before committing.
Dashboard and replay features shown in GIF but actual API surface and limitations not fully detailed in excerpt; see `packages/core/README.md` for full feature parity.

When to avoid it — and what to weigh

Strict Upfront Graph Requirement — If your workflow must be fully defined and validated before runtime, or you need deterministic, non-adaptive node/edge topology, consider LangGraph JS which uses declarative graph design.
Deep Persistence & State Checkpoint Ecosystem — LangGraph offers richer checkpoint and resume semantics across databases. OMA supports inspection and replay but does not have LangGraph's depth of persistence integrations.
Python-First Organization — If your team standardizes on Python and CrewAI, adopting a TypeScript-only framework introduces a new runtime and skillset dependency.
Real-Time Streaming at Scale — OMA is designed for discrete task orchestration; if you need sub-second streaming updates across hundreds of agents, evaluate streaming-focused frameworks.

License & commercial use

MIT License. Permissive, OSI-approved. Allows commercial use, modification, and distribution with attribution. No copyleft obligations.

MIT is a permissive license that explicitly permits commercial use. No commercial licensing, restrictive terms, or proprietary requirements documented. However, commercial viability depends on LLM provider terms (Anthropic, OpenAI, etc.); ensure your use of those services complies with their ToS and licensing.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Strong
Assessment confidence	High

Security considerations

Framework does not manage credential storage; LLM API keys and other secrets remain your responsibility—use environment variables or a secrets manager. DAG replay and dashboard expose task outputs; audit who has access. Tool definitions (`bash`, `file_*`, `grep`) mentioned as built-in but security posture of those tools not detailed—review before running in sensitive environments. No security audit or third-party assessment documented in excerpt.

Alternatives to consider

LangGraph JS

Declarative graph-first design with deeper persistence and checkpoint ecosystem; reach for LangGraph if your workflow is fixed upfront and you need robust state management.

Mastra

Hand-wired orchestration for TypeScript; preferred if you need explicit control over workflow topology and want to avoid runtime decomposition overhead.

CrewAI (Python)

Established Python multi-agent framework with broader community and integrations; use if your org standardizes on Python and wants battle-tested abstractions.

Software development agency

Build on open-multi-agent with DEV.co software developers

Start with `npm create oma-app@latest` or review the full documentation and examples in the repository. MIT licensed, production-ready, and actively maintained.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

openai-agents-python openagi openagent

Related on DEV.co

Explore the category and the services that help you build with it.

AI Frameworks AI Development Backend & API Development Web App Development Talk to DEV.co

open-multi-agent FAQ

Can I run OMA on local models without API keys?

Yes. OMA supports Ollama and other local LLM endpoints. The README mentions examples using local quantized models with the Coordinator and context compaction.

How does OMA differ from just chaining LLM calls?

The Coordinator decomposes a goal into a DAG of parallel tasks at runtime, auto-parallelizes independents, and provides a deterministic scheduler and replay dashboard. It avoids hand-coding every step.

Is OMA production-ready?

Early adopters are using it in production (temodar-agent, PR-Copilot cited). MIT licensed, actively maintained, but ~3 months old—production deployments should pin versions, monitor breaking changes, and validate error handling against your SLA.

What are the costs of using OMA?

You pay only for LLM API calls (Anthropic, OpenAI, etc.). The Coordinator itself consumes tokens to decompose each goal. Local models incur no API cost but require VRAM and CPU for inference.

Work with a software development agency

Need help beyond evaluating open-multi-agent? DEV.co is a software development agency offering software development services and web development for teams of every size. Our software developers and web developers build custom software, web applications, APIs, and ai frameworks integrations — and maintain them long-term.

Ready to orchestrate AI agents in TypeScript?

Start with `npm create oma-app@latest` or review the full documentation and examples in the repository. MIT licensed, production-ready, and actively maintained.

Talk to DEV.co Schedule a Consultation