Package Exports

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@realblxckcodex/opencode-swarm) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

🐝 OpenCode Swarm Plugin

Multi-Agent Orchestration System with true subagent support for OpenCode AI

🇩🇪 Deutsch | German

🎯 Was ist OpenCode Swarm?

OpenCode Swarm ist ein produktionsreifes Multi-Agent-Orchestrierungssystem, das komplexe Entwicklungsaufgaben durch koordinierte Teams von KI-Agenten ausführt. Im Gegensatz zu einfachen Agent-Ketten implementiert Swarm ein echtes Subagent-Pattern, bei dem jeder Worker als isolierter Subtask mit voller Sichtbarkeit in der OpenCode-Chat-Oberfläche läuft.

✨ 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

# Repository klonen
git clone https://github.com/RealBlxckCodex/OpenSwarm.git
cd OpenSwarm

# Abhängigkeiten installieren
npm install

# Umgebung konfigurieren
cp .env.example .env
# .env mit deinen API-Keys bearbeiten

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              │
└───────────────────────────────────────┘

🇬🇧 English | Englisch

🎯 What is OpenCode Swarm?

OpenCode Swarm is a production-ready multi-agent orchestration system that enables complex development tasks to be executed by coordinated teams of AI agents. Unlike simple agent chains, Swarm implements a true subagent pattern where each worker runs as an isolated subtask with full visibility in the OpenCode chat interface.

✨ 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

# Clone the repository
git clone https://github.com/RealBlxckCodex/OpenSwarm.git
cd OpenSwarm

# Install dependencies
npm install

# Configure environment
cp .env.example .env
# Edit .env with your API keys

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              │
└───────────────────────────────────────┘

🇩🇪 Workflow-Modi | Workflow Modes

Hierarchischer Modus:

strategic-queen → planner → workers → consensus → reviewer

Mesh-Modus:

Alle Worker führen parallel mit Peer-Konsens aus

🇬🇧 Workflow Modes | Workflow-Modi

Hierarchical Mode:

strategic-queen → planner → workers → consensus → reviewer

Mesh Mode:

All workers execute in parallel with peer consensus

🇩🇪 Verfügbare Agents | Available Agents

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

🇬🇧 Available Agents | Verfügbare Agents

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

🇩🇪 Befehle | Commands

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

🇬🇧 Commands | Befehle

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

🇩🇪 Projektstruktur | Project Structure

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

🇬🇧 Project Structure | Projektstruktur

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

🇩🇪 Dokumentation | Documentation

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

🇬🇧 Documentation | Dokumentation

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

🇩🇪 Tests | Testing

# 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

🇬🇧 Testing | Tests

# 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

🇩🇪 Performance | Performance

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

🇬🇧 Performance | Performance

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

🇩🇪 Mitwirken | Contributing

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

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

📝 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert.

🙏 Danksagungen

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

🇬🇧 Contributing | Mitwirken

Contributions are welcome! Please see our GitHub Issues for:

🐛 Bug reports
💡 Feature requests
📖 Documentation improvements

📝 License

This project is licensed under the MIT License.

🙏 Acknowledgments

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

🐝 Swarm Intelligence for Better Code 🐝
🐝 Schwarm-Intelligenz für besseren Code 🐝

Changelog • Roadmap • Ideas/Ideen