OpenCode Ensemble plugin
An OpenCode plugin that runs a team of parallel agents with separate sessions, a shared task board and messaging
- 254 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Teammates with the build role edit files and run commands in separate worktrees, and the external_directory allow rule removes prompts for those directories
- Several agents spend model tokens in parallel, and the cost grows with the number of teammates
- The local dashboard opens on port 4747 and shows agent prompts and messages
Install
- Works in
Manual install
opencode plugin add @hueyexe/opencode-ensemble@0.18.0After installing, restart OpenCode and add an `external_directory` allow rule for `~/.local/share/opencode/worktree/**` to the config.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Teammates with the build role edit files and run commands in separate worktrees, and the external_directory allow rule removes prompts for those directories
- Several agents spend model tokens in parallel, and the cost grows with the number of teammates
- The local dashboard opens on port 4747 and shows agent prompts and messages
This is third-party code. Review the repository files before installing.
What it does
OpenCode Ensemble gives the lead agent team tools: it creates a team, adds tasks to a shared board and spawns teammates. Each teammate works in its own OpenCode session with a fresh context and a separate git worktree branch, so parallel file edits do not conflict. Read-only agents such as a scout and a reviewer run without a worktree. There are 14 tools; the lead has all of them and teammates get six for messaging and tasks. `team_create`, `team_spawn`, `team_shutdown`, `team_merge` and `team_cleanup` manage the lifecycle, `team_message`, `team_broadcast` and `team_results` handle communication, and `team_tasks_add`, `team_tasks_list`, `team_tasks_complete` and `team_claim` run the board. Tasks link through `depends_on`, and an implementer making a dangerous edit gets `plan_approval`: it sends a plan first and edits begin after approval. The lead merges finished branches with `team_merge`, and the changes stay in the working directory as unstaged files for review through `git diff`. While OpenCode runs, a dashboard at `http://localhost:4747` shows agent cards, the task board and an event feed. Models are assigned by agent type, from a pool in rotation, or by asking the user.
Who it is for. OpenCode users whose tasks split into independent pieces: scouting, implementation, tests and review.
Good fit when
- Fixing webhook idempotency needs code scouting, an edit, regression tests and a separate review
- Two or three modules change independently, and each agent keeps its own branch without conflicts
- A risky change goes through a plan first, and the developer approves it before the first edit
- Different roles need different models, such as a cheap one for scouting and a strong one for implementation
Not a fit when
- The work happens in Claude Code or Cursor: the plugin is written for OpenCode and does not run in other agents
- The task is small and sequential: teammates add token and coordination costs with no gain
- The runtime is old: Bun or Node 24 and newer is required for the built-in SQLite
Example request
Fix Stripe webhook idempotency so duplicates do not create orders: assemble a team of scout, developer, tester and reviewerLimitations
- The plugin works only in OpenCode and uses SQLite, so Bun or Node 24 and newer is required.
- The OpenCode config needs an allow rule for the worktree directory, otherwise every teammate operation triggers a permission prompt.
- The plugin version should be pinned: because of an OpenCode bug an unpinned package never updates.
- In the first OpenCode version a teammate message can switch the lead agent to build mode.
How to disable. Remove the `@hueyexe/opencode-ensemble` entry from the plugin list in `opencode.json` and restart OpenCode. Set `dashboardPort: 0` in `ensemble.json` to disable the dashboard port.
FAQ
Where do teammate edits end up?
Each works in its own worktree branch, and `team_merge` merges the branch into the working directory as unstaged changes. Review them with `git diff` and commit yourself.
How do I install the plugin in OpenCode?
Run `opencode plugin add @hueyexe/opencode-ensemble@0.18.0` and restart OpenCode. Then add an allow rule for the worktree directory to the config, otherwise the agent asks for access on every action.
Can each agent get its own model?
Yes, in four ways: the `model` parameter of `team_spawn`, the `modelsByAgent` map, rotation from `modelPool`, or a default model in `ensemble.json`. If nothing is set, the OpenCode model is used.
How do I install the skill with team-shape advice?
The command `npx skills@latest add hueyexe/opencode-ensemble --skill opencode-ensemble` installs a separate skill that teaches the agent to split work into independent pieces and write teammate prompts.
How many teammates should I start with?
Two or three is enough to begin: more agents add coordination overhead. Give each a self-contained task and set `worktree: false` for read-only agents.
Discussion
No questions or reviews yet.
Related
PluginsA kit that gives OpenCode role-based agents, handoffs, independent review and task state that survives interruptions.
An OpenCode plugin: an orchestrator hands work to six specialists, each on its own model, and merges their results into one answer
An open source coding agent for the terminal and desktop with build and plan modes
Orchestrator plugin for OpenCode and Codex CLI: multiple agents, hooks, built-in MCPs, ultrawork mode and hash-anchored edits
multi-agents runs a team of coding agents on a task and measures whether it beat a single agent and what it cost.
A planner for Claude Code, Codex and OpenCode: one goal becomes a task plan and independent tasks run in parallel
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| OpenCode Ensemble (this card) | no | 254 | |
| OpenCode Swarm | no | 518 | turns a session into a team led by an architect and runs work by plan phases; here teammates claim tasks from a shared board |
| oh-my-opencode-slim | no | 10,127 | an orchestrator hands work to six specialists with fixed roles; here the lead agent assembles the team for the task |
README in short
The README opens with a quick start and an example team fixing idempotency. Then come the companion skill, the dashboard, runtime requirements, installation with the worktree permission, tables of 14 tools and the architecture. It ends with model selection, configuration, tips, known limitations and differences from agent teams in Claude Code.