К основному содержанию
скилл CX Codex

oma-orchestration · first-fluke — скилл для Claude Code: что делает и как установить

Скилл oma-orchestration для Claude Code разбивает сложную задачу на части и запускает параллельных специализированных агентов. Отслеживает полный цикл фронтенд-бэкенд-QA до результата.

MIT ★ 1 472 обновлён 2026-11-12

Установить в Claude Code · Через маркетплейс плагинов Все способы и платформы ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Открыть на GitHub

Что делает oma-orchestration

Скилл разбирает запрос на задачи с приоритетами, сопоставляет каждую с доменом по сигнатуре намерений установленных скиллов oma-* и выбирает нужные референсы. Дальше идёт по сценам: подготовка сессии и файлов памяти, запуск агентов по приоритету с учётом лимита параллелизма, проверка через oma verify и QA-кросс-ревью, повторный запуск при провале проверки и финальная сборка отчёта с сохранёнными артефактами.

Диспетчеризация агентов идёт либо через нативный путь платформы, если вендор совпадает с текущим рантаймом, либо через запасной вызов oma agent spawn <agent-type> <prompt-file> <session-id> --task-id <task.id> -w <workspace>. Для работы нужен .agents/oma-config.yaml или конфиги агентов в .codex/agents/*.toml и .gemini/agents/*.md — без них скилл не определит, кого и как запускать.

При исчерпанных лимитах восстановления скилл не форсирует завершение, а возвращает статус partial или failed с сохранённой историей ревью. Для простой задачи в одном домене или ручного пошагового контроля разработчики используют oma-coordination, а не этот скилл.

Какие задачи решает

  • разбить фичу на задачи для нескольких специализированных агентов
  • запускать агентов параллельно с лимитом по числу одновременных процессов
  • прогонять автоматическую проверку и QA-кросс-ревью результатов
  • повторно запускать агентов с историей ревью после провала проверки
  • собирать финальный отчёт и артефакты сессии после параллельной работы

Примеры запросов агенту

  • Запусти oma-orchestration и прогоните фичу через бэкенд, фронтенд и QA параллельно
  • Оркеструй эту задачу: разбей на части и запусти агентов автоматически
  • Запусти оркестрацию с проверкой через oma verify и повторными попытками при провале

Как установить oma-orchestration

1Через маркетплейс плагинов

/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent

Команда ставит плагин oma целиком, со всеми его скиллами

2Через Skills CLI (Vercel)

npx skills add first-fluke/oh-my-agent --skill oma-orchestration -a claude-code

3Вручную: положить файлы

~/.claude/skills/oma-orchestration/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/oma-orchestration/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об oma-orchestration

Как установить oma-orchestration в Claude Code?

Выполните /plugin marketplace add first-fluke/oh-my-agent, затем /plugin install oma@oh-my-agent.

Что делает oma-orchestration?

Скилл разбивает сложную задачу на приоритетные подзадачи, запускает под них параллельных специализированных агентов, прогоняет проверку и QA-кросс-ревью и собирает итоговый отчёт с сохранением состояния сессии.

Что нужно для запуска oma-orchestration?

Нужен конфиг .agents/oma-config.yaml или файлы агентов в .codex/agents/*.toml и .gemini/agents/*.md; без запасного пути oma agent spawn скилл не сможет диспетчеризовать агентов.

Исходный текст

SKILL.md · MIT
---
name: oma-orchestration
description: Dispatch and supervise parallel specialist agents with durable task
  state. Use when automated multi-agent execution is requested.
---

# Orchestration - Automated Multi-Agent Coordination

## Scheduling

### Goal
Automatically orchestrate multi-agent execution with task decomposition, native/fallback dispatch, memory coordination, progress monitoring, verification, QA cross-review, retry, and result collection.

### Intent signature
- User asks to orchestrate, run in parallel, automate multi-agent execution, or coordinate full-stack work end to end.
- Task requires multiple specialist agents and a persistent review/remediation loop.

### When to use
- Complex feature requires multiple specialized agents working in parallel
- User wants automated execution without manually spawning agents
- Full-stack implementation spanning backend, frontend, mobile, and QA
- User says "run it automatically", "run in parallel", or similar automation requests

### When NOT to use
- Simple single-domain task -> use the specific agent directly
- User wants step-by-step manual control -> use oma-coordination
- Quick bug fixes or minor changes

### Expected inputs
- Complex feature or workflow request
- Project config, model/vendor routing, agent types, task constraints, and workspace/session needs
- Acceptance criteria and verification expectations

### Expected outputs
- Orchestrator session state, task board, progress files, result files, and final summary
- Specialist agent outputs after mechanical checks, automated verify, and QA cross-review
- Review history and retry/remediation status when loops fail

### Dependencies
- `.agents/oma-config.yaml`, `.codex/agents/*.toml`, `.gemini/agents/*.md`, or fallback `oma agent spawn`
- Memory provider config, subagent prompt template, scripts, task templates, verify script, and session metrics

### Control-flow features
- Branches by vendor/native dispatch availability, priority tiers, agent completion/failure, verification status, QA verdict, retry limits, and unresolved decisions
- Spawns processes/agents and reads/writes memory/result files
- Preserves unresolved evidence when bounded recovery stops

## Structural Flow

### Entry
1. Resolve agent vendor routing and runtime dispatch path.
2. Decompose request into priority-tiered tasks.
3. For each task, classify into one or more `domain_tags` by matching against the `Intent signature` block of each installed `.agents/skills/oma-*/SKILL.md`. Tasks that match no domain confidently inherit the union of their parent feature's tags.
4. Select the references needed by each task. One confidently matched skill is sufficient; expand the set when classification is uncertain or a dependency requires another domain.
5. Record selected domains, references, and any fallback reason in the task board. These are coordinator notes, not launcher-enforced exposure fields; use only reference/context controls supported by the active dispatch path.
6. Apply the shared collaboration policy before dispatch: assign edit ownership, peer contact paths, and a collection owner.

### Scenes
1. **PREPARE**: Plan, setup session ID, and initialize memory files.
2. **ACT**: Spawn agents by priority tier within parallelism limits.
3. **VERIFY**: Run self-check, `oma verify`, and QA cross-review loop.
4. **RECOVER**: Retry failed agents with review history when limits allow.
5. **FINALIZE**: Collect verified claims, compile summary, and preserve progress artifacts.

### Transitions
- If native dispatch is available for current runtime/vendor, use it.
- If vendors differ or native path is unavailable, use fallback spawn.
- Record the dispatch path per target vendor with subject `orchestration.route-selection` per `references/_shared/runtime/route-selection.md` (native or `oma agent spawn`, and the vendor match or unavailability that decided it).
- If verify or QA fails, feed feedback back to the implementation agent.
- If recovery limits are exceeded, preserve review history and return `partial` or `failed`; never force completion.
- If recovery shows that a required domain reference was missing, update the task's reference selection without changing its frozen acceptance contract, and supply it through the supported context mechanism.

### Failure and recovery
- Retry failed agents up to configured limits.
- Re-spawn with review history when review loop is exhausted.
- Continue independent work after recording material corrections; ask only for a material missing decision.

### Exit
- Success: all tasks complete, verify/review pass, and results are summarized.
- Partial success: failed agents, exhausted review loops, or missing verification are explicit.

## Logical Operations

### Actions
| Action | SSL primitive | Evidence |
|--------|---------------|----------|
| Read config and task context | `READ` | oma config, routing, request |
| Classify task into domain tags | `INFER` | task text vs each skill's `Intent signature` |
| Select task references | `SELECT` | confident domain matches, dependencies, and supported context controls |
| Select dispatch path | `SELECT` | Native vs fallback |
| Write session state | `WRITE` | task board and memory files |
| Spawn agents | `CALL_TOOL` | exposed native role-subagent tool or `oma agent spawn` |
| Poll progress | `READ` | progress/result files |
| Run verification | `CALL_TOOL` | `oma verify`, tests, QA |
| Update retry state | `UPDATE_STATE` | loop counters and CD metrics |
| Report final result | `NOTIFY` | compiled summary |

### Tools and instruments
- Exposed native role-subagent tools, fallback spawn scripts, memory tools, verify script, QA agent
- Session metrics, prompt templates, task templates

### Canonical command path
```bash
oma agent spawn <agent-type> <prompt-file> <session-id> --task-id <task.id> -w <workspace>
oma verify agent <agent-type> --workspace <workspace> --json
```

When native runtime dispatch is available, prefer the runtime-specific native path listed in this skill before falling back to `oma agent spawn`.

### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `LOCAL_FS` | Session, task-board, progress, result, config files |
| `PROCESS` | Agent CLI processes and verify scripts |
| `MEMORY` | Session state and unresolved decisions |
| `CODEBASE` | Workspaces owned by spawned agents |

### Preconditions
- Task is decomposable into specialist agent work.
- Runtime/vendor dispatch path or fallback exists.

### Effects and side effects
- Spawns agents and writes session/progress/result artifacts.
- May cause code changes through specialist agents.
- May trigger iterative review and retries.

### Guardrails
1. Orchestrate per-agent dispatch from the project configuration before spawning any agent.
2. If `target_vendor === current_runtime_vendor` and the runtime has a verified native path, use native dispatch.
3. Otherwise fall back to `oma agent spawn`.
4. Never exceed configured parallelism or the aggregate recovery budget. Ordinary retries and exploration hypotheses both consume it.
5. Keep session state, task-board state, progress files, claims, and receipts aligned. Use the plan task ID on every spawn and native begin/finish path.
6. Select references by task needs and confidence. Do not expand to all skills solely because one skill matches, or assume task-board metadata enforces runtime exposure.

Current native executor paths:
- Claude Code: Agent tool with `.claude/agents/{agent}.md` definitions (multiple Agent tool calls in one message run in parallel; results return synchronously — no polling)
- OpenCode / Kilo Code: native `task` tool with `subagent_type: {agent-id}`; do not use `oma agent spawn` for same-session OpenCode or Kilo work because it will not appear as a native child task
- Codex: use the current session's exposed native subagent tool with the resolved custom role from `.codex/agents/*.toml` when supported; otherwise use `oma agent spawn`. Model tiering follows `references/_shared/core/vendor-detection.md`.
- Gemini: use the current session's exposed native role-subagent tool with the resolved role when supported; otherwise use `oma agent spawn`.

`codex exec` and `gemini -p` start external CLI sessions. An `@agent` string in a prompt does not establish native dispatch or apply a custom-role contract.

### Configuration

| Setting | Default | Description |
|---------|---------|-------------|
| MAX_PARALLEL | 3 | Max concurrent subagents |
| MAX_RECOVERY_ATTEMPTS | 3 | Total retries and exploration hypotheses per task, including the original attempt |
| POLL_INTERVAL | bounded backoff | Fallback only when completion notifications are unavailable |
| Turn guidance | role-specific | Checkpoint/resume signal, not a hard stop or approval boundary |

These are workflow defaults. Resolve model/vendor, parallelism, and budget settings from project configuration. `config/cli-config.yaml` supplies the vendor transport registry; it does not select the active vendor or override runtime execution settings.

### Memory Configuration

Memory provider and tool names are configurable via `.agents/mcp.json` (not the repo-root `.mcp.json`, which is the Claude Code MCP server config):
```json
{
  "memoryConfig": {
    "provider": "file",
    "basePath": ".agents/state/memories",
    "tools": {
      "read": "Read",
      "write": "Write",
      "edit": "Edit"
    }
  }
}
```

### Workflow Phases

**PHASE 1 - Plan**: Reuse the current valid plan or decompose the request; preserve injected session/task/run IDs.
**PHASE 1.5 - References**: Select task references as described in Entry; record uncertainty and expansion reasons without assuming runtime enforcement.
**PHASE 2 - Setup**: Create session/task-board artifacts with the current IDs and selected references.
**PHASE 3 - Execute**: Dispatch ready tasks within MAX_PARALLEL using supported native or fallback context controls.
**PHASE 4 - Monitor**: Prefer completion notifications; otherwise use one coordinator with bounded polling backoff. Follow `references/_shared/core/execution-policy.md` for the shared deadline, cancellation, resource ownership, and shutdown rules. Cancellation or deadline exhaustion stops dispatch and recovery before verification.
**PHASE 4.5 - Verify**: Run mechanical checks for every completed agent; run `oma verify agent {agent-type}` only for `backend`, `frontend`, `mobile`, `qa`, `debug`, and `pm`; then run QA cross-review for every completed implementation
**PHASE 5 - Collect**: Read claims and run-scoped reports for plan tasks whose checks passed; compile summary without deleting evidence.

### Memory File Ownership

| File | Owner | Others |
|------|-------|--------|
| `orchestrator-session-{sessionId}.md` | orchestrator | read-only |
| `task-board-{sessionId}.md` | orchestrator | read-only |
| `progress-{agentId}-{taskId}-{runId}-{sessionId}.md` | that run | orchestrator reads |
| `result-{agentId}-{taskId}-{runId}-{sessionId}.md` | that run | orchestrator reads |

### Agent-to-Agent Review Loop (PHASE 4.5)

After each agent completes, enter an iterative review loop, not a single-pass verification.

### Loop Flow

```
Agent completes work
    ↓
[1] Mechanical Self-Check: lint, type-check, tests, diff scope
    ↓
[2] Verify: For supported types, run `oma verify agent {agent-type} --workspace {workspace}`
    Unsupported (`db`, `refactor`, `architecture`, `tf-infra`, `docs`) → record SKIP and continue
    ↓ FAIL → Agent receives feedback, fixes, back to [1]
    ↓ PASS
[3] Cross-Review: QA agent reviews the changes
    ↓ FAIL → Agent receives review feedback, fixes, back to [1]
    ↓ PASS
Accept result
```

### Step Details

**[1] Mechanical Self-Check** (formerly "Self-Review"):
Before requesting external review, the implementation agent must:
- Run lint, type-check, and tests in the workspace
- Verify only planned files were modified (diff scope check)
- Fix any mechanical failures (compile errors, test failures)

**Quality judgment is NOT performed in this step.**
Design quality, architecture alignment, and acceptance criteria satisfaction
are evaluated exclusively in [3] Cross-Review by the QA agent.
Reason: Self-evaluation bias causes agents to consistently overrate their own output
(ref: Anthropic harness design research).

**[2] Automated Verify**:
```bash
oma verify agent {agent-type} --workspace {workspace} --json
```
- Run only for `backend`, `frontend`, `mobile`, `qa`, `debug`, and `pm`.
- For `db`, `refactor`, `architecture`, `tf-infra`, and `docs`, record that automated verify is unsupported and continue to QA cross-review after the mechanical checks.
- **PASS (exit 0)**: Proceed to cross-review
- **FAIL (exit 1)**: Feed verify output back to the agent as correction context

**[3] Cross-Review**: Spawn QA agent to review the changes:
- QA agent reads the diff, runs checks, evaluates against acceptance criteria
<!-- oma-docs:ignore-start -->
- If `docs/CODE-REVIEW.md` exists, QA agent uses it as the review checklist
<!-- oma-docs:ignore-end -->
- QA agent outputs: PASS (with optional nits) or FAIL (with specific issues)
- On FAIL: issues are fed back to the implementation agent for fixing

### Loop Limits

| Counter | Max | On Exceeded |
|---------|-----|-------------|
| Self-check + fix cycles | 3 | Escalate to cross-review regardless |
| Cross-review rejections | 2 | Report to user with review history |
| Total loop iterations | 5 | Stop recovery; preserve failed checks and return `partial` or `failed` |

### Review Feedback Format

When feeding review results back to the implementation agent:
```
## Review Feedback (iteration {n}/{max})
**Reviewer**: {self / verify / qa-agent}
**Verdict**: FAIL
**Issues**:
1. {specific issue with file and line reference}
2. {specific issue}
**Fix instruction**: {what to change}
```

This replaces single-pass verification. Most "nitpicking" should happen agent-to-agent.
Resolve relevant automated checks before handoff. Ask for approval only when the next action is outside existing authorization.

### Recovery Budget (after review loop exhaustion)

Maintain one budget per workflow lineage and logical goal: `attempts_used`, `attempts_remaining`, and any
configured cost cap. The original attempt, each ordinary retry, and each
exploration hypothesis consume one attempt. Before starting recovery, reserve
the complete next action; do not exceed the budget or start an incomplete
exploration round.

Use the plan's stable `lineage_id` and task `goal_id` from `references/_shared/runtime/result-contract.md`. New task/run/session IDs do not reset that budget. Freeze the full JSON plan at first dispatch; reject recursive planning/review tasks and post-dispatch plan revisions. A contract change requires an explicitly separated new session and lineage.

Classify failures before retrying: `PRODUCT_FAILURE` follows the remaining product recovery budget; `WORKFLOW_EVIDENCE_FAILURE` means current product checks passed but completion claims or bindings failed. Automatic resume stops evidence-only replay. Allow at most one metadata-only repair under the existing task and frozen plan, consuming the same budget, then stop with a partial handoff if unresolved. Do not create PM tasks, rerun product planning, or import another workflow's plan-review loop for evidence failures.

- First remaining attempt: re-spawn with review history.
- Later attempts: choose either one different retry or a 2–3 hypothesis round
  only if enough attempts and cost remain.
- On cap exhaustion, preserve all checks, review findings, and unresolved work.
  The task is `partial` or `failed`, never `completed`.

### Session evidence

For material corrections or review findings, retain the cause, impact, and evidence in existing task artifacts. Use `references/_shared/core/session-metrics.md` when a retrospective or separate session summary is useful. Do not score clarification questions or require an RCA based on counters. Resolve the affected work and ask only for a material missing decision.

## References
- Parallel worker collaboration: `references/_shared/core/collaboration-policy.md` (before assigning parallel work or coordinating peer issues, ownership handoffs, and result collection)
- Prompt template: `resources/subagent-prompt-template.md`
- Memory schema: `resources/memory-schema.md`
- Scripts: `scripts/spawn-agent.sh`, `scripts/parallel-run.sh`, `scripts/verify.sh`
- Task templates: `templates/`
- Skill-to-agent mapping: `references/_shared/core/skill-routing.md`
- Verification: `scripts/verify.sh <agent-type>`
- Session metrics: `references/_shared/core/session-metrics.md`
- API contract template (SSOT): `references/_shared/core/api-contracts/template.md`; read generated contracts from `.agents/results/api-contracts/` (run artifact) or `docs/plans/contracts/` (durable spec)
- Context loading: `references/_shared/core/context-loading.md`
- Task decomposition: `references/_shared/core/difficulty-guide.md` (unresolved scope or dependencies)
- Clarification protocol: `references/_shared/core/clarification-protocol.md`
- Context budget: `references/_shared/core/context-budget.md`
- Code intelligence: `references/_shared/core/code-intelligence.md`
- Runtime lessons: `references/_shared/core/lessons-learned.md` (recurring failure or requested retrospective)

© First Fluke · MIT · first-fluke/oh-my-agent

Похожие скиллы

Все скиллы по теме «Настройка агента: память, контекст, субагенты» →

Сначала — oma-orchestration от других авторов.

oma-orchestration first-fluke Скилл oma-orchestration для Claude Code распределяет задачи между специализированными субагентами и контролирует их работу. Управляет параллельным выполнением, проверками QA и повторными попытками при сбоях. CX Codex +1 ★ 1 472звёзд репо Swarm Orchestration ruvnet Скилл Swarm Orchestration для Claude Code управляет роями агентов с параллельным выполнением задач, динамической топологией и балансировкой нагрузки. Координирует специалистов разного профиля. CX Codex +1 2 100установок orchestration stablyai Скилл orchestration для Claude Code запускает задачи в отдельном воркере Orca и возвращает результаты. CX Codex +1 359 600установок paperclip-ai-orchestration reason-machines Скилл paperclip-ai-orchestration обучает ассистента управлять платформой Paperclip: разворачивать структуру из ИИ-агентов, ставить им цели и контролировать лимиты расходов. Помогает координировать задачи по расписанию. CX Codex +1 1 500установок agent-orchestration-advisor deanpeters Скилл agent-orchestration-advisor для Claude Code помогает спроектировать мультиагентный воркфлоу: делит сложную задачу между специализированными агентами, задавая границы и точки передачи управления. CX Codex +1 1 400установок agent-orchestration OrchestKit Скилл agent-orchestration для Claude Code описывает циклы работы ИИ-агентов и координацию нескольких агентов. Включается при проектировании автономных циклов, многошаговых процессов и выборе фреймворка. CX Codex +1 1 400установок edict-multi-agent-orchestration reason-machines Скилл edict-multi-agent-orchestration для Claude Code разворачивает оркестрацию 12 агентов по исторической модели Sansheng Liubu с React-канбаном и обязательным ревью. Распределяет задачи между разными LLM. CX Codex +1 1 400установок

Из того же набора69

Весь набор →
oma-scholar Скилл oma-scholar ищет научные публикации, разбирает claims и evidence, создаёт и проверяет sidecar-файлы .knows.yaml. Работает в Claude Code и Codex. CX Codex +1 ★ 1 472звёзд репо oversized-skill Скилл oversized-skill для Claude Code проверяет обработку тела, превышающего рекомендованные 500 строк. CX Codex +1 ★ 1 472звёзд репо oma-security Скилл oma-security запускает аудит безопасности исходного кода, пакетов скиллов и компонентов MCP. Включается при проверке репозитория перед релизом или настройке CI-гейтов. CX Codex +1 ★ 1 472звёзд репо oma-voice Скилл oma-voice генерирует речь, расшифровывает аудио и обрабатывает готовые файлы. Скилл включается для озвучки текста, транскрипции или подготовки аудио с заданными параметрами. CX Codex +1 ★ 1 472звёзд репо oma-observability Скилл oma-observability маршрутизирует задачи наблюдаемости, трейсинга и сигналов MELT+P между инструментами, помогает настроить OpenTelemetry и расследовать инциденты. CX Codex +1 ★ 1 472звёзд репо oma-translator Скилл oma-translator переводит и проверяет UI-тексты, документацию и маркетинговые материалы с учётом контекста проекта. Помогает сохранить тон, терминологию и структуру исходника. CX Codex +1 ★ 1 472звёзд репо oma-research Плагин oma-research для поиска научной литературы, исследования рынка, извлечения данных из документов и подготовки академических текстов прямо в Claude Code. CX Codex ★ 1 472звёзд репо oma-security Плагин oma-security выполняет сканирование безопасности, анализирует исходный код и готовит проверенные исправления уязвимостей в Claude Code и Codex. CX Codex ★ 1 472звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой