Open Multi Agent Orchestration

# Open Multi-Agent Orchestration

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

`open-multi-agent` is a TypeScript framework for building AI agent teams where agents with different roles, models, and tools collaborate on complex goals. The framework handles task dependency resolution (DAG scheduling), parallel execution, shared memory, and inter-agent communication — all in-process with no subprocess overhead.

## Installation

```bash
npm install @jackchen_me/open-multi-agent
# or
pnpm add @jackchen_me/open-multi-agent
```

Set environment variables:

```bash
export ANTHROPIC_API_KEY=your_key_here
export OPENAI_API_KEY=your_key_here   # optional, only if using OpenAI models
```

## Core Concepts

| Concept | Description |
|---------|-------------|
| `OpenMultiAgent` | Top-level orchestrator — entry point for all operations |
| `Team` | A named group of agents sharing a message bus, task queue, and optional shared memory |
| `AgentConfig` | Defines an agent's name, model, provider, system prompt, and allowed tools |
| `Task` | A unit of work with a title, description, assignee, and optional `dependsOn` list |
| `LLMAdapter` | Pluggable interface — built-in adapters for Anthropic and OpenAI |
| `ToolRegistry` | Registry of available tools; built-ins + custom tools via `defineTool()` |

## Quick Start — Single Agent

```typescript
import { OpenMultiAgent } from '@jackchen_me/open-multi-agent'

const orchestrator = new OpenMultiAgent({ defaultModel: 'claude-sonnet-4-6' })

const result = await orchestrator.runAgent(
  {
    name: 'coder',
    model: 'claude-sonnet-4-6',
    tools: ['bash', 'file_write'],
  },
  'Write a TypeScript function that reverses a string, save it to /tmp/reverse.ts, and run it.',
)

console.log(result.output)
```

## Multi-Agent Team

```typescript
import { OpenMultiAgent } from '@jackchen_me/open-multi-agent'
import type { AgentConfig } from '@jackchen_me/open-multi-agent'

const architect: AgentConfig = {
  name: 'architect',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You design clean API contracts and file structures.',
  tools: ['file_write'],
}

const developer: AgentConfig = {
  name: 'developer',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You implement what the architect designs.',
  tools: ['bash', 'file_read', 'file_write', 'file_edit'],
}

const reviewer: AgentConfig = {
  name: 'reviewer',
  model: 'claude-sonnet-4-6',
  systemPrompt: 'You review code for correctness and clarity.',
  tools: ['file_read', 'grep'],
}

const orchestrator = new OpenMultiAgent({
  defaultModel: 'claude-sonnet-4-6',
  onProgress: (event) => console.log(event.type, event.agent ?? event.task ?? ''),
})

const team = orchestrator.createTeam('api-team', {
  name: 'api-team',
  agents: [architect, developer, reviewer],
  sharedMemory: true,
})

const result = await orchestrator.runTeam(
  team,
  'Create a REST API for a todo list in /tmp/todo-api/',
)

console.log(`Success: ${result.success}`)
console.log(`Output tokens: ${result.totalTokenUsage.output_tokens}`)
```

## Task Pipeline — Explicit DAG Control

Use `runTasks()` when you need precise control over task ordering, assignments, and parallelism:

```typescript
const result = await orchestrator.runTasks(team, [
  {
    title: 'Design the data model',
    description: 'Write a TypeScript interface spec to /tmp/spec.md',
    assignee: 'architect',
  },
  {
    title: 'Implement the module