OpenCode Orchestrator

🚀 Multi-Agent Orchestration Plugin for OpenCode

🔥 Why This Plugin?

Budget models have limits. Orchestration breaks them.

🧠 Core Philosophy

Explore → Adapt → Act
Never assume. Always verify. Then execute.

The Problem with AI Agents

Most AI agents fail because they:

Assume instead of checking
Guess instead of researching
Follow rigid rules instead of adapting
Trust memory instead of verifying

Our Solution: Adaptive Intelligence

Every agent in this system follows a simple principle:

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   🔍 EXPLORE    →    🔄 ADAPT    →    ⚡ ACT               │
│                                                             │
│   Discover         Adjust to         Execute with           │
│   the reality      what you find     confidence             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Agent Philosophies

Agent	Philosophy	What It Means
🎯 Commander	Explore → Adapt → Act	Discover project structure first, then delegate intelligently
📋 Planner	Research → Plan → Document	Never guess syntax. Find official docs, verify, then plan
🔨 Worker	Observe → Learn → Implement	Study existing code patterns, then write code that fits
✅ Reviewer	Understand → Verify → Approve	Know the project's standards, run actual tests, approve with evidence

Guiding Principles

🔍 Never Assume, Always Discover
- Read context.md before every action
- Detect the tech stack, don't assume it
- Find the build/test commands, don't guess them
📚 Evidence Over Memory
- Cite official documentation for every claim
- Run actual commands for verification
- Mark complete only with proof
🔄 Adapt to the Project
- Match existing code patterns
- Follow discovered conventions
- Respect the project's way of doing things
🤝 Separation of Concerns
- Commander orchestrates, never implements
- Worker builds, never verifies
- Reviewer approves, never codes
- Each agent does one thing excellently

⚡ Quick Start

npm install -g opencode-orchestrator

Then in OpenCode:

/task "Build a REST API with authentication"

Done. You just deployed an army of AI agents. They plan, build, test, fix — and don't stop until it's sealed. ✨

🎯 What Makes This Different?

🚀 Core Capabilities

	Feature	What It Means
⚡	Multi-Session Parallel	50 isolated sessions running simultaneously. True multi-threading.
🔥	Parallel Execution	Workers build different files at once. 10x faster.
�	Non-Blocking Async	Fire-and-forget. Commander never waits. Results collected automatically.
🧩	Smart Distribution	One file = one worker. No conflicts. No stepping on each other.
🔗	Real-Time Sync	Shared `.opencode/` state. All agents see updates instantly.
🛡️	Auto Verify & Test	E2E tests, import checks, integration validation. Bugs get caught.
🩹	Self-Healing	Auto-recovery from crashes, rate limits, context overflow. 3 retries.
�	Live Monitoring	Track sessions, progress, queues. Toast notifications in real-time.

🏛️ How It Works

⚡ DELEGATE. PARALLELIZE. SEAL. — One command unleashes full autonomous execution.

            /task "Build REST API"
                     │
     ╔═══════════════╧═══════════════╗
     ║  🎯 COMMANDER — Delegate+Loop ║
     ╚═══════════════╤═══════════════╝
                     │
     ┌───────────────┼───────────────┐
     ▼               ▼               ▼
 ┌───────┐      ┌───────┐      ┌───────┐
 │PLANNER│      │WORKER │      │WORKER │   ← 🔥 50 PARALLEL
 │plan.md│      │auth.ts│      │api.ts │      SESSIONS
 └───────┘      └───────┘      └───────┘
     │               │               │
     └───────────────┼───────────────┘
                     ▼
     ╔═══════════════╧═══════════════╗
     ║      ✅ REVIEWER — Verify     ║
     ╚═══════════════╤═══════════════╝
                     │
            ┌────────┴────────┐
            │ TODO 100%?      │
            │ Issues = 0?     │
            └────────┬────────┘
              No ↙       ↘ Yes
            ♻️ LOOP      🎖️ SEALED

🔑 Key Systems

System	What It Does
🔀 Multi-Session	`delegate_task` → `client.session.create()` → new isolated session
⚡ Parallel Agents	50 sessions run simultaneously, `ConcurrencyController` manages slots
🖥️ Background Tasks	`run_background` → async shell commands, non-blocking
🔄 Auto-Continuation	`session.idle` → check TODOs → inject prompt → keep going
🛡️ Self-Healing	Rate limits, crashes → 3 auto-retries per session

Stop anytime: /stop

TUI

Window

🔧 Self-Healing Features

┌────────────────────────────────────────────────────────────┐
│ ERROR TYPE              │ AUTO-RECOVERY ACTION             │
├────────────────────────────────────────────────────────────┤
│ Tool crash              │ Inject recovery prompt           │
│ Rate limit              │ Exponential backoff + retry      │
│ Context overflow        │ Smart compaction                 │
│ Thinking block error    │ Auto-restructure                 │
│ Session timeout         │ Resume from checkpoint           │
│ Build failure           │ Loop back, fix, retry            │
└────────────────────────────────────────────────────────────┘

📚 Documentation

System Architecture — Full technical deep-dive

Uninstall

npm uninstall -g opencode-orchestrator

License

MIT License. LICENSE