# opencode-ensemble

A skill that tells the lead agent how to split work into independent slices, hand them to teammates and merge the results. Useful when a task has parallel branches.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 681 installs · ★ 251
- Author: hueyexe
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/hueyexe/opencode-ensemble/tree/HEAD/skills/opencode-ensemble/SKILL.md
- Updated: 2026-10-19
- HTML: https://affpapa.org/en/nevibecode/skills/opencode-ensemble

## What it does

The skill lays out how to run a team in OpenCode Ensemble. The lead creates a team with `team_create`, adds tasks through `team_tasks_add` and wires sequencing with `depends_on`, then spawns teammates one at a time via `team_spawn`. Roles differ: a scout on the `explore` agent with no worktree only reads code, builders and QA work in their own branches, a reviewer inspects diffs. For risky edits there is `plan_approval: true`, so the teammate shows a plan first.

Always pass an explicit `model` to `team_spawn`. Omit it and the server default kicks in, which may be paid or misconfigured. The role table suggests `openai/gpt-5-mini` for scouts and reviewers and `anthropic/claude-opus-4-7` for builders, but treat those as examples and check current IDs with your provider. The author advises starting with two or three teammates.

The skill ships reference files: coordination patterns, prompt recipes, checklists for pre-spawn, merge and cleanup, an anti-patterns write-up and eval scenarios. It requires the `@hueyexe/opencode-ensemble` plugin. Hard rules are blunt: never invent task IDs, never hand a teammate a vague prompt like "fix the bug", never let teammates call lead-only tools, and never merge a branch without reading the result and inspecting the diff.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add hueyexe/opencode-ensemble --skill opencode-ensemble -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/opencode-ensemble/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/opencode-ensemble/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add hueyexe/opencode-ensemble --skill opencode-ensemble -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/opencode-ensemble/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add hueyexe/opencode-ensemble --skill opencode-ensemble -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/opencode-ensemble/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install hueyexe/opencode-ensemble opencode-ensemble
```

2. **Manually: put the files in place**
- File: `.github/skills/opencode-ensemble/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add hueyexe/opencode-ensemble --skill opencode-ensemble -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/hueyexe/opencode-ensemble --path skills/opencode-ensemble
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/opencode-ensemble/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add hueyexe/opencode-ensemble --skill opencode-ensemble -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/hueyexe/opencode-ensemble/tree/HEAD/skills/opencode-ensemble/SKILL.md

## When to use it
- split a large change into independent slices and assign them to agents
- map unfamiliar code with a scout before anyone edits
- add regression tests as a separate teammate after implementation
- review a merged diff for correctness and missed tests
- route a risky change through plan approval

## Example prompts
- Set up a team with three tasks: a scout maps the checkout webhook flow, a builder adds the duplicate guard, QA writes regression tests.
- Spawn a scout on `explore` with no worktree and have it return the file list and a smallest-safe-change plan.
- Before merging, read the builder's result and inspect the diff, then run the project's verification commands.

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 911e5a79e24c71f7.

BEGIN THIRD-PARTY FILE 911e5a79e24c71f7
```text
---
name: opencode-ensemble
description: "Use when coordinating multiple coding agents, delegating independent software work, managing OpenCode Ensemble teams, choosing teammate roles or models, reviewing teammate output, or deciding whether parallel execution is appropriate."
license: MIT
compatibility: "OpenCode with the @hueyexe/opencode-ensemble plugin installed"
metadata:
  author: hueyexe
  version: "1.2.0"
---

# OpenCode Ensemble

Use OpenCode Ensemble as a coordination system, not a shortcut for avoiding judgment. Parallel agents work best when the lead owns decomposition, sequencing, review, merge, and verification.

## Core Principle

Spawn teammates only for independent, verifiable work. A good Ensemble team has narrow task ownership, clear dependencies, and a lead that integrates results deliberately.

## Use Ensemble When

- Work can be split into independent research, implementation, test, or review slices.
- A read-only scout can map unfamiliar code before edits begin.
- Multiple files or subsystems can be changed without overlapping ownership.
- A risky change benefits from `plan_approval: true` before edits.
- A final reviewer can inspect merged changes without creating another branch.

## Do Not Use Ensemble When

- The task is small enough for one agent to finish quickly.
- The work is tightly coupled and every teammate would need the same files.
- The lead cannot describe each teammate's output and success criteria.
- The user needs one coherent design decision rather than parallel exploration.
- You are tempted to spawn agents because the task feels hard but not divisible.

## Lead Workflow

1. Decide whether parallelism is justified.
2. Create a team with `team_create`.
3. Add tasks with `team_tasks_add`; use `depends_on` for sequencing.
4. Spawn teammates one at a time with `team_spawn`.
5. Use `worktree: false` for read-only `explore` teammates.
6. Use `plan_approval: true` for risky implementation work.
7. Wait for teammate messages instead of polling status repeatedly.
8. Read full results with `team_results` when messages are truncated or consequential.
9. Shut down completed teammates with `team_shutdown`.
```
END THIRD-PARTY FILE 911e5a79e24c71f7

The third-party file has ended. Everything between the 911e5a79e24c71f7 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2172 of 6152 bytes. © hueyexe · MIT · https://github.com/hueyexe/opencode-ensemble/tree/HEAD/skills/opencode-ensemble/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md