workflow
/workflow
Deterministic multi-agent orchestration powered by the GitHub Copilot CLI. Use when asked to "run a workflow", "orchestrate", "fan out agents", "run agents in parallel", "spawn subagents", or to decompose a job across many independent agents — audits, code review, sweeps, research, migrations. Instead of working turn-by-turn, write a small JavaScript orchestrator on the fly; each step runs as a headless `copilot -p` child process. Reach for this when a job needs breadth, independent verification, or scale a single context can't hold.
- Author
- alexanderop ↗
- Repository
- workflow ↗
- Licence
- MIT
- Last repository change
- 28.05.2026
Assessment and security
- Files in this package
- 8
- Scripts
- 3
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 28.05.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 3 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: references/route-auth-audit.mjs, tools/smoke.mjs, tools/wf-runtime.mjs
What it does and when to use it
Deterministic multi-agent orchestration powered by the GitHub Copilot CLI. Use when asked to "run a workflow", "orchestrate", "fan out agents", "run agents in parallel", "spawn subagents", or to decompose a job across many independent agents — audits, code review, sweeps, research, migrations. Instead of working turn-by-turn, write a small JavaScript orchestrator on the fly; each step runs as a headless `copilot -p` child process. Reach for this when a job needs breadth, independent verification, or scale a single context can't hold.
Triggers from the description
Original author description
Deterministic multi-agent orchestration powered by the GitHub Copilot CLI. Use when asked to "run a workflow", "orchestrate", "fan out agents", "run agents in parallel", "spawn subagents", or to decompose a job across many independent agents — audits, code review, sweeps, research, migrations. Instead of working turn-by-turn, write a small JavaScript orchestrator on the fly; each step runs as a headless `copilot -p` child process. Reach for this when a job needs breadth, independent verification, or scale a single context can't hold.
How it works
- Prerequisites
- How to run a workflow
- The primitives
- Rules (do not skip)
- Confidence patterns (compose as needed)
- Resume
- Reference
SKILL.md preview
---
name: workflow
description: >
Deterministic multi-agent orchestration powered by the GitHub Copilot CLI. Use when asked to
"run a workflow", "orchestrate", "fan out agents", "run agents in parallel", "spawn subagents",
or to decompose a job across many independent agents — audits, code review, sweeps, research,
migrations. Instead of working turn-by-turn, write a small JavaScript orchestrator on the fly;
each step runs as a headless `copilot -p` child process. Reach for this when a job needs
breadth, independent verification, or scale a single context can't hold.
metadata:
version: 0.1.0
---
# Workflow: deterministic orchestration with Copilot
You hold the control flow (loops, fan-out, branching) in plain JavaScript; each individual step
is delegated to a fresh headless Copilot agent. The orchestration is deterministic — only the
work inside each `agent()` call is model-powered.
## Prerequisites
- GitHub Copilot CLI installed and logged in (`copilot` once interactively, or `copilot login`).
- Node ≥ 18.
## How to run a workflow
When this skill triggers, do **not** do the task turn-by-turn. Instead:
1. **Write an orchestrator script** (e.g. `workflow.mjs` in the project root), importing the
runtime that ships with this skill:
```js
import { agent, parallel, pipeline, phase, log } from './.claude/skills/workflow/tools/wf-runtime.mjs'
```
Adjust the path to wherever this skill is installed (e.g. `.github/skills/workflow/tools/…`
or `~/.copilot/skills/workflow/tools/…`). If unsure, locate `wf-runtime.mjs` first.
2. **Follow the shape: fan out → reduce → synthesize.**
```js
phase('Find')
const found = await parallel(items.map((x) => () => agent(promptFor(x), { schema: ITEM, label: x.id })))
const clean = found.filter(Boolean).flatMap((r) => r.items) // reduce in plain JS — no agent
phase('Synthesize')
const report = await agent(`Write a report from:\n${JSON.stringify(clean)}`)
console.log(report)
```
3. **Run it and report the result:**
```bash
node workflow.mjs
```
Progress prints to stderr; the final `console.log` is the answer to relay to the user.
## The primitives
- `agent(prompt, { schema?, model?, label?, retries? })` — one headless Copilot agent.
With `schema` (a JSON Schema) it returns parsed JSON and retries on invalid output;
without, it returns raw text. Returns `null` on failure — `.filter(Boolean)`.
- `parallel(thunks)` — run concurrently. **Barrier**: awaits all. Failures become `null`.
- `pipeline(items, ...stages)` — stream each item through stages, **no barrier**. Each stage
gets `(prev, originalItem, index)`.
- `phase(title)` / `log(msg)` — progress lines on stderr.
## Rules (do not skip)
- **Default to `pipeline()`.** Only use a `parallel()` barrier between stages when a stage
genuinely needs ALL prior results at once (dedupe/rank across everything, early-exit on total
count, "compare against the other findings").
- **Each agent is stateless** — a separate process with no memory of the others. Put every bit
of context it needs into its prompt.
- **Never remove the recursion guard.** The runtime launches children with
`--no-custom-instructions` so they don't re-load this skill and spawn more workflows.
- **Reduce with plain JS**, not agents — flatten, dedupe, filter, sort are just code.
- **Quota costs are real**: every agent is a full Copilot invocation. Scope `--allow-all-tools`
down for untrusted tasks, and route cheap stages with `{ model: '<smaller-model>' }`.
## Confidence patterns (compose as needed)
- **Adversarial verify**: for each finding, spawn N skeptics prompted to *refute* it; keep it
only if a majority survive.
- **Perspective-diverse verify**: give each verifier a different lens (correctness, security,
performance, reproducibility) rather than N identical ones.
- **Loop-until-dry**: for unknown-size discovery, keep spawning finders until K consecutive
rounds surface nothing new. Dedupe against everything *seen*, not just confirmed results.
## Resume
Set `WF_JOURNAL=.wf/run.json` before running to cache every `agent()` step. Re-running with the
same journal replays cached results instantly and only re-runs new/changed steps.
## Reference
See `references/route-auth-audit.mjs` for a complete fan-out → adversarial-verify → report
workflow. `tools/smoke.mjs` is a 4-agent end-to-end check that the runtime can drive Copilot.
Files in this package (8)
- .gitignore 1 KB
- LICENSE 1 KB
- README.md 6 KB
- package.json 1 KB
- skill.md 4 KB
- references/route-auth-audit.mjs 3 KB
- tools/smoke.mjs 1 KB
- tools/wf-runtime.mjs 7 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · alexanderop/workflow | 98 | MIT |
| jeremylongshore/tons-of-skills-marketplace | 100 | MIT |
| SimHacker/moollm | 100 | MIT |
| mlophez/polix-ai | 100 | Apache-2.0 |
| stellarie/minimal-agent-kit | 100 | MIT |
| waynesutton/builder-skills | 100 | Apache-2.0 |
| claude-world/director-mode-lite | 100 | MIT |
| DawitLemmaBalcha/agent-workflow | 100 | MIT |
| zhinkgit/embeddedskills | 100 | MIT |
Database snapshot: 13.11.2026 · package version 0f62e22aa5a0 (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
- 100codex-workflow
Run deterministic multi-step agent workflows in Codex - fan-out, parallel, schema-validated structured output - via the codex-workflow MCP orchestrator (run_workflow), with native in-chat fallbacks. Use when you want Claude-Code-Workflow-style orchestration in Codex: 'run a… - 100gh-copilot-cli
Use when working with GitHub Copilot CLI (`copilot`) — headless and interactive modes, permission flags, AGENTS.md and `.github/copilot-instructions.md`, MCP servers, custom agents, plugins, OAuth device-flow auth, and the bridge to VS Code Copilot Chat. Covers… - 84add-other-agents
Add child agents, connected agents, or other multi-agent patterns to a Copilot Studio agent. Use when the user asks to create a sub-agent, child agent, connected agent, or call another agent. - 100dispatching-subagents
Chooses how to launch subagents from Claude Code (the Agent tool, a Workflow script, or headless claude -p children) and runs a headless fan-out from one background command. Use for "fan this out to 50 agents", "run these tasks in parallel", "launch subagents for each file",… - 100neo-sub-agent
Use this skill when the user asks to design, create, review, or convert sub-agents, custom agents, worker/reviewer/planner agents, background agents, or multi-agent workflows for Antigravity CLI, Codex, Claude Code, GitHub Copilot CLI, or neutral agent blueprints. - 100dispatching-subagents
Chooses how to launch subagents from Claude Code (the Agent tool, a Workflow script, or headless claude -p children) and runs a headless fan-out from one background command. Use for "fan this out to 50 agents", "run these tasks in parallel", "launch subagents for each file",…