More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    delegate-kit: 8 Claude Code subagents + playbook

    2

    Run Claude Code as an orchestrator: 8 subagents tiered by reasoning depth and cost, measured 6-10x cheaper per unit of work on large tasks.

    $12.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    delegate-kit: 8 Claude Code subagents + playbook

    delegate-kit: 8 Claude Code subagents + playbook

    Example session with this skill installed

    I need to add rate limiting to all public API endpoints and update the documentation. Partition this work and start with the implementation plan.

    • Read your context and instructions
    • Compiled the delegate-kit

    I have partitioned the objective into four work units across three execution layers. The schedule is stored in .delegate-kit/runs/api-rate-limit/schedule.json.

    Partitioning Plan: API Rate Limiting

    LayerIDTitleKindFilesEst. Cost
    0W1Rate Limit Middlewarebuild3$0.12
    1W2Apply to Public Routesapply12$0.45
    1W3Update API Docsapply2$0.08
    2W4Verify & Load Testverify15$0.30

    The partitioner has identified a shared middleware bottleneck in src/middleware/auth.ts. I will spawn the executer for

    W1 first to establish the contract before parallelizing the application to routes.

    Next steps

    1. Review the schedule.json for file hit accuracy.
    2. Spawn the executer for [W1] using the generated middleware spec.
    3. Run dk bench after the first layer to calibrate cost estimates.

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

    About this skill

    Stop burning expensive context on long Claude Code sessions. Large objectives often lead to massive context accumulation, driving up token costs and slowing down response times. This skill provides a specialized orchestration layer that delegates work to a fleet of eight tiered subagents, each optimized for specific reasoning depths and context costs.

    What it does

    • Multi-agent delegation routes work to eight specific subagent types including thinkers, researchers, and executers.
    • Cost optimization: measured across 1,233 real Claude Code sessions, running as the director cut cost 6-10x per unit of work on objectives past ~35 tool calls, because the expensive model never accumulates a context. Below that line it costs more - full numbers, both directions, are in reference/measurements.md.
    • Automated partitioning splits wide, multi-file changes into independent work units and parallel execution clusters.
    • Web-enabled research provides a dedicated agent for fetching external documentation and API specs without repo access overhead.
    • Defect hunting fans out cheap, disposable agents to sweep a listed set of files or a diff for real defects (never style).

    How it works

    1. Setup installs the agent definitions and Python-based partitioning tools to the local ~/.claude directory.
    2. Orchestration initiates a session using the director agent to manage the high-level objective and delegation logic.
    3. Partitioning uses the partitioner to map out complex tasks into a schedule.json before any implementation begins.
    4. Execution spawns targeted workers (thinker, executer, simple-tasks) to perform isolated units of work and report findings by reference.

    Frameworks & tools

    The kit requires Claude Code and Python 3. It utilizes built-in shell tools like grep, bash, and sed, with optional enhanced support for Serena and graphify MCP servers.

    Why this beats prompting it yourself

    Writing manual prompts for subagents requires constant context management to prevent token bloat. This skill provides a formal protocol for "relay by reference," moving payloads through the filesystem instead of the chat history.

    Use cases

    • Refactoring large subsystems where a single agent would exceed context limits.
    • Performing parallel bug sweeps across dozens of files simultaneously.
    • Implementing features that require deep external API research before coding.
    • Automating mechanical chores like git management and multi-hop builds.

    Known limitations

    Claude Code only: the director and the per-agent model pins rely on Claude Code subagents. Requires a manual installation step and a new session start to load agent definitions. Subagents are instructed not to run destructive git commands; this package installs no hooks, so that rule is enforced by their instructions only.

    Claude Code only. Requires Python 3 for the dk scripts. Agent definitions only load at session start. Destructive git commands are forbidden by the agents' instructions; this package installs no hooks, so that rule is enforced by instructions only. Small tasks (under ~35 tool calls) cost more with the director than without.

    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 1 month ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Environment Variables
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This kit solves the 'context bloat' issue in Claude Code by delegating tasks to eight specialized subagents, preventing a single session from becoming too expensive or slow during long-running projects.

    The kit is specifically built for Claude Code and requires Python 3 for its partitioning tools. Serena and graphify MCP servers are optional extras, not required.

    You receive eight pre-configured agent definitions (including the Director, Partitioner, and Researcher), a Python-based partitioning utility, and a comprehensive implementation playbook.

    While the kit significantly cuts costs for complex tasks over 35 tool calls, it may actually be more expensive for very small, single-file tasks due to the initial orchestration overhead.

    Installation involves moving the agent definitions and Python tools into your local `~/.claude` directory and starting a new session to load the new delegation protocol.

    This kit uses a 'relay by reference' protocol, meaning data is passed through the filesystem rather than the chat history, which keeps the model's active context window lean and focused.

    New in Agents & Orchestration