Delegation

Routes multi-workstream tasks to specialized agents or Claude Code Teams for parallel execution.

1|Updated Apr 16, 2026
One-click install
npx skills add https://github.com/davdunc/pai-framework --skill delegation-davdunc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Delegation
Source: https://github.com/davdunc/pai-framework/tree/main/skills/Delegation
Command: npx skills add https://github.com/davdunc/pai-framework --skill delegation-davdunc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Delegation turns large, multi-workstream tasks into faster and more reliable outcomes by splitting work across specialized agents or coordinated teams instead of relying on a single agent to do everything sequentially.

Core Features & Use Cases

  • Two routing paths: uses Agents Skill for custom/specialized parallel workers, while using Claude Code Teams for persistent, coordinated agent teams.
  • Parallel execution modes: supports built-in specialized agents (Engineer/Architect/Algorithm/Explore/Plan), worktree-isolated file-safe parallel edits, and background agents for non-blocking work.
  • Scales by effort and workload: chooses between lightweight (haiku, max_turns=3) and full delegation (multi-step tool-using) based on whether the task can finish without tools in a single call.
  • Works well for division of labor: enables “divide and conquer” patterns such as research + implementation in parallel, and multi-file refactors across multiple agents.
  • Execution logging: instructs appending a JSONL entry to the skills execution log after workflow completion.

Quick Start

Use Delegation when you have 3+ independent workstreams and want parallel specialized agents (or an agent team) to execute them, for example: “Plan and implement the API, UI, and tests in parallel, coordinating where they share state.”

Frequently Asked Questions about Delegation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I parallelize multi-workstream tasks across specialized agents?

Agent orchestration splits large sequential tasks into faster parallel execution by routing work to built-in specialized agents, worktree-isolated background workers, or coordinated agent teams via Claude Code TeamCreate. This enables concurrent division of labor across independent workstreams.

When should I use worktree isolation for parallel agent execution?

Worktree isolation is needed when multiple agents require file-safe parallel edits without overwriting each other. It supports non-blocking background execution and prevents concurrent file modification conflicts across specialized agents working simultaneously.

How do I route agents for multi-turn collaboration with shared state?

For multi-turn collaboration requiring shared state or inter-agent communication, route tasks to coordinated agent teams using Claude Code Teams and messaging orchestration. This handles persistent coordination where agents must interact continuously.

What is the difference between lightweight and full agent delegation?

Lightweight delegation uses haiku models with a three-turn limit for tasks finishing without tools in a single call, while full delegation uses multi-step tool-using agents. The routing choice depends on tool requirements and completion likelihood.

Can I fan out identical operations to multiple identical agents at once?

Yes, you can fan out multiple identical operations across parallel subagents. This delegation pattern is suited for scenarios requiring agent specialization or concurrent execution of identical tasks across independent workstreams.

What are the limitations of using parallel agent orchestration for software engineering?

Parallel agent orchestration requires correct routing between built-in task agents, worktree isolation, or TeamCreate orchestration. It is not suited for tasks lacking independent workstreams or when shared state coordination overhead outweighs sequential execution.