Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Orchestration

    1

    Turn one request into a Scout → Architect → parallel coders → blind Reviewer pipeline using your agent's own subagents, with a human approval gate and one squash commit.

    Free

    Security scanned
    Orchestration

    Orchestration

    Example session with this skill installed

    /orchestration add rate limiting to the public API with per-key limits and tests

    • Read your context and instructions
    • Compiled the orchestration

    (Illustrative)

    Scout -> context.md: 14 relevant files, existing middleware pattern at src/api/middleware.ts:22-60, test gaps listed.
    Architect -> plan.md: 3 tasks
    
    1. Limiter core (src/limits/*) - INDEPENDENT - persona: Backend performance engineer
    2. Middleware wiring (src/api/middleware.ts) - DEPENDS ON 1 - persona: API platform engineer
    3. Tests (tests/limits/*) - INDEPENDENT - persona: QA automation engineer
    Approval gate -> you review and approve.
    Coders -> coder_1/2/3_summary.md with real test results.
    Reviewer (blind) -> review.md: NEEDS FIXES (1 major: race in counter reset, src/limits/store.ts:48) -> fix loop -> APPROVED.
    

    Landed: one squash commit on develop. Worktree and branch removed.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    One feature request in. One reviewed commit out.

    Your agent can write code. On its own, it will not survey the repo first, split the work into non-overlapping file ownership, run specialists in parallel, and then have a fresh reviewer that never saw the plan check the combined diff. Orchestration installs that discipline as a procedure your agent follows, using only its own subagents.

    The pipeline

    1. Scout (read-only) maps the repo and answers targeted questions with file:line evidence.
    2. Architect (read-only) writes plan.md: numbered tasks, each with disjoint owned files, a dependency (INDEPENDENT or DEPENDS ON), an expert persona and verification command.
    3. You approve the plan. No code is written before that. A changed plan needs fresh approval.
    4. Parallel specialist coders each get a tailored persona, scope and file list. Independent tasks run concurrently; dependent ones are sequenced.
    5. Blind reviewer (never saw the plan discussion) checks the combined diff and returns APPROVED or NEEDS FIXES with severity and file:line. Scoped fix loop, capped at 3 cycles.
    6. One squash commit on develop / main / master. git reset --hard is forbidden; conflicts go back to a coder, never to a destructive reset.

    Why this shape

    • Focused context per role instead of one overloaded conversation.
    • Disjoint file ownership means fewer overlapping edits.
    • Every handoff is a file in the run directory (context.md, plan.md, coder_N_summary.md, review.md) so the work is traceable.
    • An independent reviewer catches what the author of the code will not.

    These are intended benefits, not measured gains. Personas are prompts, not trained experts, and extra agents add cost and overhead: use it for work that touches several files, migrations, or anything where "it compiles" is not the finish line. Do not use it for one-line fixes.

    Safety by design

    • Isolated git worktree and branch (orchestration/<run-id>). Your working tree is never touched; refuses to start on a dirty tree.
    • Read-only roles stay read-only. Orchestrator never writes code itself.
    • Never invents a model ID: uses the models you pin with --models, otherwise each subagent inherits the host default. Rejected parameter = reported, never silently swapped.
    • Never pushes and never opens a PR unless you ask.
    • No hidden network calls, no credential access, no external services.

    Requirements

    A shell, a git repository and a subagent tool in your agent (Claude Code Agent, Pi subagent, OpenCode subagent, Antigravity invoke_subagent, Hermes delegate_task). If there is no subagent tool the skill stops and says so instead of faking the pipeline in one context.

    Honest limits

    • Needs an agent that can run shell commands and write files; chat-only agents cannot use it.
    • Harness compatibility is by design from each host's documented subagent tool; it has not been end-to-end tested on every harness.
    • Per-role model overrides depend on the host: Hermes delegate_task does not support them, and the skill fails closed if you ask for it.
    • Multiple subagents consume more tokens than a single-agent run.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Workflow Automation.

    Needs a subagent tool and shell/file access. Not tested end-to-end on every harness. Uses more tokens than a single-agent run. Personas are prompts, not trained experts.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Software
    Git repositoryShell accessSubagent tool in your agentGit
    Optional
    Per-role model pinning (host dependent)

    Permissions

    File Scopes

    Repo
    worktree
    and
    repo
    -orch-
    run-id
    sibling
    directory

    No network calls. Creates a git worktree and branch; never pushes.

    Listed6 days ago
    Updatedtoday

    What's inside

    Frequently Asked Questions

    Any agent with shell access and a subagent tool: Claude Code, Pi, OpenCode, Antigravity, Hermes. It stops if no subagent tool exists.

    No. It requires a clean tree and works in a separate git worktree on orchestration/<run-id>.

    Never, unless you explicitly ask.

    Yes with --models where the host supports it; otherwise subagents inherit your default. It never invents model IDs.

    No. Use it for multi-file work, migrations and changes where independent review matters.

    New in Workflow Automation

    Free