功能描述

Multi-agent orchestration with 5 proven patterns - Work Crew, Supervisor, Pipeline, Council, and Auto-Routing

使用说明 (SKILL.md)

agent-orchestrator

Name: Agent Orchestrator
Author: variable190

Multi-agent orchestration for OpenClaw. Implements 5 proven patterns for coordinating multiple AI agents: Work Crew, Supervisor, Pipeline, Expert Council, and Auto-Routing.

USE WHEN:

A task can be parallelized for speed or redundancy (Work Crew)
Complex tasks need dynamic planning and delegation (Supervisor)
Work follows a predictable sequence of stages (Pipeline)
Cross-domain input is needed from multiple specialists (Expert Council)
Mixed task types need automatic routing to appropriate specialists (Auto-Routing)
Research tasks require breadth-first exploration of multiple angles
High-stakes decisions need confidence through multiple perspectives

DON'T USE WHEN:

Simple tasks that fit in one agent's context window (use main session instead)
Sequential tasks with no parallelization opportunity (use regular tool calls)
One-shot deterministic tasks (use single agent)
Tasks requiring real-time inter-agent conversation (this uses async spawning)
Tasks where 15x token cost cannot be justified
Quick/simple tasks where coordination overhead exceeds benefit

Outputs:

Aggregated results from multiple parallel agents
Synthesized consensus recommendations
Routing decisions to appropriate specialists
Structured output from staged processing

Decision Matrix

Pattern	Use When	Avoid When
crew	Same task from multiple angles, verification, research breadth	Results cannot be easily compared/merged
supervise	Dynamic decomposition needed, complex planning	Fixed workflow, simple delegation
pipeline	Well-defined sequential stages, content creation	Path needs runtime adaptation
council	Cross-domain expertise, risk assessment, policy review	Single-domain task, need fast consensus
route	Mixed workload types, automatic classification	Task type is already known

Auto-Routing Pattern

The route command analyzes tasks and automatically classifies them by type, then routes to the appropriate specialist:

# Basic routing
claw agent-orchestrator route --task "Write Python parser"

# With custom specialist pool
claw agent-orchestrator route \
  --task "Analyze data and create report" \
  --specialists "analyst,data,writer"

# Force specific specialist
claw agent-orchestrator route \
  --task "Something complex" \
  --force coder

Confidence Thresholds

High confidence (>0.85): Auto-route immediately
Good confidence (0.7-0.85): Propose with confirmation option
Moderate confidence (0.5-0.7): Show top alternatives
Low confidence (\x3C0.5): Request clarification

Available specialists: coder, researcher, writer, analyst, planner, reviewer, creative, data, devops, support

Common Workflows

# Parallel research with consensus
claw agent-orchestrator crew \
  --task "Research Bitcoin Lightning 2026 adoption" \
  --agents 4 \
  --perspectives technical,business,security,competitors \
  --converge consensus

# Best-of redundancy for critical analysis
claw agent-orchestrator crew \
  --task "Audit this smart contract for vulnerabilities" \
  --agents 3 \
  --converge best-of

# Supervisor-managed code review
claw agent-orchestrator supervise \
  --task "Refactor authentication module" \
  --workers coder,reviewer,tester \
  --strategy adaptive

# Staged content pipeline
claw agent-orchestrator pipeline \
  --stages research,draft,review,finalize \
  --input "topic: AI agent adoption trends"

# Expert council for decision
claw agent-orchestrator council \
  --question "Should we publish this blog post about unreleased features?" \
  --experts skeptic,ethicist,strategist \
  --converge consensus \
  --rounds 2

# Auto-route mixed tasks
claw agent-orchestrator route \
  --task "Write Python function to analyze CSV data" \
  --specialists coder,researcher,writer,analyst

# Force route to specific specialist
claw agent-orchestrator route \
  --task "Debug authentication error" \
  --force coder \
  --confidence-threshold 0.9

# Route and output as JSON for scripting
claw agent-orchestrator route \
  --task $TASK \
  --format json \
  --specialists "coder,data,analyst"

Negative Examples

DON'T: Use crew for simple single-answer questions

# WRONG: Wasteful for simple facts
claw agent-orchestrator crew --task "What is 2+2?" --agents 3

# RIGHT: Use main session directly
What is 2+2?

DON'T: Use supervise when pipeline suffices

# WRONG: Over-engineering fixed workflows
claw agent-orchestrator supervise --task "Draft, edit, publish"

# RIGHT: Use pipeline for fixed sequences
claw agent-orchestrator pipeline --stages draft,edit,publish

DON'T: Route when task type is obvious

# WRONG: Unnecessary classification overhead
claw agent-orchestrator route --task "Write Python code"

# RIGHT: Direct to appropriate specialist
claw agent-orchestrator crew --pattern code --task "Write Python code"

DON'T: Use multi-agent for very small context tasks

# WRONG: Coordination overhead exceeds value
claw agent-orchestrator crew --task "Fix typo" --agents 2

# RIGHT: Single agent or direct edit
edit file.py "typo" "correct"

Token Cost Warning

Multi-agent patterns use approximately 15x more tokens than single-agent interactions. Use only for high-value tasks where quality improvement justifies the cost. See Anthropic research: token usage explains 80% of performance variance in complex tasks.

Dependencies

Python 3.8+
OpenClaw sessions_spawn capability
OpenClaw sessions_list capability
OpenClaw sessions_history capability

Files

__main__.py - CLI entry point
crew.py - Work Crew pattern implementation
supervise.py - Supervisor pattern (Phase 2)
council.py - Expert Council pattern (Phase 2)
pipeline.py - Pipeline pattern (Phase 2)
route.py - Auto-Routing pattern (Phase 2)
utils.py - Shared utilities for session management

Status

MVP: Work Crew pattern implemented
Phase 2: 100% Complete
- Supervisor pattern implemented - dynamic task decomposition and worker delegation
- Pipeline pattern implemented - sequential staged processing with validation gates
- Council pattern implemented - multi-expert deliberation with convergence methods
- Route pattern implemented - intelligent task classification and specialist routing

References

Anthropic Multi-Agent Research System
LangGraph Supervisor Pattern
CrewAI Framework
AutoGen Conversational Agents

安全使用建议

Summary of what to check before installing: 1) Source and provenance: The skill's homepage is missing and the owner is an opaque ID. If you cannot verify the author (GitHub repo, published package, or community trust), treat it as untrusted until you can inspect the code. 2) Review sanitization and spawn logic: Open utils.py (and any functions named sanitize_untrusted_task, spawn_agent, SessionManager.spawn_session). Confirm that these functions: - Do not forward raw user input into sub-agents without robust sanitization or a safety preamble. - Do not include hidden network endpoints or secrets in sub-agent tasks. - Use an allowlist for OpenClaw subcommands (sessions_spawn, sessions_list, sessions_history) as claimed. 3) Verify persistence behavior: Inspect the state-file writing code to ensure it redacts keys and does not persist full task contents or outputs containing secrets. If you will run in production, keep ORCHESTRATOR_SAFE_STATE=1 and ensure state files are stored in a controlled directory with proper file permissions. 4) Test in a sandbox: Run the skill in an isolated environment and exercise edge cases (malicious-looking inputs) to confirm the sanitization actually prevents prompt injection in spawned sessions. 5) Search the code for network I/O: Grep for requests, urllib, socket, http, or hardcoded URLs/IPs. The docs claim no external network calls, but verify this in the code to be safe. 6) Check for scanner-evasion indicators: The changelog note about rewording safety preambles to reduce false positives is unusual; confirm it did not remove protections. Prefer the explicit sanitization code and tests (tests/security_test_plan.md) over wording in docs. 7) If you need stronger guarantees: require a code review by a trusted developer or only use in non-sensitive contexts. Do not pass secrets or credentials into tasks; run initial evaluations with low-sensitivity inputs. If you want, I can: (A) locate and summarize the sanitize_untrusted_task / spawn_agent code for you, (B) search the repository for network calls and file write paths, or (C) produce a short checklist of concrete grep commands to run locally to validate the points above.

功能分析

Type: OpenClaw Skill Name: agent-orchestrator-molter-102 Version: 1.0.2 The OpenClaw Agent Orchestrator skill bundle is classified as benign. It demonstrates a strong and proactive approach to security, particularly against prompt injection and unsafe execution. Key indicators include comprehensive input sanitization (`sanitize_untrusted_task` in `utils.py`), a robust `SECURITY_PREAMBLE` prepended to all sub-agent tasks, and a strict allowlist for `openclaw` CLI subcommands (`sessions_spawn`, `sessions_list`, `sessions_history`) executed via `subprocess.run` (without `shell=True`). Additionally, sensitive data is redacted before persistence to local state files (`redact_sensitive_text` in `utils.py`), and a detailed `SECURITY.md` and `tests/security_test_plan.md` confirm a commitment to security best practices and testing.

能力评估

✓ Purpose & Capability

Name/description describe multi-agent orchestration and the code files implement crew, supervise, pipeline, council, and routing patterns that align with that purpose. Declared dependencies (OpenClaw session capabilities) match the implementation. The skill does not request unrelated credentials or external binaries.

⚠ Instruction Scope

SKILL.md instructs use of the local 'claw' CLI and shows commands that spawn sessions; that matches the code. However, the pre-scan found a prompt-injection pattern ('ignore-previous-instructions') inside SKILL.md. The docs also mention sanitization and safety preambles and a recent changelog entry saying safety text was reworded to reduce scanner false positives — this could be benign maintenance, but it also suggests the author adjusted wording to influence scanners. You should inspect the sanitization code paths (sanitize_untrusted_task and safety preamble logic) to confirm they actually remove or neutralize injection payloads rather than rely on wording alone.

✓ Install Mechanism

There is no external install spec (no network downloads or package installs). The skill ships as Python code in the package; that is a low install surface. No external URLs or extract/install steps are present in the listed metadata.

✓ Credentials

The skill requests no environment variables, no credentials, and no privileged config paths. It relies on OpenClaw session capabilities, which is consistent with its purpose. The README/SECURITY.md explicitly warn not to pass secrets in task text.

ℹ Persistence & Privilege

The skill writes local state files by default (e.g., .pipeline_state.json, .router_state.json, .council_state.json). The package claims a safe-state default (ORCHESTRATOR_SAFE_STATE=1) and redaction of keys in persisted previews, which is reasonable for history/state, but you should verify that redaction is effective and that state files do not contain full prompts, outputs, or secrets. always:false (not force-installed) and normal autonomous invocation are defaults and acceptable here.

版本历史

v1.0.2

Stable 1.0.2 line (scanner-preferred) with canonical description wording.

元数据

Slug agent-orchestrator-molter-102

版本 1.0.2

许可证 —

累计安装 1

当前安装数 1

历史版本数 1

常见问题