🐝 OpenCode Swarm Plugin

Native OpenCode plugin for multi-agent swarm orchestration using OpenCode's built-in providers.

No external setup required — runs entirely inside OpenCode using your existing providers.

🤔 Why Swarm?

Standard AI assistants handle one task at a time. Swarm brings true multi-agent orchestration to OpenCode:

• Parallel agents work on different aspects of your task simultaneously
• Hierarchical workflows break complex problems into manageable subtasks
• Consensus mechanisms ensure quality through automated review
• Native integration — no external servers, no API keys, no local models

🎯 Was ist OpenCode Swarm?

OpenCode Swarm ist ein nativer OpenCode-Plugin für Multi-Agent-Orchestrierung. Es erweitert OpenCode um echte Subagent-Funktionalität — komplexe Aufgaben werden automatisch in Teilaufgaben zerlegt und von spezialisierten Agenten parallel bearbeitet.

Das Plugin läuft vollständig innerhalb von OpenCode und nutzt dabei die integrierte Provider-Infrastruktur. Keine externen Server, keine zusätzlichen API-Keys, kein lokales Modell-Setup erforderlich.

✨ Hauptfunktionen

• 🎭 14 Spezialisierte Agents - Von strategischen Planern bis zu Code-Reviewern
• 🔄 Echte Subagent-Orchestrierung - Jeder Worker als separater Subtask sichtbar
• 🏗️ Hierarchische & Mesh-Workflows - Flexible Ausführungsmuster
• 🗳️ Konsens-Mechanismen - Byzantinisch, Abstimmung und gewichteter Konsens
• 🧠 Intelligente Modellauswahl - Automatische Model-Tier-Zuweisung
• 📊 Kosten-Tracking - API-Nutzung pro Run überwachen
• 🔒 Security Guard - Eingabe-Sanitisierung und Validierung
• 📈 Umfassendes Logging - Debuggen mit detaillierten Ausführungs-Logs

🚀 Schnellstart

Installation als OpenCode Plugin

Füge das Plugin zu deiner OpenCode Konfiguration hinzu:

{
  "plugins": ["@realblxckcodex/opencode-swarm@latest"]
}

Oder installiere es lokal für Entwicklung:

npm install @realblxckcodex/opencode-swarm

Entwicklung aus dem Repository

git clone https://github.com/RealBlxckCodex/OpenSwarm.git
cd OpenSwarm
npm install
npm run build

Konfiguration

Erstelle .env mit deinen bevorzugten Modellen:

# Model Tiers
THINKING=kimi-k2-thinking
CODING=kimi-k2-5
STRONG=gpt-5-codex
REVIEWER=gpt-5-codex

Nutzung

# Swarm-Run starten
/swarm_run task="Benutzer-Authentifizierungssystem implementieren"

# Ausführungs-Logs prüfen
/swarm_logs

# Mit spezifischem Modus ausführen
/swarm_run task="Datenbank-Layer refactoren" mode=hierarchical

🏗️ Architektur

Drei-Ebenen-Agent-System

┌─────────────────────────────────────────┐
│         Benutzer-Oberflächen-Ebene      │
│         (swarm-master)                  │
└─────────────────┬───────────────────────┘
                  │
┌─────────────────▼───────────────────────┐
│         Strategische Ebene              │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐   │
│  │strategic│ │tactical │ │adaptive │   │
│  │ -queen  │ │ -queen  │ │ -queen  │   │
│  └────┬────┘ └────┬────┘ └────┬────┘   │
└───────┼──────────┼──────────┼────────┘
        │          │          │
┌───────▼──────────▼──────────▼────────┐
│         Ausführungs-Ebene             │
│  researcher │ coder │ tester │        │
│  architect  │reviewer│optimizer│       │
│  analyst    │documenter              │
└───────────────────────────────────────┘

🎯 What is OpenCode Swarm?

OpenCode Swarm is a native OpenCode plugin for multi-agent orchestration. It extends OpenCode with true subagent capabilities — complex tasks are automatically decomposed into subtasks and processed in parallel by specialized agents.

The plugin runs entirely inside OpenCode using the integrated provider infrastructure. No external servers, no additional API keys, no local model setup required.

✨ Key Features

• 🎭 14 Specialized Agents - From strategic planners to code reviewers
• 🔄 True Subagent Orchestration - Each worker visible as separate subtask
• 🏗️ Hierarchical & Mesh Workflows - Flexible execution patterns
• 🗳️ Consensus Mechanisms - Byzantine, voting, and weighted consensus
• 🧠 Smart Model Selection - Automatic model tier assignment
• 📊 Cost Tracking - Monitor API usage per run
• 🔒 Security Guard - Input sanitization and validation
• 📈 Comprehensive Logging - Debug with detailed execution logs

🚀 Quick Start

Installation

Option 1: Via npm (Recommended)

npm install @realblxckcodex/opencode-swarm

Configuration

Create .env with your preferred models:

# Model Tiers
THINKING=kimi-k2-thinking
CODING=kimi-k2-5
STRONG=gpt-5-codex
REVIEWER=gpt-5-codex

Usage

# Start a swarm run
/swarm_run task="Implement user authentication system"

# Check execution logs
/swarm_logs

# Run with specific mode
/swarm_run task="Refactor database layer" mode=hierarchical

🏗️ Architecture

Three-Tier Agent System

┌─────────────────────────────────────────┐
│         User Interface Layer            │
│         (swarm-master)                  │
└─────────────────┬───────────────────────┘
                  │
┌─────────────────▼───────────────────────┐
│         Strategic Layer                 │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐   │
│  │strategic│ │tactical │ │adaptive │   │
│  │ -queen  │ │ -queen  │ │ -queen  │   │
│  └────┬────┘ └────┬────┘ └────┬────┘   │
└───────┼──────────┼──────────┼────────┘
        │          │          │
┌───────▼──────────▼──────────▼────────┐
│         Execution Layer               │
│  researcher │ coder │ tester │        │
│  architect  │reviewer│optimizer│       │
│  analyst    │documenter              │
└───────────────────────────────────────┘

Hierarchischer Modus:

strategic-queen → planner → workers → consensus → reviewer

Mesh-Modus:

Alle Worker führen parallel mit Peer-Konsens aus

Hierarchical Mode:

strategic-queen → planner → workers → consensus → reviewer

Mesh Mode:

All workers execute in parallel with peer consensus

Queens (Strategische Ebene)

• strategic-queen - Hochrangige Planung & Dekomposition
• tactical-queen - Ausführungs-fokussierte Planung
• adaptive-queen - Selbst-optimierend mit Feedback-Loops

Worker (Ausführungs-Ebene)

• researcher - Codebase-Analyse & Dokumentation
• coder - Implementierungs-Spezialist
• tester - Test-Generierung & Validierung
• architect - System-Design & Patterns
• reviewer - Code-Review & Qualitätssicherung
• analyst - Anforderungsanalyse
• optimizer - Performance-Optimierung
• documenter - Dokumentations-Generierung

Swarm-Spezialisten

• swarm-planner - Swarm-spezifische Planung
• swarm-implementer - Multi-Agent-Ausführung
• swarm-reviewer - Swarm-Output-Review
• swarm-master - Benutzeroberfläche & Delegation

Queens (Strategic Layer)

• strategic-queen - High-level planning & decomposition
• tactical-queen - Execution-focused planning
• adaptive-queen - Self-optimizing with feedback loops

Workers (Execution Layer)

• researcher - Codebase analysis & documentation
• coder - Implementation specialist
• tester - Test generation & validation
• architect - System design & patterns
• reviewer - Code review & quality assurance
• analyst - Requirements analysis
• optimizer - Performance optimization
• documenter - Documentation generation

Swarm Specialists

• swarm-planner - Swarm-specific planning
• swarm-implementer - Multi-agent execution
• swarm-reviewer - Swarm output review
• swarm-master - User interface & delegation

| Befehl | Beschreibung | |--------|-------------| | /swarm_run | Task mit dem Swarm ausführen | | /swarm_logs | Ausführungs-Logs abrufen | | /swarm_debug | Diagnose ausführen |

Befehls-Optionen

/swarm_run 
  task="Deine Task-Beschreibung"    # Erforderlich
  mode=hierarchical|mesh            # Workflow-Modus
  consensus=byzantine|voting        # Konsens-Typ
  depth=3                           # Planungs-Tiefe
  verbose=true                      # Detaillierte Ausgabe

| Command | Description | |---------|-------------| | /swarm_run | Execute a task with the swarm | | /swarm_logs | Retrieve execution logs | | /swarm_debug | Run diagnostics |

Command Options

/swarm_run 
  task="Your task description"    # Required
  mode=hierarchical|mesh          # Workflow mode
  consensus=byzantine|voting      # Consensus type
  depth=3                         # Planning depth
  verbose=true                    # Detailed output

OpenCode-Swarm/
├── .opencode/
│   ├── agents/              # 14 Agent-Definitionen
│   ├── plugins/swarm/       # Plugin-Implementierung
│   ├── swarm/
│   │   ├── core/            # Core-Orchestrierung (~11.200 Zeilen)
│   │   ├── adapters/        # Plattform-Adapter
│   │   └── modules/         # Erweiterungssystem
│   └── commands/            # Debug-Befehle
├── .github/                 # GitHub-Templates
├── CHANGELOG.md            # Versions-Historie
├── ROADMAP.md              # Feature-Roadmap
└── FEATURE_BRAINSTORMING.md # Zukünftige Features

OpenCode-Swarm/
├── .opencode/
│   ├── agents/              # 14 agent definitions
│   ├── plugins/swarm/       # Plugin implementation
│   ├── swarm/
│   │   ├── core/            # Core orchestration (~11,200 lines)
│   │   ├── adapters/        # Platform adapters
│   │   └── modules/         # Extension system
│   └── commands/            # Debug commands
├── .github/                 # GitHub templates
├── CHANGELOG.md            # Version history
├── ROADMAP.md              # Feature roadmap
└── FEATURE_BRAINSTORMING.md # Future ideas

| Dokument | Beschreibung | |----------|-------------| | ROADMAP.md | Entwicklungs-Roadmap & Meilensteine | | CHANGELOG.md | Versions-Historie & Änderungen | | FEATURE_BRAINSTORMING.md | Zukünftige Feature-Ideen | | SWARM_ARCHITECTURE_REPORT.md | Detaillierte Architektur-Analyse | | TEST_PLAN.md | Test-Strategie & Validierung |

| Document | Description | |----------|-------------| | ROADMAP.md | Development roadmap & milestones | | CHANGELOG.md | Version history & changes | | FEATURE_BRAINSTORMING.md | Future feature ideas | | SWARM_ARCHITECTURE_REPORT.md | Detailed architecture analysis | | TEST_PLAN.md | Testing strategy & validation |

# Einfachen Test ausführen
/swarm_run task="Teste Grundfunktionalität"

# Parallelen Ausführungs-Test ausführen
/swarm_run task="Teste parallele Worker" mode=mesh

# System-Status prüfen
/swarm_debug

# Run simple test
/swarm_run task="Test basic functionality"

# Run parallel execution test
/swarm_run task="Test parallel workers" mode=mesh

# Check system health
/swarm_debug

• Ausführungszeit: 4-5 Minuten für komplexe Tasks
• Erfolgsrate: >90%% für gut definierte Tasks
• Kosteneffizienz: Intelligente Model-Tier-Auswahl
• Parallelisierung: Bis zu 8 gleichzeitige Worker

• Execution Time: 4-5 minutes for complex tasks
• Success Rate: >90% for well-defined tasks
• Cost Efficiency: Smart model tier selection
• Parallelism: Up to 8 concurrent workers

Mitwirkungen sind willkommen! Siehe unsere GitHub Issues für:

• 🐛 Bug-Reports
• 💡 Feature-Requests
• 📖 Dokumentations-Verbesserungen

☕ Unterstützung

Wenn dir dieses Projekt hilft, kannst du mir gerne einen Kaffee spendieren!

Deine Unterstützung hilft, dieses Projekt am Leben zu erhalten, zu pflegen und für alle kostenlos zu halten.

📝 Lizenz

Dieses Projekt ist unter der Open Swarm License 1.0 lizenziert.

Kurzfassung: Du kannst dieses Plugin kostenlos nutzen, um coole Sachen zu bauen und diese sogar verkaufen. Aber du darfst das Plugin selbst nicht verkaufen oder als Hauptprodukt nutzen.

Siehe LICENSE für Details.

🙏 Danksagungen

• Gebaut für OpenCode AI
• Inspiriert durch Multi-Agent-Forschung
• Dank an das OpenCode-Team für das type: "subtask" Pattern

Contributions are welcome! Please see our GitHub Issues for:

• 🐛 Bug reports
• 💡 Feature requests
• 📖 Documentation improvements

☕ Support

If you find this project helpful, consider buying me a coffee!

Your support helps keep this project alive, maintained, and free for everyone.

📝 License

This project is licensed under the Open Swarm License 1.0.

TL;DR: You can use this plugin for free to build cool stuff and even sell what you build. But you cannot sell the plugin itself or use it in a way where the plugin is the main product you're selling.

See LICENSE for full details.

🙏 Acknowledgments

• Built for OpenCode AI
• Inspired by multi-agent research
• Thanks to the OpenCode team for the type: "subtask" pattern