Open Multi-Agent

// Overview

Open Multi-Agent (OMA) is a self-hosted TypeScript runtime for teams of agents, built around a governance question rather than a capability one: who approved the action, and can you prove afterwards what the model actually saw. It runs on your own infrastructure with your own keys and endpoints, whether a hosted provider, an OpenAI-compatible server or a local model reached through `baseURL`.

Its two distinguishing mechanisms are durable approvals and a verifiable journal. A plan, task dispatch or tool-call gate can return `suspend`; the request is stored beside the run checkpoint and bound to a SHA-256 hash of exactly what the reviewer was shown, so the run survives a restart and resumes from that content. Decisions are atomic and first-wins, and a tampered request — or a store without compare-and-set — fails closed rather than quietly proceeding.

The journal records every block the model saw, every tool call and result, and every context rewrite. `verifyRun()` reads it back cold and offline and checks that each block's named source event still reproduces it byte for byte. The project is precise about what this proves: lineage and content, not that the file was never edited, and an evicted context window is reported as inconclusive rather than as a failure. Three execution modes are exposed — `runAgent()` for a single agent, `runTasks()` for an explicit pipeline, and `runTeam()` to plan from a goal.

// What it does

• Durable approvals: consequential tool calls suspend and wait for a human decision that survives a restart
• Approval requests bound to a SHA-256 hash of exactly what the reviewer saw; tampering fails closed
• Verifiable journal with `verifyRun()`, replayed cold and offline to check each block byte for byte
• Three execution modes: `runAgent()`, `runTasks()` for explicit pipelines, and `runTeam()` to plan from a goal
• Checkpoint stores (such as `FileStore`) keep runs and pending approvals durable
• Bring your own provider and endpoint — hosted, OpenAI-compatible, local servers or AI SDK providers

// Getting started

The scaffolder is the fastest path: in an interactive terminal it picks a starter and runtime, installs dependencies and runs a deterministic local demo that needs no API key and makes no model request — scripted responses drive the real scheduler, aggregation and offline dashboard.

npm create oma-app@latest my-oma

npm install @open-multi-agent/core

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

const oma = new OpenMultiAgent({
  defaultProvider: 'openai',
  defaultModel: 'gpt-5.4',
  // Consequential tool calls (file writes, shell) pause for a human decision.
  onToolCall: ({ consequential }) => (consequential ? { action: 'suspend' } : { action: 'allow' }),
})

const team = oma.createTeam('ops', {
  name: 'ops',
  agents: [{ name: 'operator', systemPrompt: 'Reconcile overdue invoices.', toolPreset: 'readwrite' }],
})

const result = await oma.runTeam(team, 'Find overdue invoices and draft the reminders.', {
  checkpoint: { store: new FileStore('./.oma/run.json') },
})

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

// When to use it

• Run agents that touch production systems where every consequential action needs a named human approver
• Satisfy an audit by replaying offline exactly which context a model saw before it acted
• Keep an agent workflow entirely on your own infrastructure and model endpoints
• Build a review or analysis pipeline where tasks are an explicit DAG rather than an open-ended loop

// How Open Multi-Agent compares

Open Multi-Agent alongside other open-source multi-agent systems tools AI/TLDR tracks, ranked by GitHub stars.