Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

orchestrate

/orchestrate

Rozbija duże zadanie na podsesje, kontroluje liczbę pracowników, trzyma kompaktowy plik stanu i scala wyniki.

Licencja
MIT
Ostatnia zmiana repozytorium
01.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 01.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Rozbija duże zadanie na podsesje, kontroluje liczbę pracowników, trzyma kompaktowy plik stanu i scala wyniki.

Wyzwalacze z opisu

orchestratedispatchsplit this upsub-sessions

Argumenty

/orchestrate <the big task>
Oryginalny opis (EN)

Orchestrate a large task across sub-sessions with compact context. Decomposes the task, decides how many workers to use (0, 1 or N independent units, max 4), routes each unit to a subagent or a separate session with the right model, keeps a compact state file that survives compaction, and verifies the merged result. Use when the user gives a big multi-part task, says "orchestrate", "dispatch", "split this up", "sub-sessions", or "/orchestrate".

Jak działa

  1. Resume (do this first)
  2. 0. Load project rules first
  3. 1. Decompose
  4. 2. Decide the number of workers
  5. 3. Pick the vehicle for each worker
  6. 4. Pick the model
  7. 5. Write compact briefs
  8. 6. Track state in .orchestra/state.md
  9. 7. Integrate and verify
  10. Rules
Sekcje z nagłówków SKILL.md, w oryginale · 128 linii, 1 304 słów
Podgląd SKILL.md
---
name: orchestrate
description: Orchestrate a large task across sub-sessions with compact context. Decomposes the task, decides how many workers to use (0, 1 or N independent units, max 4), routes each unit to a subagent or a separate session with the right model, keeps a compact state file that survives compaction, and verifies the merged result. Use when the user gives a big multi-part task, says "orchestrate", "dispatch", "split this up", "sub-sessions", or "/orchestrate".
argument-hint: <the big task>
---

# Orchestrate

You are the **orchestrator**. Your job is to plan, dispatch, track and verify, not to carry the detail of every unit in your own context. Keep your context small: briefs out, compact reports in.

## Resume (do this first)

At start, if `.orchestra/state.md` exists, read it before anything else. List the units whose status is not `done`, tell the user in one line, and continue from the first unfinished wave (the `Wave:` line) instead of re-decomposing. Re-plan only if the user's new request changes the task.

## 0. Load project rules first

Before decomposing, check the project's skills (`.claude/skills/`) for an `orchestrate-<project>` skill and any `verify-*` skill. If present, load them: their rules (unit boundaries, waves, brief contents, verification commands) override this skill. Name the relevant project skills in each worker's brief.

## 1. Decompose

Break the task into **units**. For each unit write one line:

```
U<n> | <goal, ≤12 words> | files/area: <paths or globs> | depends on: <U ids or -> | kind: read | write | design
```

Read just enough of the codebase to decompose correctly (structure + signatures, not full files). If you cannot tell which files a unit touches, use the `explorer` agent to find out before deciding.

## 2. Decide the number of workers

Apply in order, stop at the first that fits:

1. **0 workers (do it inline)**: the whole task fits in roughly 15 tool calls or fewer, or units are tiny. Delegation costs more than doing it. Say so in one line.
2. **1 worker**: the task is large but **coupled**: units depend on each other in a chain, share files, or must land in one change. One worker runs them in sequence (or do it inline if your context is still small).
3. **N workers**: N = number of units that are **truly independent**: no dependency on another unit's result, no shared files, no need to land in the same commit. **Cap N at 4**; group extra units into the 4 workers by area. Dependent units wait for a later wave.

Waves: units whose dependencies are done form the next wave. Re-apply the rule per wave.

**Before dispatching, show the user the plan in 6 lines or fewer** (units, waves, worker count, model per worker) and proceed unless the plan includes something irreversible (push, deploy, migration on a shared DB, deleting data). Then ask first.

**Cost guard:** before each wave, estimate rough token spend per worker (brief + files it reads + output; opus costs several times sonnet or haiku). If the wave looks large, ask the user first and state the estimate. Threshold used here: more than 3 workers on opus, or 4 workers on sonnet each reading many files, or any Agent Teams run. Below it, proceed.

## 3. Pick the vehicle for each worker

| Unit needs… | Use |
|---|---|
| A result you need back in this turn (research, audit, locate code, review) | **Subagent**: `Agent` tool, `subagent_type: explorer` / `verifier` |
| Code edits that are part of this same change | **Subagent**: `Agent`, `subagent_type: implementer`, `isolation: "worktree"` when 2 or more writers run at once |
| An independent deliverable of its own (own branch / PR, may outlive this turn, user may want to steer it) | **Separate session**: in the Claude desktop app use `start_session` (`context: "fresh"`, own worktree); in the CLI use `Agent` with `isolation: "worktree"` and `run_in_background: true` |
| Units that must coordinate with each other (share findings, challenge each other, cross-layer changes) and can own disjoint files | **Agent Teams** (experimental): teammates message each other and share a task list. Needs `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in env or settings.json `env`, interactive session only (not `-p`). Higher token cost, no `/resume` of in-process teammates, one team per session. Ask the user before enabling. Otherwise prefer subagents. |

Isolation: use Claude Code's native worktrees. `claude --worktree <name>` starts a session in its own worktree; inside a session use the `EnterWorktree` tool, or `isolation: "worktree"` on `Agent`. Prefer these over hand-made `git worktree` calls.

**Desktop app default:** when two or more writers each produce a change of their own (own files, own branch), start each as a session with `start_session` (`context: "fresh"`, own worktree, a clear title) so the user sees them in the sidebar and can open, steer or stop them. Keep subagents for read-only work and for units whose result you need back inside this turn. Record each session's name and branch in `.orchestra/state.md`, and ask before merging its branch.

Never let two writers touch the same files. Read-only workers may share the checkout.

`isolation: "worktree"` only works when the working directory is a git repo. In a non-git workspace that holds several repos (for example one folder per package), isolate by scoping each writer to one repo folder; two writers in the same repo run in sequence, or each gets its own session started inside that repo.

## 4. Pick the model

- `haiku`: locating code, listing, grepping, summarizing files (the `explorer` agent default).
- `sonnet`: routine implementation, tests, checks (the `verifier` agent default).
- `opus` / inherit: architecture, tricky logic, cross-cutting refactors, anything design-heavy.

Pass `model` on the `Agent` call only to override the agent's default.

## 5. Write compact briefs

Each worker starts cold. Give it only what it needs: never the whole conversation, never "based on the findings above".

```
GOAL: <one sentence>
SCOPE: <files/dirs it may touch>; touch nothing else
CONTEXT: <5 bullets max: facts, decisions, conventions it needs>
DONE WHEN: <observable criteria: tests pass, endpoint returns X, file exists>
DO NOT: commit / push / switch branch (unless the unit is a separate session with its own branch)
SHELL: if a command is blocked by the shell policy, don't retry or reroute it; report what the user would need to allow under OPEN
REPORT: use the report format below, 10 lines max
```

If your setup routes shell commands through a specific tool (for example lean-ctx's `ctx_shell` with native Bash denied), say so in the SHELL line.

Report format every worker must return:

```
STATUS: done | partial | blocked
CHANGED: <files, one line>
DECISIONS: <non-obvious choices, 3 bullets max>
OPEN: <questions / risks, or ->
VERIFIED: <what was run and the result>
```

## 6. Track state in `.orchestra/state.md`

At the project root, create `.orchestra/state.md` and keep it current after every wave. It is the source of truth after a context compaction: if you lose track, re-read it first.

```markdown
# Task: <one line>
Updated: <ISO date-time>
Wave: <current wave number, e.g. 2/3>

## Units
| id | goal | worker | vehicle/model | status | branch/worktree |
|----|------|--------|---------------|--------|-----------------|

## Decisions
- ...

## Open questions
- ...

## Next
- ...
```

Keep it short: replace, don't append history. If the project is a git repo, add `.orchestra/` to `.git/info/exclude` (local, not committed) unless the user wants it tracked.

## 7. Integrate and verify

- Treat each report as a claim, not proof: check the diff or key files yourself (briefly).
- Worktree branches: **ask the user before merging** them here; never push them yourself. Name branches as `refs/heads/<name>`.
- Run the final check last (tests/build/lint over the whole result) via the `verifier` agent or inline. Say plainly what passed, what failed, and what could not be covered.
- On `partial`/`blocked`: fix inline if small, otherwise re-dispatch one targeted worker with a new brief that includes the blocker.

## Rules

- Small task: don't orchestrate; just do it and say so in one line.
- Never more than 4 parallel workers.
- Your context holds: the plan, the state file, the reports. Not file dumps.
- Follow the user's own git rules in every brief that involves git (commit message style, attribution, branch naming).
- Answer the user in the language they used.

Wersje

RepozytoriumWynikLicencja
Ta strona · NefziSofien/claude-code-orchestra100MIT
kriegcloud/beep-effect100Apache-2.0
zahidakhyar/skills100MIT
jkaloger/lazyspec100MIT
superset-sh/superset100MIT
boshu2/agentops100Apache-2.0
Ovich/charrette100MIT
matthew-eth724/orchestrate100MIT
nickthelegend/nick-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 5252a67dcdeb (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100fable-orchestrate
    Rozkłada zadanie na samodzielne specyfikacje i deleguje je workerom Sonnet 5.5 pod kierunkiem orkiestratora Fable 5.1, scala wyniki w jedną gałąź i bierze wiążący werdykt recenzenta.
  • 100plan-orchestrate
    Czyta dokument planu, dzieli go na kroki i układa łańcuchy agentów w gotowe polecenia do wklejenia.
  • 100ops-orchestrate
    Prawdopodobnie koordynuje pracę nad wieloma projektami i rozdziela zadania między agentów.
  • 100teams
    Koordynuje zespół agentów, rozbija zadanie, uruchamia współpracowników i nadzoruje wykonanie w kilku sesjach Claude Code.
  • 100loop
    Prowadzi cel przez iteracje podagentów: rozkłada go na części, wysyła po jednym podagencie na iterację ze świeżym kontekstem i weryfikuje wynik, zanim trafi do pamięci.
  • 100orchestrate-round
    Steruje rundami arcgentic w jednej sesji: uruchamia subagentów ról, weryfikuje ustrukturyzowane wyniki i zamyka rundę tylko po zaliczeniu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.