Launch Sub Agent
Dispatch a focused sub-agent with automatic model and specialist selection, Zero-shot chain-of-thought up front, and mandatory self-critique so long tasks do not pollute the main session context.
Overview
launch-sub-agent is an agent skill for the Build phase that dispatches isolated sub-agents with analyzed task type, model selection, Zero-shot CoT, and mandatory end-of-run self-critique.
Install
npx skills add https://github.com/neolabhq/context-engineering-kit --skill launch-sub-agentWhat is this skill?
- Supervisor/orchestrator pattern with context isolation per sub-task
- Phase 1 task analysis via Zero-shot Chain-of-Thought before dispatch
- Automatic model selection (opus, sonnet, haiku) with optional CLI overrides
- Specialized agent matching and optional --output path for artifacts
- Mandatory self-critique verification at the end of each sub-agent run
- 3-phase process: CoT analysis, dispatch configuration, self-critique close
Adoption & trust: 534 installs on skills.sh; 1.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your primary agent context is cluttered with half-finished research and code, so follow-up answers degrade and expensive tasks run on the wrong model tier.
Who is it for?
Solo builders orchestrating multi-step implementation or research from Claude Code who want a repeatable dispatch ritual and optional artifact paths.
Skip if: Simple one-shot edits where a single reply suffices, or environments that block sub-agent or task APIs entirely.
When should I use this skill?
Task description provided (e.g., implement a feature or research a topic) and you want intelligent sub-agent launch with optional --model, --agent, and --output.
What do I get? / Deliverables
You get a configured sub-agent run with documented analysis, chosen model/agent flags, and verified output—without carrying the whole exploration history in the parent chat.
- Sub-agent run with stated model/agent config
- Task-type analysis transcript
- Self-critique verification block and optional output artifact
Recommended Skills
Journey fit
Sub-agent orchestration is build-phase agent infrastructure—the skill implements the supervisor pattern while you implement features, research, or docs. It directly configures how auxiliary agents run (model tier, agent profile, isolated context), which is core agent-tooling rather than app business logic.
How it compares
Agent workflow skill for context isolation—not an MCP server and not a hosted multi-agent platform.
Common Questions / FAQ
Who is launch-sub-agent for?
Indie developers and small teams using orchestrator-style agents who need delegated tasks with explicit model and specialist selection.
When should I use launch-sub-agent?
During build agent-tooling when implementing a feature slice, researching alternatives, or drafting docs in a fresh context window while the parent session stays strategic.
Is launch-sub-agent safe to install?
Sub-agents may inherit your repo and tool permissions—review the Security Audits panel on this Prism page and scope filesystem/network access before dispatching untrusted tasks.
SKILL.md
READMESKILL.md - Launch Sub Agent
# launch-sub-agent <task> Launch a focused sub-agent to execute the provided task. Analyze the task to intelligently select the optimal model and agent configuration, then dispatch a sub-agent with Zero-shot Chain-of-Thought reasoning at the beginning and mandatory self-critique verification at the end. </task> <context> This command implements the **Supervisor/Orchestrator pattern** from multi-agent architectures where you (the orchestrator) dispatch focused sub-agents with isolated context. The primary benefit is **context isolation** - each sub-agent operates in a clean context window focused on its specific task without accumulated context pollution. </context> ## Process ### Phase 1: Task Analysis with Zero-shot CoT Before dispatching, analyze the task systematically. Think through step by step: ``` Let me analyze this task step by step to determine the optimal configuration: 1. **Task Type Identification** "What type of work is being requested?" - Code implementation / feature development - Research / investigation / comparison - Documentation / technical writing - Code review / quality analysis - Architecture / system design - Testing / validation - Simple transformation / lookup 2. **Complexity Assessment** "How complex is the reasoning required?" - High: Architecture decisions, novel problem-solving, multi-faceted analysis - Medium: Standard implementation following patterns, moderate research - Low: Simple transformations, lookups, well-defined single-step tasks 3. **Output Size Estimation** "How extensive is the expected output?" - Large: Multiple files, comprehensive documentation, extensive analysis - Medium: Single feature, focused deliverable - Small: Quick answer, minor change, brief output 4. **Domain Expertise Check** "Does this task match a specialized agent profile?" - Development: code, implement, feature, endpoint, TDD, tests - Research: investigate, compare, evaluate, options, library - Documentation: document, README, guide, explain, tutorial - Architecture: design, system, structure, scalability - Exploration: understand, navigate, find, codebase patterns ``` ### Phase 2: Model Selection Select the optimal model based on task analysis: | Task Profile | Recommended Model | Rationale | |--------------|-------------------|-----------| | **Complex reasoning** (architecture, design, critical decisions) | `opus` | Maximum reasoning capability | | **Specialized domain** (matches agent profile) | Opus + Specialized Agent | Domain expertise + reasoning power | | **Non-complex but long** (extensive docs, verbose output) | `sonnet[1m]` | Good capability, cost-efficient for length | | **Simple and short** (trivial tasks, quick lookups) | `haiku` | Fast, cost-effective for easy tasks | | **Default** (when uncertain) | `opus` | Optimize for quality over cost | **Decision Tree:** ``` Is task COMPLEX (architecture, design, novel problem, critical decision)? | +-- YES --> Use Opus (highest capability) | | | +-- Does it match a specialized domain? | +-- YES --> Include specialized agent prompt | +-- NO --> Use Opus alone | +-- NO --> Is task SIMPLE and SHORT? | +-- YES --> Use Haiku (fast, cheap) | +-- NO --> Is output LONG but task not complex? | +-- YES --> Use Sonnet (balanced) | +-- NO --> Use Opus (default) ``` ### Phase 3: Specialized Agent Matching If the task