Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Freebies — Simple Subagent Delegator

    1

    Decompose complex tasks into specialized subagent workflows with explicit context handshakes and state isolation.

    Free

    Security scanned
    Freebies — Simple Subagent Delegator

    Freebies — Simple Subagent Delegator

    Example session with this skill installed

    Break down the task of building a secure auth service into a subagent delegation plan with clear handoffs.

    • Read your context and instructions
    • Compiled the freebies

    I have decomposed the authentication service development into a modular subagent workflow. This plan establishes four specialized personas with strict input/output contracts to ensure security and architectural integrity. ## Subagent Delegation Orchestration Plan | Phase | Subagent Persona | Input Contract | Output Deliverable | Verification Gate | | :--- | :--- | :--- | :--- | :--- | | 1 | **Security Architect** | Feature Requirements | `auth-spec.md` (Threat Model) | OWASP Top 10 Checklist | | 2 | **Database Designer** | `auth-spec.md` | `schema.sql` (Bcrypt/Salted) | Normalization Review | | 3 | **Backend Developer** | `schema.sql` + Spec | `auth-service.ts` | Unit Test Coverage > 90% | | 4 | **Security Reviewer** | `auth-service.ts` | Audit Report | Pentest Simulation | ### Message Passing Schema (JSON Handoff) ```json { "trace_id": "auth-svc-001", "source_agent": "Security-Architect", "target_agent": "Database-Designer", "payload": { "encryption_standard": "AES-256-GCM", "hashing_rounds": 12, "session_strategy": "JWT-Stateless" }, "verification_status": "PASSED" } ``` **Next steps** 1. Review the `auth-spec.md` requirements for JWT expiration policies. 2. Initialize the Database Designer subagent with the `schema.sql` template. 3. Run the automated evaluation suite in `evals/eval-suite.json` to validate the handoff logic.

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

    About this skill

    Monolithic prompts often fail when tasks become too complex for a single context window. This skill provides a deterministic framework for decomposing high-level goals into modular subagent workflows with strict state isolation and contract-based handoffs. ## What it does - **Task Decomposition** breaks down complex user goals into independent, sequentially dependent subtasks. - **Persona Assignment** routes subtasks to specialized roles like Researcher, Architect, or Reviewer. - **Context Handshaking** defines explicit Markdown or JSON contracts for data passing between agents. - **Verification Checkpoints** establishes quality gates before intermediate outputs advance to the next stage. - **State Isolation** ensures subtasks remain modular and free from global context pollution. ## How it works 1. **Analyze** the high-level request to identify logical boundaries for sub-orchestration. 2. **Define** the specialized subagent personas required for the specific technical domain. 3. **Map** the sequential flow and data contracts required for each agent handoff. 4. **Output** a structured orchestration diagram and message-passing schema for implementation. ## Frameworks & tools Built for AAIF agentskills.io Open Standard. Compatible with Claude Code, Cursor, Windsurf, Gemini CLI, and OpenAI Codex. Supports project-scoped runners like `npx`, `uvx`, and `pipx`. ## Why this beats prompting it yourself Manual delegation often leads to "context drift" where agents lose track of the original goal. This skill enforces strict handshake contracts and verification steps that prevent logic errors during complex, multi-stage agentic workflows. ## Use cases - Designing a multi-agent swarm to handle automated PR reviews and refactoring. - Orchestrating a research-to-code pipeline with distinct architect and implementer roles. - Implementing MCP server workflows that require isolated state between tool executions. ## Known limitations Restricted to the active project workspace. Does not support global system package installations or root-level commands.

    Workspace-confined to ./. No support for parent directory access, root/admin commands, or global package installations.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.
    Linux only

    Permissions

    Read Files

    Target Use Cases: - Design a subagent task delegation workflow. - Break down a complex task for multiple AI agents. - Create handoff contracts between AI subagents.

    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill prevents 'context drift' and logic errors by breaking monolithic prompts into modular subtasks with strict data contracts, ensuring each agent remains focused on a specific role without being overwhelmed by unrelated information.

    The skill is fully compatible with the AAIF agentskills.io Open Standard and works seamlessly with popular AI tools like Claude Code, Cursor, Windsurf, and Gemini CLI.

    No, this skill is designed to work within your active project workspace using local runners like npx, uvx, or pipx, ensuring it respects your environment's security and isolation.

    You receive the complete orchestration framework, including specialized persona templates, contract-based handoff schemas, and the deterministic logic required to decompose complex tasks into modular workflows.

    Yes, this framework is specifically optimized for Multi-Context Protocol (MCP) server workflows, providing the state isolation necessary to manage data passing between different tool executions.

    New in Agents & Orchestration