delegation

Delegate parallel tasks to isolated sub-agents for efficient orchestration.

28|14|Updated Mar 2, 2026
One-click install
npx skills add https://github.com/ai-ecoverse/slicc --skill delegation-ai-ecoverse
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: delegation
Source: https://github.com/ai-ecoverse/slicc/tree/main/packages/vfs-root/workspace/skills/delegation
Command: npx skills add https://github.com/ai-ecoverse/slicc --skill delegation-ai-ecoverse

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the inefficiency of handling all work in a single agent context, reducing total task completion time and cutting wasted context overhead from unnecessary pre-work by the main orchestrator.

Core Features & Use Cases

  • Delegation Decision Guidance: Clear rules for when to handle work directly vs delegate to sub-agents (scoops) to maximize efficiency.
  • Sub-Agent Lifecycle Management: Instructions for when to retain or drop sub-agents, including rules for preserving sub-agents that own active task ownership (sprinkles).
  • Parallel Orchestration Primitives: Built-in tools to batch parallel sub-agent work and eliminate redundant context turns from individual sub-agent completion notifications.
  • Sandbox Configuration: Best practices for setting sub-agent read/write permissions and command allow-lists to balance autonomy and safety.
  • One-Shot Ephemeral Sub-Agents: Guidance for spawning lightweight, isolated sub-agents for quick, deterministic tasks with no follow-up overhead. Use Case: If you need to compare 3 different software libraries for a project, you can delegate each library's research to a separate scoop, then synthesize the results in a single turn instead of running each research task sequentially.

Quick Start

Delegate parallel sub-agents to research three software libraries for your project and compile a unified feature comparison report.

Frequently Asked Questions about delegation

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

FAQPage Schema
How do I run parallel research tasks with sub-agents instead of executing them sequentially?

Parallel task delegation assigns each independent research task, like evaluating a software library, to a separate sub-agent scoop. This architecture completes the total workload concurrently and synthesizes the results in a single turn to reduce overall execution time.

When should I delegate work to sub-agents rather than handling it in a single agent context?

You should delegate to sub-agents when handling multi-source data collection, parallel code refactoring, or independent research. Delegation eliminates wasted context overhead from the main orchestrator's unnecessary pre-work and significantly reduces total task completion time.

How does sub-agent lifecycle management handle retaining or dropping active task ownership?

Sub-agent lifecycle management provides explicit instructions for when to retain or drop sub-agents. It includes specific rules for preserving sub-agents that own active task ownership, known as sprinkles, ensuring continuous workflow tracking without premature termination.

How do I configure sandbox permissions and command allow-lists for autonomous sub-agents?

Sandbox configuration applies best practices for setting sub-agent read and write permissions alongside command allow-lists. This configuration balances sub-agent autonomy for executing delegated tasks with strict safety constraints to protect the main orchestration environment.

What is the best way to handle isolated deterministic tasks without follow-up overhead?

Spawning one-shot ephemeral sub-agents handles quick, deterministic tasks in complete isolation. This lightweight approach executes isolated operations without retaining sub-agent state or generating follow-up context overhead for the main orchestrator.

Why does parallel orchestration eliminate redundant context turns from sub-agent completion notifications?

Parallel orchestration primitives batch parallel sub-agent work together, which eliminates redundant context turns. Instead of processing individual sub-agent completion notifications sequentially, the orchestrator receives and synthesizes all compiled results simultaneously.