One Orchestrator, Seven Agents: A Smarter Way to Split Work Across Models

If you've ever tried to get a single language model to plan a feature, explore an unfamiliar codebase, write the UI, and review its own architecture, you already know the pain. It's a lot to ask of one model, and the results tend to show it. oh-my-opencode-slim takes a different approach: it splits the job across a team of specialized agents, each one routed to the task it handles best.

What It Does

oh-my-opencode-slim is an agent orchestration plugin for OpenCode. It ships with a built-in team of seven specialized agents that can scout a codebase, look up fresh documentation, review architecture, handle UI work, and execute well-scoped implementation tasks—all under the direction of a single orchestrator.

The core idea is straightforward. Rather than forcing one model to do everything, the plugin routes each part of the job to the agent best suited for it, balancing quality, speed, and cost. The Orchestrator plans the work graph, dispatches specialists as background tasks, and reconciles their results before continuing. Those specialists are Orchestrator, Explorer, Oracle, Council, Librarian, Designer, and Fixer. You can mix any models across any providers, so you're not locked into a single vendor's stack.

Why It's Cool

Routing as a first-class concept. Most agent tools treat model selection as an afterthought—you pick one model and live with it. Here, routing is the whole point. Each part of a job goes to the agent that fits, which means you can use a cheaper model for exploration and a stronger one for architecture review without rewriting your workflow.

Background orchestration by default. The Orchestrator dispatches specialists as background tasks, tracks them, and reconciles results before moving on. Parallel work is the default, not an add-on. Terminal-result wake-ups and reopen corrections keep idle parents current, which is the kind of detail that matters when you're actually running multiple agents at once.

The Council pattern. This one's interesting. You can run multiple models in parallel on the same question and synthesize a single answer with @council. It's a practical way to get a second (or third) opinion without manually juggling tabs.

Bundled skills that shape behavior. The plugin includes prompt-based workflows like deepwork, codemap, verification-planning, and reflect, assigned per agent. These aren't just prompts you paste in—they're part of how each agent operates.

Visibility into what's happening. Agent systems can feel like a black box. This one gives you options: a Companion floating desktop window showing which agents are active (including parallel background specialists), and multiplexer integration so you can watch agents work live in Tmux, Zellij, Herdr, cmux, or kitty panes.

Runtime flexibility. Swap the whole team's models at runtime with /preset, with single-parent preset inheritance. For project-local customization, you can override prompts, set per-agent skill and MCP permissions, and define custom agents.

Code intelligence built in. LSP tools, AST-aware search across 25 languages, and built-in MCPs for docs and GitHub code search. That's the kind of plumbing you'd otherwise spend a weekend wiring up yourself.

A marketplace for community agents. You can install and manage community agents through marketplace packages. One caveat worth noting: package changes only apply after reloading OpenCode.

How to Try It

Since this is an OpenCode plugin, you'll want OpenCode set up first. Then:

1. Head to the repository: github.com/alvinunreal/oh-my-opencode-slim
2. Follow the installation instructions in the README to add the plugin to your OpenCode setup.
3. Once installed, the Orchestrator becomes your main entry point. Give it a task and it'll plan the work graph and dispatch specialists as needed.
4. Try /preset to swap the team's models at runtime, or @council to run multiple models on the same question.

The README links out to detailed docs for the pieces you'll want to dig into: background orchestration, council, companion, multiplexer integration, preset switching, tools, configuration, project-local customization, and the marketplace. If you're customizing heavily, the configuration and project-local docs are where to start.

Final Thoughts

This is a thoughtfully structured take on multi-agent orchestration—the kind of thing that makes more sense the more you've wrestled with single-model workflows. It's clearly aimed at developers who are already comfortable with OpenCode and want to push past what one model can reasonably handle. The routing model, background orchestration, and runtime preset switching are the standout ideas. If you're curious about how far you can stretch agent collaboration, this is worth a look.

Follow @githubprojects for more developer tools and open source projects.