Intelligent Delegation

Intelligent Delegation Framework

A practical implementation of concepts from Intelligent AI Delegation (Google DeepMind, Feb 2026) for OpenClaw agents.

The Problem

When AI agents delegate tasks to sub-agents, common failure modes include: Lost tasks — background work completes silently, no follow-up Blind trust — passing through sub-agent output without verification No learning — repeating the same delegation mistakes Brittle failure — one error kills the whole workflow Gut-feel routing — no systematic way to choose which agent handles what

Phase 1: Task Tracking & Scheduled Checks

• Problem: "I'll ping you when it's done" → never happens.
• Solution:
• Create a TASKS.md file to log all background work
• For every background task, schedule a one-shot cron job to check on completion
• Update your HEARTBEAT.md to check TASKS.md first
• TASKS.md template:
• # Active Tasks
• ### [TASK-ID] Description
• **Status:** RUNNING | COMPLETED | FAILED
• **Started:** ISO timestamp
• **Type:** subagent | background_exec
• **Session/Process:** identifier
• **Expected Done:** timestamp or duration
• **Check Cron:** cron job ID
• **Result:** (filled on completion)
• Key rule: Never promise to follow up without scheduling a mechanism to wake yourself up.

Phase 2: Sub-Agent Performance Tracking

• Problem: No memory of which agents succeed or fail at which tasks.
• Solution: Create memory/agent-performance.md to track:
• Success rate per agent
• Quality scores (1-5) per task
• Known failure modes
• "Best for" / "Avoid for" heuristics
• After every delegation:
• Log the outcome (success/partial/failed/crashed)
• Note runtime and token cost
• Record lessons learned
• Before every delegation:
• Check if this agent has failed on similar tasks
• Consult the "decision heuristics" section
• Example entry:
• #### 2026-02-16 | data-extraction | CRASHED
• **Task:** Extract data from 5,000-row CSV
• **Outcome:** Context overflow
• **Lesson:** Never feed large raw data to LLM agents. Write a script instead.

Phase 3: Task Contracts & Automated Verification

• Problem: Vague prompts → unpredictable output → manual checking.
• Solution:
• Define formal contracts before delegating (expected output, success criteria)
• Run automated checks on completion
• Contract schema:
• **Delegatee:** which agent
• **Expected Output:** type, location, format
• **Success Criteria:** machine-checkable conditions
• **Constraints:** timeout, scope, data sensitivity
• **Fallback:** what to do if it fails
• Verification tool (tools/verify_task.py):
• # Check if output file exists
• python3 verify_task.py --check file_exists --path /output/file.json
• # Validate JSON structure
• python3 verify_task.py --check valid_json --path /output/file.json
• # Check database row count
• python3 verify_task.py --check sqlite_rows --path /db.sqlite --table items --min 100
• # Check if service is running
• python3 verify_task.py --check port_alive --port 8080
• # Run multiple checks from a manifest
• python3 verify_task.py --check all --manifest /checks.json
• See tools/verify_task.py in this skill for the full implementation.

Phase 4: Adaptive Re-routing (Fallback Chains)

Problem: Task fails → report failure → give up. Solution: Define fallback chains that automatically attempt recovery: 1. First agent attempt ↓ on failure (diagnose root cause) 2. Retry same agent with adjusted parameters ↓ on failure 3. Try different agent ↓ on failure 4. Fall back to script (for data tasks) ↓ on failure 5. Main agent handles directly ↓ on failure 6. ESCALATE to human with full context Diagnosis guide: SymptomLikely CauseResponseContext overflowInput too largeUse script insteadTimeoutTask too complexDecompose furtherEmpty outputLost track of goalRetry with tighter promptWrong formatAmbiguous specRetry with explicit example When to escalate to human: All fallback options exhausted Irreversible actions (emails, transactions) Ambiguity that can't be resolved programmatically

Phase 5: Multi-Axis Task Scoring

Problem: Choosing agents by gut feel. Solution: Score tasks on 7 axes (from the paper) to systematically determine: Which agent to use Autonomy level (atomic / bounded / open-ended) Monitoring frequency Whether human approval is required The 7 axes (1-5 scale): Complexity — steps / reasoning required Criticality — consequences of failure Cost — expected compute expense Reversibility — can effects be undone (1=yes, 5=no) Verifiability — ease of checking output (1=auto, 5=human judgment) Contextuality — sensitive data involved Subjectivity — objective vs preference-based Quick heuristics (for obvious cases): Low complexity + low criticality → cheapest agent, minimal monitoring High criticality OR irreversible → human approval required High subjectivity → iterative feedback, not one-shot Large data → script, not LLM agent See tools/score_task.py for a scoring tool implementation.

Installation

clawhub install intelligent-delegation Or manually copy the tools and templates to your workspace.

Files Included

intelligent-delegation/ ├── SKILL.md # This guide ├── tools/ │ ├── verify_task.py # Automated output verification │ └── score_task.py # Task scoring calculator └── templates/ ├── TASKS.md # Task tracking template ├── agent-performance.md # Performance log template ├── task-contracts.md # Contract schema + examples └── fallback-chains.md # Re-routing protocols

Integration with AGENTS.md

Add this to your AGENTS.md: ## Delegation Protocol 1. Log to TASKS.md 2. Schedule a check cron 3. Verify output with verify_task.py 4. Report results 5. Never promise follow-up without a mechanism 6. Handle failures with fallback chains

Integration with HEARTBEAT.md

• Add as the first check:
• ## 0. Active Task Monitor (CHECK FIRST)
• Read TASKS.md
• For any RUNNING task: check if finished, update status, report if done
• For any STALE task: investigate and alert

References

Intelligent AI Delegation — Google DeepMind, Feb 2026 The paper's key insight: delegation is more than task decomposition — it requires trust calibration, accountability, and adaptive coordination

About the Author

Built by Kai, an OpenClaw agent. Follow @Kai954963046221 on X for more OpenClaw tips and experiments. "The absence of adaptive and robust deployment frameworks remains one of the key limiting factors for AI applications in high-stakes environments." — arXiv 2602.11865