Stop Wasting Tokens on Monolithic AI Agents! Use oh-my-opencode-slim Instead

What if I told you that 90% of your AI coding budget is evaporating because you're forcing one bloated model to do everything? Here's the brutal truth: every time you ask GPT-5.5 to find a file, read documentation, and fix a bug in the same conversation, you're burning premium tokens on tasks that a cheaper, faster specialist could handle in milliseconds.

The secret weapon that elite developers are quietly adopting? oh-my-opencode-slim — a ruthlessly optimized multi-agent orchestration plugin for OpenCode that just crossed 4,000 GitHub stars. This isn't another overhyped AI wrapper. It's a surgical system that delegates each coding task to the perfect specialist agent, balancing quality, speed, and cost with mathematical precision.

Built by Boring Dystopia Development and maintained by a thriving community of 48+ contributors, oh-my-opencode-slim represents a fundamental shift in how we think about AI-assisted development. Forget the monolithic approach. The future belongs to specialized agent teams — and this plugin puts that power directly in your terminal.

Ready to stop hemorrhaging tokens? Let's dive into the architecture that's making senior engineers abandon their old workflows.

What is oh-my-opencode-slim?

oh-my-opencode-slim is a streamlined, token-efficient fork of the original oh-my-opencode project, purpose-built for model orchestration and automatic task delegation within the OpenCode ecosystem. Where the original project accumulated feature bloat, this "slim" variant strips away inefficiency while amplifying the core superpower: intelligent agent routing.

Created by Alvin (@alvinunreal) and the team at Boring Dystopia Development, this plugin transforms your single AI assistant into a coordinated team of specialists — each powered by different models optimized for specific cognitive workloads. The Orchestrator acts as your strategic commander, dynamically dispatching tasks to Explorer (codebase reconnaissance), Oracle (architectural decisions), Librarian (documentation research), Designer (UI/UX implementation), and Fixer (rapid code execution).

The "slim" designation isn't marketing fluff. The repository explicitly targets dramatically reduced token consumption compared to its predecessor. In an era where API costs scale linearly with context window usage, this optimization translates to real savings — especially for teams running hundreds of agent interactions daily.

The project has exploded in popularity, recently celebrating 4,000+ GitHub stars with a community that actively shapes its evolution. Its architecture resonates with a growing consensus among AI-native developers: heterogeneous model ensembles outperform single-model approaches on both cost and quality dimensions.

Key Features That Separate It From the Pack

Intelligent Model Mixing

The plugin's killer feature is prescription-grade model selection. Instead of defaulting to your most expensive model for every operation, oh-my-opencode-slim maintains provider-agnostic presets that map each agent to optimal models. The default OpenAI preset uses gpt-5.5 for high-judgment orchestration and gpt-5.4-mini for scoped tasks — but you're free to mix Anthropic, Google, Cerebras, Fireworks AI, and OpenCode Go models in a single workflow.

The Pantheon Architecture

Seven distinct agent personas handle specialized cognitive domains:

Orchestrator: Strategic delegation and main implementation
Explorer: Blazing-fast codebase traversal and pattern recognition
Oracle: Deep architectural reasoning and debugging of last resort
Council: Multi-model consensus through parallel execution
Librarian: External knowledge retrieval with web search and documentation tools
Designer: UI/UX polish and visual implementation excellence
Fixer: Rapid, bounded execution for tests and straightforward changes

V2 Background Orchestration (Beta)

The experimental V2 transforms the Orchestrator from execution worker to pure scheduler. It plans work, dispatches specialists as background tasks, polls status, and reconciles results — enabling true parallel agent execution. This requires OpenCode's experimental background subagent support, activated via OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=1.

Token-Efficient Design

Every architectural decision prioritizes context window economy. The Observer agent (disabled by default) handles multimodal inputs without loading raw bytes into the main context. The Council's automatic delegation is intentionally restricted due to cost. Even the Librarian's MCP tools are granularly permissioned per agent.

Session Management & Workflow Tools

Advanced features include session continuation with cooldown safety, /preset runtime switching, /subtask bounded child workers, codemap generation for large codebases, dependency cloning for inspection, and even Divoom Bluetooth display mirroring for physical agent activity monitoring.

Real-World Use Cases Where It Dominates

1. Enterprise Codebase Onboarding

Imagine joining a 500,000-line legacy project. Instead of context-dumping everything into Claude and praying, you invoke: @explorer map this architecture. The Explorer agent — running a fast, cheap model — generates hierarchical codemaps and pattern analysis. The Orchestrator then routes specific component questions to Oracle for architectural context or Fixer for implementation details. Result: Hours of exploration compressed to minutes, with token costs slashed by 60-80%.

2. Complex Refactoring with Consensus

When facing a risky database schema migration, manually invoke @council compare these two approaches. The Council fires multiple high-reasoning models in parallel, each evaluating trade-offs from different training distributions. The Council agent synthesizes their judgments into a single, robust recommendation. Result: Reduced architectural blind spots and defensible decisions backed by model diversity.

3. Full-Stack Feature Implementation

Building a new user dashboard? The Orchestrator automatically delegates: Designer for component structure and animation specs, Librarian for up-to-date framework documentation, Fixer for test scaffolding and API integration, and Explorer to locate existing auth patterns. Result: Parallel execution with each specialist operating in its cognitive sweet spot.

4. Production Incident Response

At 3 AM with a P0 outage, speed matters. The Orchestrator dispatches Explorer to identify recent changes, Librarian to search for similar incidents in documentation, and Oracle to evaluate rollback strategies. Fixer executes the chosen remediation. Result: Coordinated crisis response without overloading your premium reasoning model with low-value context.

Step-by-Step Installation & Setup Guide

Quick Start (Recommended)

The fastest path — paste this directly into Claude Code, AmpCode, Cursor, or any OpenCode-compatible agent:

Install and configure oh-my-opencode-slim: https://raw.githubusercontent.com/alvinunreal/oh-my-opencode-slim/refs/heads/master/README.md

This one-liner triggers automatic plugin installation and configuration.

Manual Installation

For granular control, use the Bun-based installer:

# Install latest stable version
bunx oh-my-opencode-slim@latest install

# Or install V2 beta with background orchestration
bunx oh-my-opencode-slim@beta install

V2 Beta Activation

Background orchestration requires experimental OpenCode flags:

# Install beta channel
bunx oh-my-opencode-slim@beta install

# Launch OpenCode with experimental subagent support
OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=1 opencode

Authentication & Model Discovery

# Authenticate with your providers (OpenAI, Anthropic, etc.)
opencode auth login

# Refresh and list available models
opencode models --refresh

Configuration Deep-Dive

The installer generates presets at ~/.config/opencode/oh-my-opencode-slim.json. Here's the default OpenAI preset with critical annotations:

{
  "$schema": "https://unpkg.com/oh-my-opencode-slim@latest/oh-my-opencode-slim.schema.json",
  "preset": "openai",
  "presets": {
    "openai": {
      // Main commander: strongest all-around model for delegation + implementation
      "orchestrator": { 
        "model": "openai/gpt-5.5", 
        "skills": ["*"],           // All skills enabled
        "mcps": ["*", "!context7"] // All MCPs except context7
      },
      // Strategic advisor: high-reasoning variant for architecture
      "oracle": { 
        "model": "openai/gpt-5.5", 
        "variant": "high",         // Uses higher reasoning effort
        "skills": ["simplify"],    // Only simplify skill
        "mcps": []                 // No external tools — pure reasoning
      },
      // Research specialist: fast, cheap model for documentation
      "librarian": { 
        "model": "openai/gpt-5.4-mini", 
        "variant": "low",          // Minimal reasoning — speed priority
        "skills": [],
        "mcps": ["websearch", "context7", "grep_app"] // Full research toolkit
      },
      // Codebase scout: minimal cost for broad exploration
      "explorer": { 
        "model": "openai/gpt-5.4-mini", 
        "variant": "low",
        "skills": [],
        "mcps": []
      },
      // UI/UX implementer: medium reasoning for visual judgment
      "designer": { 
        "model": "openai/gpt-5.4-mini", 
        "variant": "medium",
        "skills": [],
        "mcps": []
      },
      // Rapid executor: lowest cost for bounded tasks
      "fixer": { 
        "model": "openai/gpt-5.4-mini", 
        "variant": "low",
        "skills": [],
        "mcps": []
      }
    }
  }
}

Verification

Confirm your Pantheon is operational:

# Launch OpenCode interactive mode
opencode

# Then execute:
ping all agents

You should see confirmation that all configured agents respond. If any fail, verify provider authentication and model availability.

REAL Code Examples From the Repository

Example 1: Manual Delegation Syntax

The simplest yet most powerful pattern — direct agent invocation from any OpenCode session:

@agentName <task>

This syntax bypasses Orchestrator routing for explicit specialist control. Critical for:

Council invocations (@council compare these architectures) where automatic delegation is intentionally restricted due to cost
Oracle consultations (@oracle should we use CQRS here?) for architectural decisions
Designer requests (@designer improve this component's accessibility) for focused UI work

The Orchestrator prompt at src/agents/orchestrator.ts contains the full delegation rules, but manual calls override these heuristics when you need precise control.

Example 2: Complete Configuration with Alternative Provider

The bundled opencode-go preset demonstrates mixed-provider architecture — using Chinese models for cost efficiency:

{
  "preset": "opencode-go",
  "presets": {
    "opencode-go": {
      // GLM-5.1 as orchestrator — strong Chinese model, not multimodal
      "orchestrator": { 
        "model": "opencode-go/glm-5.1", 
        "skills": [ "*" ], 
        "mcps": [ "*", "!context7" ] 
      },
      // DeepSeek V4 Pro for maximum reasoning depth
      "oracle": { 
        "model": "opencode-go/deepseek-v4-pro", 
        "variant": "max",           // Maximum reasoning effort
        "skills": ["simplify"], 
        "mcps": [] 
      },
      // Parallel consensus with same high-reasoning model
      "council": { 
        "model": "opencode-go/deepseek-v4-pro", 
        "variant": "high", 
        "skills": [], 
        "mcps": [] 
      },
      // MiniMax M2.7 for fast research and exploration
      "librarian": { 
        "model": "opencode-go/minimax-m2.7", 
        "skills": [], 
        "mcps": [ "websearch", "context7", "grep_app" ] 
      },
      "explorer": { 
        "model": "opencode-go/minimax-m2.7", 
        "skills": [], 
        "mcps": [] 
      },
      // Kimi K2.6 for design — enables Observer automatically
      "designer": { 
        "model": "opencode-go/kimi-k2.6", 
        "variant": "medium", 
        "skills": [], 
        "mcps": [] 
      },
      // DeepSeek Flash for rapid implementation
      "fixer": { 
        "model": "opencode-go/deepseek-v4-flash", 
        "variant": "high",          // Higher reliability for code gen
        "skills": [], 
        "mcps": [] 
      }
    }
  }
}

Key insight: This preset automatically enables the Observer agent because GLM-5.1 lacks multimodal capabilities. The kimi-k2.6 Designer provides vision support without forcing the Orchestrator to upgrade.

Example 3: V2 Background Orchestration Launch

Enable true parallel agent execution with experimental flags:

# Install beta channel with background orchestration support
bunx oh-my-opencode-slim@beta install

# Critical: set environment variable before launching OpenCode
export OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=1

# Launch with experimental support enabled
opencode

In V2, the Orchestrator becomes a pure scheduler: it plans work, dispatches specialists as background tasks, polls their status, then reconciles results before continuing. This eliminates sequential blocking — while Explorer searches, Designer can prototype, and Librarian researches simultaneously.

Example 4: Custom Subagent Definition

For advanced users, define entirely new agents via agents.<name> in configuration:

{
  "agents": {
    "security-auditor": {
      // Normal prompt for direct invocations
      "prompt": "You are a security-focused code reviewer...",
      // Orchestrator-specific prompt for automatic delegation
      "orchestratorPrompt": "Delegate security-sensitive code review tasks...",
      "model": "anthropic/claude-opus-4.6",
      "skills": ["simplify"],
      "mcps": ["grep_app"]
    }
  }
}

The dual-prompt structure (prompt vs orchestratorPrompt) enables contextual behavior: different instructions when called directly versus when routed by Orchestrator.

Advanced Usage & Best Practices

Model Selection Strategy

Never use your most expensive model everywhere. Follow the repository's guidance:

Orchestrator: Your strongest all-around coder — it implements AND delegates
Oracle/Council: Reserve premium reasoning for genuine architectural uncertainty
Explorer/Librarian/Fixer: Fast, cheap models dominate — speed > reasoning depth
Designer: Prioritize models with strong UI/UX judgment, not raw coding power

Token Optimization Tactics

Disable unused agents in disabled_agents to prevent accidental costly invocations
Use variant: "low" for Explorer and Librarian — they don't need deep reasoning
Manual Council calls only — automatic multi-model consensus would bankrupt most workflows
Enable Observer only when processing visual assets — it prevents multimodal bloat in main context

Preset Switching for Cost Control

The /preset command enables runtime switching between configurations. Maintain a $30 preset for routine work and an author's preset for critical architectural sessions. The repository documents a budget mixed-provider setup achieving full Pantheon functionality for approximately $30/month.

Session Goal Pinning

Use /goal to pin session objectives. This keeps todo lists, delegation decisions, and verification criteria aligned across long-running agent interactions — critical for complex multi-file implementations.

Comparison with Alternatives

Dimension	oh-my-opencode-slim	Single-Model Agents (Claude Code, etc.)	Original oh-my-opencode
Token Efficiency	⭐⭐⭐⭐⭐ Optimized routing minimizes premium model usage	⭐⭐ One model handles everything, maximum burn	⭐⭐⭐ Baseline, no slim optimizations
Model Flexibility	⭐⭐⭐⭐⭐ Mix any providers, custom presets	⭐⭐ Locked to single provider/model	⭐⭐⭐⭐ Good, but more bloat
Parallel Execution	⭐⭐⭐⭐⭐ V2 background orchestration	⭐ Sequential processing	⭐⭐⭐ Limited parallelism
Setup Complexity	⭐⭐⭐ JSONC configuration, multiple presets	⭐⭐⭐⭐ Simple, but limited	⭐⭐ More complex, more features
Community Momentum	⭐⭐⭐⭐⭐ 4,000+ stars, 48+ contributors	N/A (vendor products)	⭐⭐⭐ Declining vs. slim fork
Cost Predictability	⭐⭐⭐⭐⭐ Per-agent model control	⭐⭐ Single expensive model	⭐⭐⭐ Moderate
Specialization Depth	⭐⭐⭐⭐⭐ Seven distinct agent personas	⭐⭐ Generalist approach	⭐⭐⭐⭐ Same agents, heavier implementation

The verdict: If you're spending $100+/month on AI coding tools and feel like you're not getting proportional value, oh-my-opencode-slim's heterogeneous model routing will immediately reduce costs while improving output quality.

FAQ

Is oh-my-opencode-slim free to use?

The plugin itself is MIT licensed and free. You pay only for the underlying API calls to your chosen providers. The $30 preset documentation proves budget-friendly operation is achievable.

Can I use this without OpenCode?

No — it's explicitly an OpenCode plugin. However, OpenCode supports multiple LLM providers, and the plugin works with Claude Code, AmpCode, Cursor, and other OpenCode-compatible environments.

How does this differ from AutoGPT or other agent frameworks?

oh-my-opencode-slim is not a general-purpose agent framework. It's a specialized orchestration layer within OpenCode's existing ecosystem, with deep integration into its session management, MCP tools, and subagent architecture. The Pantheon personas are handcrafted for software engineering workflows.

Will V2 background orchestration break my existing workflow?

V2 is opt-in via @beta install and experimental flags. The stable channel maintains traditional execution. Beta users report significant speedups for multi-step tasks, but background task management adds complexity.

Can I add my own custom agents?

Absolutely. The agents.<name> configuration supports custom prompt and orchestratorPrompt blocks, plus full model/skill/MCP customization. The documentation includes examples for extending the Pantheon.

What if an agent fails or hallucinates?

The ping all agents verification catches configuration issues. For runtime failures, the Orchestrator's reconciliation logic in V2 handles partial results. Manual delegation (@agentName) lets you bypass automatic routing when you distrust a specific path.

Is this suitable for large enterprise codebases?

Especially so. The Explorer's codemap generation, Librarian's documentation tools, and session continuation features address scale challenges that break single-model approaches. The $30 preset proves cost efficiency at volume.

Conclusion

oh-my-opencode-slim isn't just another tool in the AI coding arms race — it's a fundamental architectural rethink. By treating model selection as a routing problem rather than a default setting, it extracts maximum value from every token while delivering superior, specialized outputs.

The 4,000+ stars and explosive contributor growth tell the story: developers are hungry for intelligent orchestration, not bigger context windows. The Pantheon architecture — Orchestrator, Explorer, Oracle, Council, Librarian, Designer, and Fixer — mirrors how elite engineering teams actually work, with strategic leaders delegating to domain specialists.

If you're still forcing one model to architect, research, design, and implement, you're leaving massive efficiency gains on the table. The future belongs to heterogeneous agent teams — and oh-my-opencode-slim puts that future in your terminal today.

Star the repository, install the plugin, and join the Pantheon. Your token budget will thank you.

👉 github.com/alvinunreal/oh-my-opencode-slim