OpenCode Orchestrator Plugin

Multi-Agent Plugin for OpenCode

OpenCode Orchestrator is a collaborative framework that enables low-benchmark models to deliver senior-level engineering results.

By maximizing the method of agent collaboration, we overcome the inherent limitations of individual AI models. We don't just "chat" with AI; we use a structured engineering layer to ensure complex missions are executed with 100% reliability and relentlessly pushed to completion, regardless of the model's price point.

Core Philosophy: Excellence through Collaboration

We believe that a perfect collaboration method is superior to individual intelligence.

• Systems Engineering Fusion: We integrate Operating System principles (Scheduling), Distributed Systems (Actor Model), and Algorithm Theory (Divide & Conquer) to transform unpredictable LLMs into a controlled computing resource.
• Relentless PDCA Loop: Every change follows a strict Plan-Do-Check-Act cycle. This systematic approach ensures that high-level professional tasks are completed without the quality decay or hallucinations typical of raw LLM outputs.
• Architecture over Benchmarks: By decomposing missions into atomic, verifiable tasks, we extract high-fidelity outcomes from cost-effective models, proving that superior architecture can outperform raw scale.

Why Orchestrator?

• 🧩 Strategic Organization — Maximizing output through intelligent role distribution
• 📉 Token Economy — Filtering noise to reduce costs and increase focus
• ⚡ Parallel DAG — Concurrent execution for speed and efficiency
• 🔍 Micro-Tasking — Atomic decomposition to prevent hallucinations
• 🛡️ Style Guardian — Strict AST-based linting and consistency checks
• 🔄 Self-Healing — Autonomous pivot strategies for complex errors
• 🏗️ Rust Core — Native performance for heavy lifting

How It Works (Parallel DAG)

Instead of a linear sequence, we use a Directed Acyclic Graph (DAG) to model your mission.

      Mission Start (/task)
              │
              ▼
      ┌───────────────┐
      │   PLANNER     │ (Architect)
      └───────┬───────┘
              │
      ┌───────┴───────┐
      │               │ (Parallel Streams)
      ▼               ▼
┌───────────┐   ┌───────────┐
│ Tasks (A) │   │ Tasks (B) │
└─────┬─────┘   └─────┬─────┘
      │               │
      └───────┬───────┘
              ▼
      ┌───────────────┐
      │   REVIEWER    │ (Style Guardian)
      └───────┬───────┘
              ▼
          ✅ MISSION COMPLETE

Installation

npm install -g opencode-orchestrator

Note: After installation, restart OpenCode or run opencode in your terminal. The plugin will automatically register itself in ~/.config/opencode/opencode.json with its absolute path.

Troubleshooting

If the command /task does not appear:

1. Uninstall: npm uninstall -g opencode-orchestrator
2. Clear config: rm -rf ~/.config/opencode (Warning: resets all plugins)
3. Reinstall: npm install -g opencode-orchestrator

The only command you need:

/task "Implement user authentication with JWT"

The Orchestrator will:

1. Decompose the mission into a JSON Task DAG
2. Parallel Execute independent streams
3. Search proactively for patterns
4. Code with atomic precision
5. Verify via the Style Guardian (MANDATORY)
6. Self-Heal if errors occur

Agents

• System Architecture (Deep Dive): Explore the Distributed Cognitive Architecture (DCA), PDCA Loop, and Actor Model internals.
• Configuration: opencode.toml setup guide.

Open Source

MIT License. No telemetry. No backdoors.

github.com/agnusdei1207/opencode-orchestrator

License

MIT License. NO WARRANTY.

MIT

🏛️ The Architecture: The PDCA & Distributed Cognitive Loop

We have moved beyond simple "chatbots". OpenCode Orchestrator implements a Deterministic Engineering Layer built on top of the stochastic nature of LLMs,

• Strict PDCA Loop: Guarantees quality via Plan-Do-Check-Act cycle.
• 🔍 Micro-tasking: Atomic decomposition to prevent hallucinations.
• 🛡️ Style Guardian: Strict AST-based linting and consistency checks by the Reviewer.
• 🔄 Self-healing: Autonomous pivoting strategies for complex errors.
• Distributed Cognitive System: Intelligence layer acting like an OS Kernel.
• File-Based State: Uses physical filesystem as RAM, ignoring context limits. We treat agents as Semantic Compute Units. By applying rigorous Computer Science principles, we achieve a level of reliability that no single model can match.

🧬 The "Grand Fusion" of Methodologies

We explicitly fused three massive domains into one seamless workflow:

1. PDCA Methodology (Quality Assurance):

   • Plan (Planner): Recursively decomposes mission into atomic tasks ($O(log n)$).
   • Do (Coder): Executes the atomic tasks in parallel (Distributed Actions).
   • Check (Reviewer): Acts as a Byzantine Fault Tolerance node, strictly validating code against requirements.
   • Act (Orchestrator): Merges successful states or Pivots (Dynamic Programming) if failures occur.

2. Distributed Systems Theory (Actor Model):

   • Each agent operates as an independent Actor with isolated state.
   • Context Sharding: We treat context windows like RAM, paging data in/out via temp_context files to simulate Infinite Context.

3. Algorithmic Efficiency:

   • Divide & Conquer: Breaking complex problems into trivial $O(1)$ sub-problems.
   • Dynamic Programming: Storing intermediate results (State) to avoid redundant computation and allow for intelligent backtracking.

🚀 The Command: /task

The interface to this system is a single, powerful command:

/task "Refactor the authentication middleware and implement JWT rotation"

This triggers the Distributed Task Loop. It's not just a chat; it's a mission commitment.

The 5-Phase Efficiency Workflow

1. 🧠 Phase 1: Filtered Analysis: The Searcher reads docs but filters out noise. We only feed the "critical path" to the Planner.
2. 🌲 Phase 2: Strategic Planning: The Planner creates a JSON DAG. This is our roadmap. No token is wasted on aimless wandering.
3. 🚀 Phase 3: Parallel Execution: The Orchestrator identifies independent tasks and runs them concurrently.
4. 🛡️ Phase 4: Sync & Verify: The Reviewer acts as the gatekeeper. It checks syntax, logic, and cross-file consistency.
5. 💰 Phase 5: Cost-Effective Completion: We achieve "Senior Developer" results at "Junior Intern" prices.

⚡ Fast-Paced Development

This project is evolving extremely fast. We iterate rapidly to bring relentless execution to your workflow. Updates are frequent. Keep your version fresh.