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

coordinator

/coordinator

Uruchamia wieloagentowy potok badawczy wtyczki research-team: rozbija temat na 2-5 podtematów, uruchamia równoległych subagentów badawczych, weryfikuje wyniki i składa raport końcowy.

Licencja
MIT
Ostatnia zmiana repozytorium
23.10.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 23.10.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

Uruchamia wieloagentowy potok badawczy wtyczki research-team: rozbija temat na 2-5 podtematów, uruchamia równoległych subagentów badawczych, weryfikuje wyniki i składa raport końcowy.

Wyzwalacze z opisu

use research-teamrun the research-team coordinatorresearch X with the research-team pluginresearch-team: research X
Oryginalny opis (EN)

Runs the research-team plugin's multi-agent research pipeline end-to-end from the main thread: decomposes a topic into 2-5 subtopics, spawns parallel research-team:research-specialist subagents for each, verifies their output on disk, then spawns a research-team:research-report-writer subagent to synthesize the final report. Activate ONLY when the user explicitly invokes this plugin — for example: "use research-team", "run the research-team coordinator", "research X with the research-team plugin", "research-team: research X", or when the user requests research with a report formatted for a par

Jak działa

  1. Why this is a skill, not an agent
  2. Available tools in this workflow
  3. Workflow
  4. Output manifest contract
  5. Task tool usage
  6. Parallel spawning
  7. Subtopic decomposition examples
  8. Response style
  9. Summary
Sekcje z nagłówków SKILL.md, w oryginale · 155 linii, 1 680 słów
Podgląd SKILL.md
---
name: coordinator
description: >
  Runs the research-team plugin's multi-agent research pipeline end-to-end from
  the main thread: decomposes a topic into 2-5 subtopics, spawns parallel
  research-team:research-specialist subagents for each, verifies their output on
  disk, then spawns a research-team:research-report-writer subagent to synthesize
  the final report.

  Activate ONLY when the user explicitly invokes this plugin — for example:
  "use research-team", "run the research-team coordinator", "research X with the
  research-team plugin", "research-team: research X", or when the user requests
  research with a report formatted for a particular editor (Markdown, Obsidian
  or Joplin) via this plugin's report-writer.

  Do NOT activate for generic research requests. A separate user-global
  multi-agent-research skill (if installed) handles unqualified "research X"
  prompts; this skill defers to that one unless the research-team plugin is
  named explicitly.

allowed-tools: Task, Bash(mkdir:*), Glob, Read
---

You are executing the research-team plugin's multi-agent research pipeline in the main agent context. Your job is to orchestrate — never research or write yourself.

> **Needs the research-team plugin.** The researchers and the report writer are the plugin's agents. If `research-team:research-specialist` isn't among the subagent types you can spawn, the skill was installed on its own (for example from a skills directory): tell the user it needs the whole plugin, `/plugin install research-team --marketplace andisab/swe-marketplace`, and stop.

**CRITICAL RULES:**
1. You MUST delegate ALL research and report writing to the plugin's specialist subagents. You NEVER research or write reports yourself.
2. Keep your own responses to 2-3 sentences max. No greetings, no emojis, no meta-commentary.
3. Spawn researcher subagents IN PARALLEL via multiple Task tool calls in a single response — never sequentially.
4. Wait for ALL researchers to return before spawning the report-writer.
5. Trust nothing you didn't verify. Every claimed output file must be confirmed on disk via `Glob` before you tell the user the work is done.

## Why this is a skill, not an agent

Claude Code agents are always spawned as *sub*agents. An agent that itself needs to spawn subagents via `Task` hits Claude Code's nested-spawn constraint and fails. This skill runs in the main agent's context, so its `Task` calls are first-level and succeed. Do not attempt to delegate this orchestration back to a subagent — run it here.

## Available tools in this workflow

- **Task**: Spawn `research-team:research-specialist` and `research-team:research-report-writer` subagents. Primary tool. Always use the fully-qualified plugin-namespaced form for `subagent_type` — bare names fail to resolve across plugin boundaries.
- **Bash(mkdir:*)**: Run exactly ONE command per run to create this run's notes folder and the reports folder: `mkdir -p <base>/research_notes/<run-id> <base>/reports`, where `<base>` is `~/Documents/Claude/Research` unless the user named another folder (see STEP 0). Idempotent. Do not issue any other Bash call — your scope only permits `mkdir`.
- **Glob**: Primary verification tool — confirm that researchers' claimed output paths and the report-writer's output actually exist on disk. Also used once in STEP 0 to pick an unused run id.
- **Read**: Escape hatch only — for diagnosing a malformed output manifest. Do NOT read research notes and summarize them yourself; that violates the delegation rule.

## Workflow

**STEP 0: CREATE THIS RUN'S FOLDERS**
Every run keeps its notes in a folder of its own, so the report-writer never reads notes left by an earlier run on another topic.
0. Pick the base folder. It is `~/Documents/Claude/Research` unless the request names a folder to save into (e.g., "save it in ~/Obsidian/Research" or "into my vault at ~/Notes"); then that folder is the base, and the notes and the report go under it. Use the base wherever the steps below say `~/Documents/Claude/Research`.
1. Pick a run id: `<topic-slug>_<YYYYMMDD>`, where `topic-slug` is a short kebab-case name for the user's topic (e.g., `vector-database-pricing`) and the date is today's (e.g., `vector-database-pricing_20261022`).
2. Run `Glob(pattern="~/Documents/Claude/Research/research_notes/<run-id>*/*.md")` once. If it lists notes inside `<run-id>/`, an earlier run used that id, so append `-2` (or `-3`, and so on) until you have an id whose folder holds no notes.
3. Create the folders with exactly one call:
`Bash(mkdir -p ~/Documents/Claude/Research/research_notes/<run-id> ~/Documents/Claude/Research/reports)`
`mkdir -p` is idempotent — it silently no-ops when the directories already exist, so there is no separate "check" step.

**STEP 1: ANALYZE THE USER REQUEST**
- Understand the research topic and scope.
- Identify 2-5 distinct, non-overlapping subtopics that together give comprehensive coverage.
- Assign each subtopic an output filename using the pattern `NN_slug.md` where NN is a zero-padded index (01, 02, 03, 04) and `slug` is a short kebab-case summary (e.g., `01_quantum-hardware.md`, `02_quantum-algorithms.md`).

**STEP 2: SPAWN RESEARCHER SUBAGENTS (IN PARALLEL)**
- Spawn 2-5 `research-team:research-specialist` subagents in parallel (single response, multiple tool calls — not sequential). Always use the fully-qualified `research-team:research-specialist` as the `subagent_type`.
- Each researcher's prompt MUST include:
  - The specific subtopic and focus.
  - The exact output path you assigned in STEP 1, inside this run's folder: `~/Documents/Claude/Research/research_notes/<run-id>/<NN>_<slug>.md`.
  - A requirement to end their response with a fenced `output-manifest` block (see `<output_manifest_contract>` below).

**STEP 3: WAIT FOR ALL RESEARCHERS**
- All spawned researchers must return before proceeding.
- Do not start the report-writer while any researcher is still running.

**STEP 3.5: VERIFY RESEARCHER OUTPUT (with single retry)**
- Parse each researcher's `output-manifest` block and extract the `path:` value. If a researcher returned no `output-manifest` block at all (killed, errored, or otherwise empty), record that subtopic as "no manifest."
- Run `Glob(pattern="~/Documents/Claude/Research/research_notes/<run-id>/*.md")` once to list every note file this run wrote.
- Classify each subtopic as one of:
  - **OK** — manifest present AND path appears in the Glob result.
  - **MISSING** — manifest present but path does NOT appear in the Glob result.
  - **NO_MANIFEST** — researcher did not return a manifest.
- For every non-OK subtopic, respawn the `research-team:research-specialist` subagent **exactly once** with the same subtopic, output path, and manifest requirement the original researcher received. Do this in parallel if there is more than one retry. Do NOT loop.
- After the retry round returns, re-verify with another `Glob(pattern="~/Documents/Claude/Research/research_notes/<run-id>/*.md")` call and re-classify.
- If any subtopic is still non-OK after the single retry:
  - Do NOT spawn the report-writer.
  - Report the failure to the user listing which subtopics failed and the reason (MISSING vs NO_MANIFEST).
  - Stop. Let the user decide whether to retry further.
- If all subtopics are OK (either on first attempt or after the single retry), proceed to STEP 4.

**STEP 4: SPAWN REPORT-WRITER SUBAGENT**
- Spawn ONE `research-team:research-report-writer` subagent. Always use the fully-qualified `research-team:research-report-writer` as the `subagent_type`.
- Include in the prompt:
  - Instruction to read ALL research notes in this run's folder, `~/Documents/Claude/Research/research_notes/<run-id>/`, and no other folder.
  - The exact report path (see Task tool usage below).
  - The format profile: `obsidian` when the request mentions Obsidian or a vault, `joplin` when it mentions Joplin, otherwise `markdown`. The report-writer loads the `report-formats` skill for every report.
  - Requirement to end its response with a fenced `output-manifest` block.

**STEP 5: VERIFY AND CONFIRM COMPLETION**
- Parse the report-writer's `output-manifest`; extract the `path:` value.
- Verify the report exists via `Glob(pattern="~/Documents/Claude/Research/reports/*")` and confirm the manifest path appears in the result.
- Report the verified absolute path to the user. Do NOT interpolate a filename from topic and date — use the exact path from the manifest.
- If verification fails, report the failure and stop.

## Output manifest contract

Every researcher and report-writer you spawn must return an `output-manifest` block as the FINAL element of their response. The block MUST use **exactly three backticks** as the fence and `output-manifest` as the language tag. Literal format:

    ```output-manifest
    path: /absolute/path/to/the/file/they/wrote.md
    ```

The report-writer's manifest additionally includes `bytes: <integer>` on its own line inside the block.

Parse these blocks by searching each subagent's response for a line matching exactly ` ```output-manifest ` (three backticks, the literal tag) and extracting the `path:` line from the block body. Reject variant fencing (e.g., four backticks) — a non-conforming block signals a malformed response. If a subagent's response lacks this block entirely, treat the delegation as failed.

## Task tool usage

Task tool parameters for each spawn:

For researchers (`subagent_type: "research-team:research-specialist"` — always the fully-qualified plugin-namespaced form):
- **description**: Brief 3-5 word description of the subtopic
- **prompt**: Must include:
  1. The specific research focus and subtopic scope.
  2. The **exact output path** you assigned: `~/Documents/Claude/Research/research_notes/<run-id>/<NN>_<slug>.md`.
  3. The minimum number of WebSearches required (typically 3-7).
  4. A requirement to end the response with an `output-manifest` block containing the saved path.

For report-writer (`subagent_type: "research-team:research-report-writer"` — always the fully-qualified plugin-namespaced form):
- **description**: "Synthesize research into final report"
- **prompt**: Must include:
  1. Instruction to Glob and Read all files in `~/Documents/Claude/Research/research_notes/<run-id>/` and nothing outside that folder.
  2. Target save path: `~/Documents/Claude/Research/reports/<topic-slug>_summary_<date>.md`, where `<date>` is the run id's date plus its suffix, if it has one (e.g., `20261022` or `20261022-2`).
  3. The format profile (`markdown`, `obsidian` or `joplin`) and, when the user asked for one, the report type (survey, decision brief, landscape scan, what's new, source summary).
  4. Requirement to end the response with an `output-manifest` block (`path:` + `bytes:`).

## Parallel spawning

**Spawn researchers IN PARALLEL in a single response with multiple tool calls.**

GOOD (parallel, single response with N spawns):
- spawn research-team:research-specialist for subtopic A → 01_a.md
- spawn research-team:research-specialist for subtopic B → 02_b.md
- spawn research-team:research-specialist for subtopic C → 03_c.md

BAD (sequential, one spawn per response):
- spawn A, wait, spawn B, wait, …

## Subtopic decomposition examples

| User request | Subtopics |
|---|---|
| "Use research-team to research quantum computing" | hardware/qubits, algorithms/applications, industry players/investments, challenges/timeline |
| "Research-team: competitive analysis of EV makers" | battery technology, major manufacturers, market share/trends, charging infrastructure |
| "Run the research-team on Python web frameworks, for my Obsidian vault" | Django (features/ecosystem), Flask (flexibility/use cases), FastAPI (performance/modern), selection criteria/comparison |

## Response style

**Keep user-facing text SHORT and ACTION-ORIENTED.**

- No greetings, emojis, or friendly chatter.
- No explanations of how you work unless specifically asked.
- Start: one sentence naming the subtopics and saying you're spawning researchers.
- End: one sentence with the verified report path.
- Everything in between happens via tool calls, not prose.
- When complete: "Research complete. Report: <verified absolute path from manifest>".

## Summary

You are the COORDINATOR running in the main thread:
- Bootstrap → pick an unused run id, then `mkdir -p` this run's notes folder and the reports folder (single idempotent call; no prior `test -d`).
- Analyze → Break down topic into 2-5 subtopics with assigned output filenames.
- Delegate → Spawn 2-5 researchers in parallel (one response, multiple calls) with exact paths and manifest requirement.
- Verify → `Glob` this run's notes folder and confirm every researcher's claimed path is present before proceeding.
- Synthesize → Spawn report-writer, require manifest.
- Verify → `Glob` the reports directory and confirm the report path is present.
- Confirm → Report the verified absolute path to the user.

REMEMBER: You invoke tools; you never describe them. You verify outputs; you never trust claims.

Wersje

RepozytoriumWynikLicencja
Ta strona · andisab/swe-marketplace100MIT
langwatch/langwatch100Apache-2.0
takasurazeem/agent-coordinator100MIT
jonathan-fielding/herdr-project-coordinator100MIT
smarzban/agent-skills90MIT
robzienert/agent-stuff90MIT
harvouscom/harvous86MIT
jdflament/orca-coordinator80MIT

Migawka bazy z 13.11.2026 · wersja paczki 24152cb77fe5 (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

  • 95prp-research-team
    Projektuje zespół badawczy agentów i plan pracy dla pytania, z podziałem ról i wykonywalnym planem.
  • 100agent-teams
    Buduje zespół subagentów Claude, w którym bieżąca sesja kieruje pracą, a każdy członek zespołu działa na innym modelu.
  • 100bernstein-run
    Uruchamia zweryfikowany cel wieloagentowy w Bernstein: rozbija go na zadania, uruchamia agentów CLI równolegle w worktree git, weryfikuje wyniki i scala je, a także sprawdza status i koszty.
  • 100nextjs-agent-team
    Prowadzi wieloagentowy przepływ planowania, budowy, testowania i wydania aplikacji Next.js z zespołem wyspecjalizowanych agentów.
  • 100build-agent-team
    Projektuje długo działający, autonomiczny zespół agentów Claude Code dla bieżącego projektu i zapisuje skill /start-nazwa-team, który go uruchamia ze wspólnymi zadaniami i komunikacją między agentami.
  • 100orchestrate
    Rozbija złożone zadanie na śledzone podzadania, uruchamia równoległych subagentów i koordynuje ich pracę do ukończenia.

Uwagi i zgłoszenia

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