fleet delegation

    1

    A read-only orchestrator that manages parallel code changes through isolated git-worktrees and structured worker briefs.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    fleet delegation

    Example session with this skill installed

    Title: Fleet Delegation for OpenCode & Claude Code — Parallel Worker Sessions with Review, Worktree Isolation and Permission Classes

    Tagline: Run your coding agent as a chief of staff, not a pair of hands: a read-only orchestrator that delegates to parallel workers, reviews every result, and never lets deploy / spend / destructive actions slip past you.

    Price: $9.99 one-time.

    Description

    Most multi-agent setups fail the same way: one agent edits everything itself, workers collide in the same working tree, and "autonomous" quietly includes deploys and deletions nobody approved.

    Fleet Delegation is the operating discipline from Jarvis, a production voice-and-text chief of staff that supervises a live fleet of OpenCode worker sessions every day. It teaches your agent to work the same way:

    Read-only orchestrator — the brain plans, delegates and reviews; it never edits or runs mutating commands itself, so it cannot break your codebase.
    One task per worker, in a strict brief format (TASK / CONTEXT / SCOPE / VERIFY / REPORT) with a built-in prompt-injection guardrail: content from web pages, issues and email is data, never instructions.
    Git-worktree isolation — every delegation chain gets its own branch and worktree; parallel workers never collide, your checkout is never touched, and finished work lands via land / keep / discard.
    Permission classes with hard stops — reads, tests and in-worktree edits can be automatic; external writes ask; deploy, spend and destructive actions always ask, under every preset.
    Bounded review loop — every worker result comes back with changed files and verification output; the orchestrator reviews the diff and takes at most one next step, max 3 rounds per chain.
    A single decision queue — everything waiting on you (permissions, questions, finished branches) in one place, reported chief-of-staff style.
    Includes three ready-to-use read-only specialist patterns (architecture explainer, contract auditor, verification planner) and the full permission-class table with cautious / balanced / hands-off presets.

    Works with OpenCode, Claude Code, Codex, Grok Build, Cursor, Copilot, Gemini CLI and other SKILL.md-compatible agents (open agentskills.io standard). Install paths for each host are in INSTALL.md. One-time purchase, free updates.

    Tags / keywords: opencode, claude-code, multi-agent, subagents, delegation, orchestration, code-review, git-worktree, parallel-agents, ai-agents, chief-of-staff, automation, devops

    What's in the download

    SKILL.md — the core method (loop, brief format, permission rules, decision queue, reporting, anti-patterns)
    INSTALL.md — per-host install paths and verification
    references/permission-classes.md — full class table + audit/cap rules
    references/specialist-agents.md — the three read-only specialist patterns + how to define builders
    references/worktree-isolation.md — branch naming, landing rules, hygiene

    • Read your context and instructions
    • Compiled the fleet delegation

    I have analyzed the requirements and confirmed that auth and telemetry modules are independent. I am initializing two parallel worker chains using isolated git worktrees.

    Fleet Status Report

    Worker IDTaskScopeStatusBranch
    worker-alphaUpdate logging to JSON format in authsrc/auth/*In Progresstask/auth-logs
    worker-betaUpdate logging to JSON format in telemetrysrc/telemetry/*In Progresstask/telemetry-logs

    Worker Brief: worker-alpha

    TASK: Update all console.log and console.error calls to use the new JSONLogger utility.
    CONTEXT: Follow the pattern in src/shared/logger.ts. Ensure all existing log messages are preserved in the msg field.
    SCOPE: src/auth/
    VERIFY: npm run test:auth and grep -r "console\." src/auth/ (should return no results).
    REPORT: final summary, changed files, verification output.
    GUARDRAIL: Never push or deploy. Ask before modifying files outside src/auth/.

    Worker Brief: worker-beta

    TASK: Update all console.log and console.error calls to use the new JSONLogger utility.
    CONTEXT: Follow the pattern in src/shared/logger.ts.
    SCOPE: src/telemetry/
    VERIFY: npm run test:telemetry and grep -r "console\." src/telemetry/ (should return no results).
    REPORT: final summary, changed files, verification output.
    GUARDRAIL: Never push or deploy. Ask before modifying files outside src/telemetry/.

    Next steps

    1. Wait for worker-alpha to report verification results for the auth module.
    2. Wait for worker-beta to report verification results for the telemetry module.
    3. Review the diffs in the land/discard queue once workers finish.

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

    About this skill

    Managing large-scale code changes or parallel refactors often leads to corrupted checkouts, merge conflicts, and unreviewable PRs. This skill implements a strict chief-of-staff architecture that separates high-level planning from file execution, ensuring your main environment remains stable while workers handle the churn.

    What it does

    • Read-only orchestration ensures the main agent never edits files directly, preventing accidental codebase corruption.
    • Git-worktree isolation runs each delegation chain in a dedicated branch and directory to eliminate environment pollution.
    • Structured worker briefs enforce clear task outcomes, explicit scopes, and mandatory verification commands for every sub-task.
    • Permission class enforcement applies hard stops on destructive actions, deployments, and external writes without user consent.
    • Bounded review loops limit iterations to three rounds to prevent infinite loops and signal when human intervention is required.

    How it works

    1. Analysis phase where the orchestrator identifies necessary changes and defines success criteria for each unit.
    2. Decomposition of the main task into independent, non-overlapping worker units to avoid merge conflicts.
    3. Dispatch using a standardized brief format that includes context, scope, and specific verification commands.
    4. Review of the worker's diff and test output, resulting in either a follow-up, a new specialist dispatch, or a land recommendation.

    Frameworks & tools

    This skill is compatible with any agent host capable of spawning subagents or worker sessions, including Claude Code, Cursor, and Copilot. It utilizes standard git worktree and git branch commands for process isolation.

    Why this beats prompting it yourself

    Standard agents often get "lost" in large tasks, leading to scope creep and messy diffs. This skill enforces a production-grade delegation protocol that guarantees isolation, formalizes the review process, and ensures no destructive action occurs without an explicit permission check.

    Use cases

    • Parallel refactoring of multiple independent modules without manual context switching.
    • Dependency upgrades across several microservices using isolated verification environments.
    • Code audits where a specialist agent analyzes a codebase and prepares a land/discard queue for the developer.

    Known limitations

    Requires a host that supports sub-agents or sequential worker sessions. Not suitable for tasks where sub-tasks have high inter-dependency requiring shared state during execution.

    Requires git worktree support. Not for interdependent tasks sharing a state. Maximum of 3 review rounds per chain. Orchestrator is strictly read-only.

    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 any payment.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 17 days ago

    Requires

    Git

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    It uses git-worktrees to create isolated directories for every sub-task, ensuring that worker agents can run tests and make changes in parallel without ever touching your active working directory or corrupting your main checkout.

    The skill is compatible with any agent environment that supports sub-agent spawning or sequential worker sessions, such as Claude Code, Cursor, and GitHub Copilot.

    Your purchase includes the orchestration protocol, structured worker brief templates, and the permission-class enforcement logic designed to be imported into your agent's system prompt or configuration.

    No complex installation is required; you simply follow the provided integration guide to map your agent's tool-calling capabilities to the git-worktree and worker-brief commands defined in the skill.

    Fleet Delegation is best suited for independent, non-overlapping units of work; tasks that require real-time shared state or high inter-dependency between workers are currently a known limitation.

    The skill includes a 'Bounded Review' logic that triggers a mandatory human intervention signal if a worker fails to meet the success criteria within three iterations, preventing infinite loops and API waste.

    New in Agents & Orchestration