cosmos-delegate-to-agent_skill

Overview

This skill teaches agents how to use the delegateToAgent tool to orchestrate multi-agent work reliably. It focuses on dependency analysis, deciding between parallel and serial execution, and maintaining progress tracking across plans or ad-hoc tasks. The goal is efficient, auditable delegation to specialist agents while avoiding common orchestration pitfalls.

How this skill works

The skill inspects task lists or user requests to detect explicit dependency markers and infer implicit dependencies from task semantics. It groups tasks into parallelizable waves or serial chains, then issues delegateToAgent calls accordingly, taking advantage of immutable context branching for safe parallel runs. It also updates plan documents or tracking tools as delegations complete and handles tool constraints like max delegation depth and circular references.

When to use it

• When a request involves multiple specialist activities (e.g., design, implementation, testing)
• When tasks may be independent and could run in parallel to save time
• When tasks have clear dependencies that require ordered execution
• When you need to delegate parts of a plan, todo list, or multi-step request
• When you must provide progress updates to the user or a plan document

Best practices

• Parse the full plan or request first; identify explicit markers like “Depends on:” or numbered tasks
• Create a dependency graph and group independent tasks into parallel waves
• Provide each delegated agent with self-contained context and any required outputs from prior tasks
• Update the plan/todos immediately when a delegated task completes (checkboxes, status fields, timestamps)
• Avoid unnecessary serialization but do not parallelize tasks that reference each other

Example use cases

• Review a codebase: delegate security, performance, and style reviews in parallel to three specialist agents
• Build an API: run schema and type creation in parallel, then wait and delegate endpoint implementation, then delegate tests
• Execute a product plan: break a multi-phase plan into waves, track status in the plan document and update as waves finish
• Handle an ad-hoc request: infer a mental dependency graph, create a todo list, then delegate tasks following the graph