Skip to content
Skills Library
AI & agents · Planning

multi-agent

/multi-agent

Coordinate authorized independent agent subtasks with explicit scopes, ownership and evidence. Use when delegation, a fleet, parallel agent work or result synthesis is requested or appropriate under host instructions; keep sequential or small work in one agent.

Repository
wrongstack ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Coordinate authorized independent agent subtasks with explicit scopes, ownership and evidence. Use when delegation, a fleet, parallel agent work or result synthesis is requested or appropriate under host instructions; keep sequential or small work in one agent.

Original author description

Coordinate authorized independent agent subtasks with explicit scopes, ownership and evidence. Use when delegation, a fleet, parallel agent work or result synthesis is requested or appropriate under host instructions; keep sequential or small work in one agent.

How it works

  1. Selection card
  2. Overview
  3. Rules
  4. Workflow
  5. Brief template
  6. Review workflow
  7. Before returning
  8. Skills in scope
Original SKILL.md headings · 80 lines, 545 words
SKILL.md preview
---
name: multi-agent
description: "Coordinate authorized independent agent subtasks with explicit scopes, ownership and evidence. Use when delegation, a fleet, parallel agent work or result synthesis is requested or appropriate under host instructions; keep sequential or small work in one agent."
version: 2.1.1
required-capabilities: [filesystem.read]
required-tools: []
optional-capabilities: [verification.run, web.research, filesystem.write, fleet.delegate]
trigger: "delegation, a fleet, parallel agent work or result synthesis is requested or appropriate under host instructions; keep sequential or small work in one agent."
metadata:
  routing-group: workflow
---

# Multi-Agent Coordination

## Selection card
- Task: Plan coordinated work when delegation is authorized.
- Start: Identify the requested artifact, repository owner and acceptance criteria.
- Finish: apply the acceptance checks below; report observed results and unresolved constraints.

## Overview

Parallel agents improve independent attention and elapsed time, at the cost of
handoff and synthesis. Use the host's actual limits and context-sharing rules.
Separate contexts may still share files, build outputs, ports and databases.

## Rules

1. Follow the session's delegation authorization and available tools. A large
   task or this skill's availability alone does not authorize spawning agents.
2. Delegate independent work with exact boundaries and a definition of done.
   Keep decisions requiring the complete context with the coordinator.
3. Assign file/resource ownership before writes. Prefer parallel reading and
   separate edit scopes; serialize shared build, coverage, release and database
   writers unless their isolation is demonstrated.
4. Treat task brief and supplied artifacts as the worker's reliable context;
   inspect what the host actually inherits instead of assuming total amnesia
   or unlimited shared memory.
5. Validate every worker's completion status and evidence. Partial, cancelled
   and budget-exhausted outputs are coverage gaps, not successful checks.
6. Synthesize one outcome with deduplicated findings and material cross-scope
   effects; do not concatenate reports or fabricate unanimity.

## Workflow

1. Decide whether the work is independent enough to repay briefing and merge
   costs. Use one agent when a subtask depends on exploratory results.
2. Brief each worker: task, exact paths, raw inputs, constraints, write ownership,
   checks, return format, budget and stopping conditions.
3. Dispatch within host concurrency/resource limits. Keep useful coordinator
   work running while workers execute.
4. Handle dependency handoffs explicitly with versioned artifacts or paths.
   A worker should reread a shared file before editing when another writer changed it.
5. Check actual statuses, commands and changed files. Read relevant code for
   consequential findings and inspect integration conflicts.
6. Retry a failed worker only when a changed scope/input addresses the cause.
   Bound retries; respect cancellation and report remaining gaps.
7. Run the integration checks against the combined final state with one owner.

## Brief template

~~~
Task: <one concrete objective>
Scope and ownership: <paths; read-only or permitted writes>
Inputs and constraints: <artifacts; relevant host rules>
Done when: <observable result>
Verify with: <commands and expected behavior>
Return: <outcome, files/lines, commands/results, limitations>
Stop/escalate when: <dependency or scope decision>
~~~

## Review workflow

For the host's collab_debug path, load
[the complete instructions](references/collab-debug.md) before dispatch.
That workflow's actual tool contract governs roles and result handling.

## Before returning

- [ ] Delegation authorization and host concurrency limits were verified and respected.
- [ ] File and shared-resource write ownership was partitioned or serialized before dispatch.
- [ ] Every worker completion status (including partial, cancelled, or timed-out runs) and evidence was reconciled.
- [ ] Combined final state passed integration checks under a single owner, with any coverage gaps or conflicting observations reported.

## Skills in scope

- `code-review` — independent review of worker-produced diffs and cross-module contract changes
- `evidence-audit` — scoped proof-driven verification rounds across isolated subsystems
- `refactor-planner` — dependency graph ordering and file-ownership partitioning before parallel execution
- `audit-log` — inspection of worker session trajectories, tool calls, and failure traces
- `output-standards` — deduplicated synthesis of multi-worker results into a unified report
Files in this package (3)
  • SKILL.md 5 KB
  • SKILL.save.md 2 KB
  • references/collab-debug.md 4 KB

Versions

RepositoryScoreLicence
This page · wrongstack/wrongstack90MIT
shibing624/agentica100Apache-2.0
masihmoafi/skills100MIT
fengshao1227/ccg-workflow95MIT
GuYu-001/ccg-ros2-workflow95MIT
samchon/typia90MIT
systemfsoftware/systemfsoftware90Apache-2.0

Database snapshot: 13.11.2026 · package version c5288d1160fc (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 85agent-orchestrator
    Plan and coordinate authorized multi-agent work with explicit dependencies, resource ownership, acceptance checks and integration. Use when the user requests delegation, or an authorized engineering workflow identifies independent tasks worth parallel execution and host policy…
  • 100orchestrate
    This skill should be used when the user asks to 'orchestrate a task', 'break down work into parallel agents', 'coordinate subtasks', 'run agents in parallel', or mentions 'multi-agent'. Decomposes complex tasks into tracked subtasks, dispatches parallel subagents, and coordinates until completion.
  • 90multi-agent-collaboration
    Coordinate multiple agents on implementation or research with isolated ownership, reproducible handoffs, independent checks, and evidence-based conflict resolution. Use when parallel or peer-agent work is requested or already in progress.
  • 100native-agent-swarms
    Coordinate small teams of specialized Codex agents with bounded parallelism, explicit ownership, native messaging, and evidence-based synthesis. Use when two or more independent investigations, reviews, or implementation streams can run concurrently without sharing writable…
  • 90parallel-launch
    Use when work splits into independent sub-tasks or cross-domain research. Not for durable scope ownership with per-scope review: use partition-scopes-to-subagents.
  • 90delegation-design
    Break a bounded engineering request into independent, reviewable work units for a human team or an already available agent system. Use when parallel work is requested and the environment supports it.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.