home / skills / openclaw / skills / delegate

delegate skill

safe

This skill delegates tasks to sub-agents with optimal model selection, error handling, and result verification to improve efficiency and reliability.

npx playbooks add skill openclaw/skills --skill delegate

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

1.7 KB

---
name: Delegate
description: Route tasks to sub-agents with optimal model selection, error recovery, and result verification.
---

## Core Rule

Spawn cost < task cost → delegate. Otherwise, do it yourself.

## Model Tiers

| Tier | Models | Cost | Use for |
|------|--------|------|---------|
| Small | Haiku, GPT-4o-mini, Gemini Flash | ~$0.25/1M | Search, summarize, format, classify |
| Medium | Sonnet, GPT-4o, Gemini Pro | ~$3/1M | Code, analysis, synthesis |
| Large | Opus, o1, Gemini Ultra | ~$15/1M | Architecture, complex reasoning |

**Rule of thumb:** Start with smallest tier. Escalate only if output quality insufficient.

## Spawn Checklist

Every spawn must include:
```
1. TASK: Single clear deliverable (not "help with X")
2. MODEL: Explicit tier choice
3. CONTEXT: Only files/info needed (never full history)
4. OUTPUT: Expected format ("return JSON with...", "write to file X")
5. DONE: How to signal completion
```

Check `templates.md` for copy-paste spawn templates.

## Error Recovery

| Error Type | Action |
|------------|--------|
| Sub-agent timeout (>5 min no response) | Kill and retry once |
| Wrong output format | Retry with stricter instructions |
| Task too complex for tier | Escalate: Small→Medium→Large |
| Repeated failures (3x) | Abort, report to user |

Check `errors.md` for recovery patterns and escalation logic.

## Verification

Never trust "done" without checking:
- **Code:** Run tests, check syntax
- **Files:** Verify they exist and have content
- **Data:** Spot-check 2-3 items
- **Research:** Confirm sources exist

## Don't Delegate

- Quick tasks (<30 seconds to do yourself)
- Tasks needing conversation context
- Anything requiring user clarification mid-task

Overview

This skill routes tasks to sub-agents with optimal model selection, automated error recovery, and result verification. It decides whether to spawn a sub-agent or handle the task locally using a cost-vs-benefit rule and tiered model choices. The goal is reliable delivery of discrete outputs while minimizing resource use.

How this skill works

For each incoming task the skill compares the estimated spawn cost to the task cost; spawn only when cheaper. It uses three model tiers (Small, Medium, Large) and a rule-of-thumb escalation path: start small, escalate if quality is insufficient. Every spawn follows a strict checklist (task, model, context, output, done) and includes automated checks for timeouts, format errors, and verification rules tailored to code, files, data, and research.

When to use it

Automating discrete deliverables that can be executed without mid-task user clarification
Routing routine search, summarization, or classification work to low-cost models
Offloading code, analysis, or synthesis to medium-tier models for higher fidelity
Delegating architecture or complex reasoning to large-tier models when needed
Running batch jobs that require verification and retries without manual oversight

Best practices

Apply the core rule: spawn only if spawn cost is less than doing it yourself
Always provide a single clear TASK and a precise OUTPUT format in the spawn checklist
Limit CONTEXT to only the files or data needed; do not pass full history
Start with the smallest model tier and escalate only after verification failures
Implement the verification steps for code, files, and data before accepting a sub-agent’s DONE
Abort after repeated failures (three attempts) and report actionable diagnostics to the user

Example use cases

Summarize a set of documents using a Small-tier model and verify key facts before returning results
Generate and test code snippets with a Medium-tier model, run unit tests, and return failing tests for review
Produce architectural recommendations by escalating to a Large-tier model and validating rationale against sources
Transform and validate data files: spawn a sub-agent to convert formats and confirm file integrity
Run automated research batches: retrieve sources, spot-check citations, and flag unverifiable claims

FAQ

How do I choose the initial model tier?

Start with the Small tier for simple search, summarization, and formatting. Escalate to Medium for code or deeper analysis, and to Large for architecture or complex reasoning when verification indicates insufficient quality.

What happens on repeated failures?

If a sub-agent fails the same task three times, the skill aborts delegation and reports detailed diagnostics and the attempted recovery steps to the user.