Skip to main content
skill CX Codex

oma-coordination — Claude Code skill for agent handoffs

The oma-coordination skill guides manual coordination across specialist agents on multi-domain projects. It covers task planning, progress checks, contract alignment, and a final QA review.

MIT ★ 1,472 updated 2026-11-05

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Open on GitHub

What oma-coordination does

The workflow moves a complex task through preparation, priority-based agent dispatch, progress monitoring, and QA. It helps divide work across PM, frontend, backend, mobile, and QA roles, align API and data contracts, then gather results and coordinate fixes.

Independent tasks at the same priority can run in parallel with separate workspaces. The listed tools include oma agent spawn and progress and result files. Reuse a current plan; if contracts diverge, pause dependent frontend or mobile work until the API is reconciled. The skill is for multi-domain tasks: simple work goes to one specialist, while automated execution goes to an orchestrator.

What it helps with

  • split a complex feature across specialist agents
  • dispatch independent tasks of equal priority in parallel
  • align an API contract before dependent frontend work
  • track agent progress and collect results
  • send blocking QA defects back to the responsible agent

Example prompts for the agent

  • Coordinate this feature across backend and frontend, align the API contract, and finish with QA.
  • Break this mobile project into PM, mobile, and QA tasks, then launch independent work in parallel.
  • Check agent progress, find contract conflicts, and route any blocking defect to its owner.

How to install oma-coordination

1Plugin marketplace

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

This installs the whole oma plugin with all its skills

2Skills CLI (Vercel)

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

3Manually: put the files in place

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

Copy the whole skill folder; for one project use .claude/skills/oma-coordination/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about oma-coordination

How do I install oma-coordination in Claude Code?

Run these commands in order: /plugin marketplace add first-fluke/oh-my-agent, then /plugin install oma@oh-my-agent.

What does oma-coordination do?

It guides manual work across multiple agents: task allocation, progress monitoring, contract alignment, and a final QA review.

What does oma-coordination need to work?

The task must span multiple domains, and a current plan must define task owners, acceptance checks, dependencies, and priority tiers. CLI dispatch uses oma agent spawn.

Source text

SKILL.md · MIT
---
name: oma-coordination
description: Coordinate assigned specialist tasks and handoffs manually. Use
  when supervising a multi-agent project step by step.
---

# Multi-Agent Workflow Guide

## Scheduling

### Goal
Guide manual multi-agent coordination for complex work that spans PM, frontend, backend, mobile, and QA responsibilities.

### Intent signature
- User wants step-by-step coordination, manual agent spawning, or multi-domain work planning without full automation.
- Task spans multiple specialist agents and requires contract alignment.

### When to use

- Complex feature spanning multiple domains (full-stack, mobile)
- Coordination needed between frontend, backend, mobile, and QA
- User wants step-by-step guidance for multi-agent coordination

### When NOT to use

- Simple single-domain task -> use the specific agent directly
- User wants automated execution -> use orchestrator
- Quick bug fixes or minor changes

### Expected inputs
- Complex feature or project goal
- Required domains and priority tiers
- Workspace/session constraints and API/data contract needs

### Expected outputs
- Manual coordination sequence
- PM task decomposition, agent spawn order, monitoring guidance, and QA review step
- API/data contract alignment checkpoints

### Dependencies
- PM, frontend, backend, mobile, QA, and orchestrator skills
- CLI `oma agent spawn` and progress/result memory conventions

### Control-flow features
- Branches by task complexity, priority tiers, dependency ordering, and whether automation is desired
- Spawns independent same-priority tasks in parallel when appropriate
- Monitors progress files and contract alignment

## Structural Flow

### Entry
1. Confirm the task is complex enough for multi-agent coordination.
2. Reuse a current plan and handoff state; use PM when task decomposition or contract changes are needed.
3. Identify priority tiers and shared contracts.
4. Apply the shared collaboration policy before assigning parallel work or coordinating ownership handoffs and result collection.

### Scenes
1. **PREPARE**: Define session, domains, and task decomposition needs.
2. **ACT**: Spawn agents by priority with separate workspaces.
3. **VERIFY**: Monitor progress and API/data contract alignment.
4. **FINALIZE**: Run QA review and coordinate remediation.

### Transitions
- If task is simple, route to one specialist.
- If user wants automated execution, use orchestrator.
- If QA reports a blocking defect or required verification gap, route the affected work to the responsible agent within the existing recovery budget.

### Failure and recovery
- If contracts diverge, pause downstream frontend/mobile work until backend/API contract is reconciled.
- If agent workspaces conflict, split ownership boundaries.
- If progress stalls, inspect progress files and reissue focused instructions.

### Exit
- Success: specialist outputs are coordinated and QA-reviewed.
- Partial success: blocked agents, contract conflicts, or QA failures are explicit.

## Logical Operations

### Actions
| Action | SSL primitive | Evidence |
|--------|---------------|----------|
| Read request and domains | `READ` | User prompt and project context |
| Select agent plan | `SELECT` | PM decomposition and priority tiers |
| Spawn agents | `CALL_TOOL` | `oma agent spawn` |
| Monitor progress | `READ` | injected task/run-scoped progress, claims, and receipts |
| Validate contracts | `VALIDATE` | API/data model alignment |
| Notify coordination status | `NOTIFY` | Final coordination summary |

### Tools and instruments
- `oma agent spawn`, PM/frontend/backend/mobile/QA agents
- Memory/progress/result files
- Configured code intelligence, with native fallback per `references/_shared/core/code-intelligence.md`

### Canonical command path
```bash
# If planning is required, dispatch the declared PM task first; otherwise reuse the current plan.
oma agent spawn pm <pm-prompt-file> <session-id> --task-id <plan.pm_task.id> -w ./pm
oma agent spawn backend <backend-prompt-file> <session-id> --task-id <plan.backend_task.id> -w ./backend &
oma agent spawn frontend <frontend-prompt-file> <session-id> --task-id <plan.frontend_task.id> -w ./frontend &
wait
```

When native runtime dispatch is available (per-agent target vendor equals the current runtime vendor), prefer the runtime's native subagent path and use `oma agent spawn` as the cross-vendor fallback — same resolution rule as oma-orchestration.

Useful `agent spawn` options: `--vendor <vendor>` (CLI vendor override), `--isolation worktree` (git worktree per spawn, prevents file conflicts), `--read-only` (non-destructive tools only, e.g. for review/QA passes).

### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `LOCAL_FS` | Progress/result files and workspaces |
| `PROCESS` | Agent spawn commands |
| `MEMORY` | Session state and task board |
| `CODEBASE` | Shared contracts and implementation areas |

### Preconditions
- Task requires multiple domains.
- A current plan identifies task ownership, acceptance checks, dependencies, and priority tiers.

### Effects and side effects
- Spawns or guides multiple agents.
- Coordinates workspace ownership and QA feedback.

### Guardrails

1. Reuse a valid plan; call PM only when decomposition or contract changes are required
2. Spawn independent tasks in parallel (same priority tier)
3. Reuse or update contracts for changed API boundaries before dependent frontend/mobile work
4. QA review is always the final step
5. Assign separate workspaces to avoid file conflicts (or use `--isolation worktree` for a git worktree per spawn)
6. Follow `references/_shared/core/code-intelligence.md`: discover configured tools, do not auto-install or track, and use native search only for paths outside this project or ignored paths when unavailable or timed out
7. Resume from the current handoff state and execute applicable steps in dependency order; record why a branch is not applicable

### Workflow

#### Step 1: Plan with PM Agent

Reuse an existing valid plan. Otherwise, PM analyzes requirements and creates the task breakdown, acceptance checks, contracts, and priorities. Preserve injected session/task/run IDs; do not regenerate a plan already frozen by dispatch.

#### Step 2: Spawn Agents by Priority

Resolve the dispatch path per agent, then spawn:

1. Resolve the per-agent target vendor from oma-config.yaml (`agents:` override, else `model_preset`)
2. If the target vendor equals the current runtime vendor and a native subagent path exists, use native dispatch
3. Otherwise use `oma agent spawn` for that agent
4. Spawn all same-priority tasks in parallel using background processes

```bash
# Example: spawn backend and frontend in parallel
oma agent spawn backend backend-prompt.md session-id --task-id plan.backend_task.id -w ./backend &
oma agent spawn frontend frontend-prompt.md session-id --task-id plan.frontend_task.id -w ./frontend &
wait
```

#### Step 3: Monitor & Coordinate

- Apply `references/_shared/core/execution-policy.md` for the execution deadline, resource ownership, and cancellation. Prefer host completion notifications; otherwise use one coordinator with bounded polling backoff. Cancellation or deadline exhaustion stops new dispatch, review, and recovery; use bounded termination checks and report survivors or unsupported cancellation in the handoff.
- Read injected run artifacts and receipts. Human-readable progress/results use `{memoryConfig.basePath}/progress-{agentId}-{taskId}-{runId}-{sessionId}.md` and the corresponding `result-` name; see `references/_shared/runtime/memory-protocol.md`. Keep the structured claim path unchanged.
- Verify API contracts align between agents
- Ensure shared data models are consistent

#### Step 4: QA Review

Review the coordinated deliverables with QA. Resolve blocking defects and required verification gaps through the responsible agents; rerun affected checks before finalizing.

### Automated Alternative

For fully automated execution without manual spawning, use the **orchestrator** skill instead.

## References
- Parallel worker collaboration: `references/_shared/core/collaboration-policy.md` (before assigning parallel work or coordinating peer issues, ownership handoffs, and result collection)

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set69

The whole set →
oma-hwp oma-hwp converts Korean HWP, HWPX, and HWPML documents into Markdown or JSON for LLM prompts and retrieval pipelines. CX Codex +1 ★ 1,472repo stars oma-search The oma-search skill picks a search channel for docs, web research, code, or local project files, then labels external sources by domain trust. Use it when the right place to search is unclear. CX Codex +1 ★ 1,472repo stars oma-image oma-image routes image generation requests across Codex, Pollinations and Gemini, and turns a reference picture into a new variation matching its style or layout. CX Codex +1 ★ 1,472repo stars oma-architecture oma-architecture is a Claude Code skill that helps design module and service boundaries, compare alternatives, and document architecture decisions as ADRs. CX Codex +1 ★ 1,472repo stars oma-hwp oma-hwp turns Korean HWP, HWPX and HWPML documents into Markdown via kordoc. Extracts text, tables, lists, images and footnotes. CX Codex +1 ★ 1,472repo stars oma-pdf oma-pdf converts PDF documents into structured Markdown while preserving tables, headings, and lists. Runs when preparing files for LLM context or RAG pipelines. CX Codex +1 ★ 1,472repo stars oma-market oma-market runs community-signal research on customer pain, trends, and competitors, then saves a market brief for the requested topic. CX Codex +1 ★ 1,472repo stars oma-video Builds videos through the OMA video CLI or works on an existing clip: pulling frames, cutting silence, assembling dubbed audio. CX Codex +1 ★ 1,472repo stars

Project sponsors

Companies that keep this analytics open