什么是 自主技能编排器？

自主技能编排器是一个先进的框架，旨在解决 AI 开发中上下文过载和认知漂移的挑战。通过实现受成熟编排模式启发的层级架构，它将标准的 AI 交互转变为系统化的规划、引导和执行过程。该技能允许用户利用 Openclaw Skills 的全部功能，将任务委派给专业的子智能体，同时保持一个中央指挥官来确保质量并遵守项目准则。

其核心功能类似于项目经理，将大型目标拆分为具有特定验收标准的细粒度任务。它维护着一份持续的智慧日志，确保在项目一个阶段获得的见解能立即提供给后续阶段的子智能体。这种方法有效地消除了人为瓶颈，允许并行处理和不懈执行，直到完全实现项目目标。

下载入口:https://github.com/openclaw/skills/tree/main/skills/oyi77/joko-orchestrator

安装与下载

1. ClawHub CLI

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

2. 手动安装

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

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

3. 提示词安装

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

自主技能编排器 应用场景

• 需要跨多个模块进行系统验证的大规模代码库重构。
• 从零开始构建复杂的新功能，同时遵循现有的架构模式。
• 自动调试和修复需要重现与测试的深层问题。
• 涉及各种文件和外部引用的广度研究和文档编制任务。
• 并行化独立的开发任务，以大幅缩短项目完成时间。

1. 发现访谈：该技能启动简短访谈，以明确目标、边界和完成标准。
2. 结构化规划：生成详细的工作计划，按复杂度对任务进行分类并定义明确的准则。
3. 计划验证：自审阶段（Momus 模式）确保所有任务都是具体的，且依赖关系已被明确映射。
4. 任务委派：Atlas 指挥官为特定任务派生子智能体，并根据任务类型（如深度、快速、创意）使用适当的模型提示。
5. 智慧积累：实时记录学习心得、发现的模式和成功的命令，以指导未来的子智能体。
6. 独立验证：编排器根据验收标准亲自验证所有子智能体的输出，不盲目信任任何结论。
7. 最终报告：生成一份全面的摘要，记录变更、学习成果和建议的后续步骤。

自主技能编排器 配置指南

要在 Openclaw Skills 环境中激活此技能，您可以使用显式触发器或魔术关键词模式。如果您的库中存在该技能文件，则无需复杂的安装。

# 通过魔术关键词激活
ultrawork "重构支付网关以使用 Stripe"

# 简写激活
ulw "生成一个全面的 API 文档网站"

# 显式编排请求
use autonomous-skill-orchestrator

自主技能编排器 数据架构与分类体系

编排器利用结构化的数据层级在整个项目生命周期中维护状态和上下文。

name: autonomous-skill-orchestrator
description: >
  Deterministically coordinates autonomous planning and execution across available skills under
  strict guardrails. Use only when the user explicitly activates this skill by name to run
  autonomously until a stop command is issued. Trigger keywords include: "use autonomous-skill-orchestrator",
  "activate autonomous-skill-orchestrator", "start autonomous orchestration".
metadata:
  version: "2.0.0"
  owner: "user"
  inspired_by: "oh-my-opencode (Sisyphus, Atlas, Prometheus)"

Autonomous Skill Orchestrator v2.0

Inspired by oh-my-opencode's three-layer architecture, adapted for OpenClaw's ecosystem.

Core Philosophy

Traditional AI follows: user asks → AI responds. This fails for complex work because:

1. Context overload: Large tasks exceed context windows
2. Cognitive drift: AI loses track mid-task
3. Verification gaps: No systematic completeness check
4. Human bottleneck: Requires constant intervention

This skill solves these through specialization and delegation.

Architecture

┌─────────────────────────────────────────────────────────┐
│  PLANNING LAYER (Interview + Plan Generation)          │
│  ? Clarify intent through interview                     │
│  ? Generate structured work plan                        │
│  ? Review plan for gaps                                 │
└─────────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────┐
│  ORCHESTRATION LAYER (Atlas - The Conductor)           │
│  ? Read plan, delegate tasks                            │
│  ? Accumulate wisdom across tasks                       │
│  ? Verify results independently                         │
│  ? NEVER write code directly — only delegate            │
└─────────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────┐
│  EXECUTION LAYER (Sub-agents via sessions_spawn)       │
│  ? Focused task execution                               │
│  ? Return results + learnings                           │
│  ? Isolated context per task                            │
└─────────────────────────────────────────────────────────┘

Activation

Explicit Triggers

• "use autonomous-skill-orchestrator"
• "activate autonomous-skill-orchestrator"
• "start autonomous orchestration"
• "ulw" or "ultrawork" (magic keyword mode)

Magic Word: ultrawork / ulw

Include ultrawork or ulw in any prompt to activate full orchestration mode automatically. The agent figures out the rest — parallel agents, background tasks, deep exploration, and relentless execution until completion.

Phase 1: Planning (Prometheus Mode)

Step 1.1: Interview

Before planning, gather clarity through brief interview:

Ask only what's needed:

• What's the core objective?
• What are the boundaries (what's NOT in scope)?
• Any constraints or preferences?
• How do we know when it's done?

Interview Style by Intent:

Step 1.2: Plan Generation

After interview, generate structured plan:

## Work Plan: [Title]

### Objective
[One sentence, frozen intent]

### Tasks
- [ ] Task 1: [Description]
  - Acceptance: [How to verify completion]
  - References: [Files, docs, skills needed]
  - Category: [quick|general|deep|creative]
  
- [ ] Task 2: ...

### Guardrails
- MUST: [Required constraints]
- MUST NOT: [Forbidden actions]

### Verification
[How to verify overall completion]

Step 1.3: Plan Review (Self-Momus)

Before execution, validate:

• Each task has clear acceptance criteria
• References are concrete (not vague)
• No scope creep beyond objective
• Dependencies between tasks are explicit
• Guardrails are actionable

If any check fails, refine plan before proceeding.

Phase 2: Orchestration (Atlas Mode)

Conductor Rules

The orchestrator:

• ? CAN read files to understand context
• ? CAN run commands to verify results
• ? CAN search patterns with grep/glob
• ? CAN spawn sub-agents for work

The orchestrator:

• ? MUST NOT write/edit code directly
• ? MUST NOT trust sub-agent claims blindly
• ? MUST NOT skip verification

Step 2.1: Task Delegation

Use sessions_spawn with category-appropriate configuration:

Delegation Template:

sessions_spawn(
  label: "task-{n}-{short-desc}",
  task: """
  ## Task
  {exact task from plan}
  
  ## Expected Outcome
  {acceptance criteria}
  
  ## Context
  {accumulated wisdom from previous tasks}
  
  ## Constraints
  - MUST: {guardrails}
  - MUST NOT: {forbidden actions}
  
  ## References
  {relevant files, docs}
  """,
  runTimeoutSeconds: {based on category}
)

Step 2.2: Parallel Execution

Identify independent tasks (no file conflicts, no dependencies) and spawn them simultaneously:

# Tasks 2, 3, 4 have no dependencies
sessions_spawn(label="task-2", task="...")
sessions_spawn(label="task-3", task="...")
sessions_spawn(label="task-4", task="...")
# All run in parallel

Step 2.3: Wisdom Accumulation

After each task completion, extract and record:

## Wisdom Log

### Conventions Discovered
- [Pattern found in codebase]

### Successful Approaches
- [What worked]

### Gotchas
- [Pitfalls to avoid]

### Commands Used
- [Useful commands for similar tasks]

Store in: memory/orchestrator-wisdom.md (append-only during session)

Pass accumulated wisdom to ALL subsequent sub-agents.

Step 2.4: Independent Verification

NEVER trust sub-agent claims. After each task:

1. Read actual changed files
2. Run tests/linting if applicable
3. Verify acceptance criteria independently
4. Cross-reference with plan requirements

If verification fails:

• Log the failure in wisdom
• Re-delegate with failure context
• Max 2 retries per task, then escalate to user

Phase 3: Completion

Step 3.1: Final Verification

• All tasks marked complete
• All acceptance criteria verified
• No unresolved issues in wisdom log

Step 3.2: Summary Report

## Orchestration Complete

### Completed Tasks
- [x] Task 1: {summary}
- [x] Task 2: {summary}

### Learnings
{key wisdom accumulated}

### Files Changed
{list of modified files}

### Next Steps (if any)
{recommendations}

Safety Guardrails

Halt Conditions (Immediate Stop)

• User issues explicit stop command
• Irreversible destructive action detected
• Scope expansion beyond frozen intent
• 3+ consecutive task failures
• Sub-agent attempts to spawn further sub-agents (no recursion)

Risk Classification

Forbidden Actions

• Creating new autonomous orchestrators
• Modifying this skill file
• Accessing credentials without explicit need
• External API calls not in original scope
• Recursive spawning (sub-agents spawning sub-agents)

Stop Commands

User can stop at any time with:

• "stop"
• "halt"
• "cancel orchestration"
• "abort"

On stop: immediately terminate all spawned sessions, output summary of completed work, await new instructions.

Memory Integration

During Orchestration

• Append to memory/orchestrator-wisdom.md for learnings
• Reference existing memory files for context

After Orchestration

• Update daily memory with orchestration summary
• Persist significant learnings to MEMORY.md if valuable

Example Usage

Simple (magic word):

ulw refactor the authentication module to use JWT

Explicit activation:

activate autonomous-skill-orchestrator

Build a REST API with user registration, login, and profile endpoints

With constraints:

use autonomous-skill-orchestrator
- Build payment integration with Stripe
- MUST: Use existing database patterns
- MUST NOT: Store card numbers locally
- Deadline: Complete core flow only