什么是 智能委派框架？

此技能为 Openclaw Skills 提供了智能 AI 委派框架的实际实现。它解决了多智能体系统中常见的故障，如后台任务丢失、对子代理输出的盲目信任以及缺乏对以往错误的系统性学习。通过建立严格的协议，该框架确保每次委派都得到追踪、验证并针对性能进行了优化。

利用这些 Openclaw Skills，开发人员可以构建更具韧性的智能体工作流。它将范式从简单的任务分解转变为稳健的问责生态系统，智能体通过使用任务合同、自动化验证脚本和自适应回退链，能够自信地处理复杂且高风险的环境。

下载入口:https://github.com/openclaw/skills/tree/main/skills/hogpile/intelligent-delegation

安装与下载

1. ClawHub CLI

从源直接安装技能的最快方式。

2. 手动安装

将技能文件夹复制到以下位置之一

优先级：工作区 > 本地 > 内置

3. 提示词安装

将此提示词复制到 OpenClaw 即可自动安装。

智能委派框架 应用场景

• 在多个子代理之间管理长时间运行的后台任务而不丢失进度。
• 使用程序化检查自动验证来自专业 LLM 智能体的复杂输出。
• 当主智能体遇到上下文溢出或超时时，实施自适应恢复协议。
• 构建基于性能的路由系统，学习哪些智能体最适合特定的技术任务。
• 针对高关键性或不可逆的操作，校准人工介入的升级机制。

1. 任务追踪：智能体将所有后台工作记录到 TASKS.md 文件中，并调度一个单次 cron 任务以确保检查完成情况。
2. 性能日志：记录每次委派的结果到性能日志中，以追踪成功率、成本和失败模式，为未来的路由决策提供参考。
3. 合同规范：在委派之前，智能体定义正式合同，包括可由机器检查的成功标准和输出位置。
4. 自动化验证：verify_task.py 工具执行任务后检查（例如 JSON 验证、数据库行数统计），以确认受托方满足合同要求。
5. 自适应重路由：如果任务失败，框架会诊断根本原因并触发回退链，其中可能包括重试、切换到脚本或升级到人工处理。

智能委派框架 配置指南

要将框架安装到您的环境中，请使用以下命令：

clawhub install intelligent-delegation

安装后，您应将委派协议集成到您的 AGENTS.md 中，并将“活动任务监控器”添加为 HEARTBEAT.md 中的第一项检查，以确保持久追踪。当这些模板在您的工作区中保持一致维护时，Openclaw Skills 的效果最佳。

智能委派框架 数据架构与分类体系

该框架通过一组 Markdown 模板和 Python 工具来组织其数据和元数据：

name: intelligent-delegation
description: A 5-phase framework for reliable AI-to-AI task delegation, inspired by Google DeepMind's "Intelligent AI Delegation" paper (arXiv 2602.11865). Includes task tracking, sub-agent performance logging, automated verification, fallback chains, and multi-axis task scoring.
version: 1.0.0
author: Kai (@Kai954963046221)
metadata:
  openclaw:
    inject: false

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

The Solution: 5 Phases

Phase 1: Task Tracking & Scheduled Checks

Problem: "I'll ping you when it's done" → never happens.

Solution:

1. Create a TASKS.md file to log all background work
2. For every background task, schedule a one-shot cron job to check on completion
3. 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:

1. Log the outcome (success/partial/failed/crashed)
2. Note runtime and token cost
3. Record lessons learned

Before every delegation:

1. Check if this agent has failed on similar tasks
2. 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:

1. Define formal contracts before delegating (expected output, success criteria)
2. 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:

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):

1. Complexity — steps / reasoning required
2. Criticality — consequences of failure
3. Cost — expected compute expense
4. Reversibility — can effects be undone (1=yes, 5=no)
5. Verifiability — ease of checking output (1=auto, 5=human judgment)
6. Contextuality — sensitive data involved
7. 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