🎼 Orche — Multi-Phase Orchestration Engine#

A multi-agent orchestration engine that executes complex tasks in Query → Plan (Debate) → Execute → Verify — 4 phases. A sub-agent panel debates, critiques, executes, and verifies, while the watchdog monitors the entire process.

---

📌 Table of Contents#

1. Why Orche?
2. Comparison with Existing Orchestration Skills
3. Quick Start — First Orchestration in 5 Minutes
4. Phase Overview
5. Phase 0: Query
6. Phase 1: Planning
7. Phase 2: Execution
8. Phase 3: Verification
9. State Management
10. Directory Structure
11. Harness Rules (Safety Mechanisms)
12. Watchdog Integration
13. Hallucination Checklist (14 Items)
14. Cost Management
15. Exception Handling Summary
16. User Intervention Points
17. Abort Procedure
18. Session Disconnection Recovery
19. Demo Scenarios
20. Production Run Records
21. hallucination-guard Integration
22. Advanced Configuration
23. FAQ
24. Changelog

---

🎯 Why Orche?#

Problem: Limitations of Existing Multi-Agent Execution#

When complex tasks are delegated to AI agents, the following problems arise:

ProblemSymptomResultHallucinationUses non-existent APIs/librariesNon-executable codeExecution without planningStarts writing code immediatelyDirection change costs explodeNo verificationDeliverables "look plausible"Don't actually workLinear-only progressionKeeps going forward even on failureRoot cause unresolvedCost explosionIndiscriminate agent deploymentBudget exhaustion

Solution: Orche's 4-Phase Engine#

text

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   Phase 0        Phase 1         Phase 2        Phase 3     │
│   ┌──────┐      ┌──────┐       ┌──────┐      ┌──────┐     │
│   │Query │─G0─▶│ Plan  │──G1─▶│Execute│─G2─▶│Verify│     │
│   │      │      │(Debate)│      │(Parall)│      │      │     │
│   └──────┘      └──────┘       └──────┘      └──┬───┘     │
│       │                             ▲            │         │
│       │                             │          fail?       │
│       │                             └──── YES ◀──┘         │
│       │                                                     │
│       └── Watchdog monitors the entire process ───────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Key Differentiators:

• ✅ Phase Gates: Explicit condition fulfillment required at each phase transition
• ✅ Critic Debate: Advocate vs Critic debate improves plan quality
• ✅ 14-Item Hallucination Check: Fact, consistency, completeness, and hallucination pattern verification
• ✅ Auto Regression: Automatically returns to Phase 2 on verification failure
• ✅ Watchdog Integration: Monitors entire process, auto-detects deadlocks/loss/budget overruns
• ✅ Cost Management: 4-tier budget alerts + concurrent agent limit

---

📊 Comparison with Existing Orchestration Skills#

Featuredispatching-parallel-agents``parallel-agent-management``executing-plansorcheParallel execution✅✅❌ (sequential)✅Pre-query phase❌❌❌✅ Phase 0Debate/discussion❌❌❌✅ Includes CriticPhase gates❌❌✅ (checkpoints)✅ 4 gatesHallucination check❌❌❌✅ 14 itemsAuto regression on verification failure❌❌❌✅ Up to 3 retriesWatchdog integration❌❌❌✅Cost management❌❌❌✅ 4-tier budgetSession disconnection recovery❌❌❌✅ State file basedBest forSimple parallel tasksCodebase splittingSequential plan executionComplex multi-step projects

When to Use Orche?#

✅ Orche is appropriate when:

• Complex tasks requiring 3+ different roles
• Tasks where output accuracy matters (research, analysis, code design)
• Tasks where hallucination is critical
• Tasks with interdependent deliverables

❌ Other skills are better when:

• Simple 2-3 independent tasks in parallel → dispatching-parallel-agents
• File-by-file codebase splitting → parallel-agent-management
• Sequential execution with an already-confirmed plan → executing-plans

---

🚀 Quick Start — First Orchestration in 5 Minutes#

Step 1: Install the Skill (30 Seconds)#

Place the skill file in the OpenClaw skills directory:

bash

# Copy to skills directory
mkdir -p ~/.agents/skills/orche
cp SKILL.md ~/.agents/skills/orche/SKILL.md

Step 2: Trigger (10 Seconds)#

Enter the /orche command in chat and describe your task:

text

/orche "Write a market analysis report on Korean AI startups"

Or in natural language:

text

Orchestrate this project systematically

Step 3: Phase 0 — Answer the Queries (2 Minutes)#

Orche will ask 3~10 questions. Answer clearly:

text

🎼 /orche started — Phase 0: Query

📋 Questions to clarify requirements:

1. 📐 Scope: All AI fields? Specific segment (LLM, robotics, etc.)?
2. 🎯 Priority: Market size vs competitive analysis vs investment trends?
3. 📏 Success criteria: Report length? Number of data sources?
4. 🔧 Technical constraints: Specific data sources needed?
5. ⏰ Deadline: Is there a due date?

Step 4: Auto-Progress (Remaining)#

Once you answer, Orche automatically:

• Phase 1: Builds plan through expert + Critic debate
• Phase 2: Sub-agents research and write in parallel
• Phase 3: Verification team runs hallucination check + cross-validation

Step 5: Receive Results#

text

🎼 /orche Completion Report

📋 Task: orche-1711432800
⏱️ Total duration: 23 minutes
📊 By phase: Query 3m → Plan 5m → Execute 10m → Verify 5m
🤖 Agents deployed: 11
✅ Tasks completed: 5/5

📁 Deliverables:
- workspace/orche-1711432800/requirements.md
- workspace/orche-1711432800/final-plan.md
- workspace/orche-1711432800/tasks/
- workspace/orche-1711432800/verification/final-verdict.md

---

🔄 Phase Overview#

text

Phase 0: Query    — Clarify requirements (3~10 questions)
Phase 1: Plan     — 3~7 sub-agents debate → finalize plan
Phase 2: Execute  — Split into tasks → 3~8 sub-agents execute in parallel
Phase 3: Verify   — 3~5 verifiers deployed → regress to Phase 2 if issues found

Phase Gate System#

Each phase transition requires gate conditions to be met before proceeding. Automatic blocking on non-compliance.

GateTransitionKey ConditionsG0Phase 0 → 1Requirements structured + ambiguous expressions removed + user approvalG1Phase 1 → 2final-plan.md created + hallucination check passed + no circular dependenciesG2Phase 2 → 3All tasks completed + deliverables exist + no zombie agentsVerificationPhase 3 → Done14-item hallucination check passed + all required deliverables present

On gate failure:

• G0 not passed → Phase 1 entry blocked. Re-confirmation requested from user.
• G1 not passed → Phase 2 entry blocked. Plan re-debate forced.
• G2 not passed → Phase 3 entry blocked. Missing tasks re-executed.
• Verification fail → Auto regression to Phase 2 (up to 3 times).

---

Phase 0: Query#

Purpose#

Remove ambiguity from user instructions and specify them to an actionable level.

Procedure#

1. Analyze original request → identify missing/ambiguous areas
2. Generate 3~10 questions (at least 1 from each of 6 categories below)
3. Collect user responses → finalize requirements document (max 2 additional rounds)
4. On user approval → save requirements.md

Question Categories#

CategoryExampleScopeWhat's in scope? What should be excluded?Technical constraintsLanguage/framework/environment limitations?PriorityWhat matters most? (speed/quality/cost)Success criteriaHow to judge completion? Deliverables?DependenciesExternal systems/APIs/data?RiskImpact of failure? Rollback needed?

Gate G0: Phase 0 → 1 Transition Conditions#

• ✅ Requirements are structured (goal, constraints, deliverables specified)
• ✅ Ambiguous expressions removed ("appropriately", "etc." type expressions eliminated)
• ✅ Feasibility assessment complete (required tools/access confirmed)
• ✅ User confirmation received

Phase 0: When Deemed Infeasible#

If G0 feasibility check determines the task is impossible:

1. Report specific reasons to user
2. Suggest alternatives (if possible)
3. Await user decision → modification instructions or termination
4. On termination → orche-state.json status → "rejected"

---

Phase 1: Planning#

Debate Panel Composition (3~7 members)#

RoleResponsibilityDomain Expert (1~2)Draft plan based on domain expertiseAdvocateStrengthen plan merits, argue feasibilityCriticPoint out weaknesses/risks/gaps + hallucination checkModeratorSynthesize debate, build consensus, write final plan

Sub-Agent Spawning#

text

sessions_spawn:
  task: "<role-specific prompt>"
  label: "orche-<role>-<taskId>"
  model: "anthropic/claude-sonnet-4-6"  # Default (use opus for high complexity)
  mode: "run"

Model Selection Guide:

• Planning/debate: sonnet (cost-efficient)
• Complex domain experts: opus (when deep reasoning needed)
• Simple execution tasks: sonnet or haiku (fast processing)

Debate Protocol (Round-based, File-async)#

Round 1:

1. Expert agents → spawn in parallel → each writes a proposal
2. Advocate → analyze strengths of drafts
3. Critic → point out weaknesses + hallucination check:
   • References to non-existent APIs/libraries?
   • Unrealistic performance/time estimates?
   • Logical contradictions?
   • Missing dependencies/prerequisites?
4. Moderator → synthesize → write final-plan.md

If unresolved issues remain → Round 2 (up to 3 rounds max).

Gate G1: Phase 1 → 2 Transition Conditions#

• ✅ final-plan.md created
• ✅ Task list + dependencies + success criteria specified
• ✅ Hallucination check passed
• ✅ No circular dependencies
• ✅ Rollback strategy defined for each task

---

Phase 2: Execution#

Task Splitting#

Split from final-plan.md into independently executable task units:

json

{
  "id": "task-1",
  "title": "...",
  "description": "...",
  "dependencies": [],
  "assignedAgent": null,
  "status": "pending",
  "output": null
}

Task Status Flow: pending → running → completed / failed

Dependency-Based Scheduling#

• Independent tasks → spawn in parallel immediately
• Dependent tasks → spawn after predecessor completion
• Max concurrent agents: 8 (cost explosion prevention: 3 concurrent recommended)

Required Inclusions in Execution Agent Prompts#

All execution agent prompts must include the following:

1. Overall plan summary (brief)
2. Detailed task specification
3. Predecessor task deliverables (file paths)
4. Deliverable save path
5. Success criteria
6. Harness rules (see below)

Immediate Checks on Task Completion#

• Deliverable file exists?
• Not empty?
• Success criteria met?
• No obvious hallucinations?
• On failure → retry that task only (max 2 times). 2 failures → alert user.

Gate G2: Phase 2 → 3 Transition Conditions#

• ✅ All tasks completed or skipped_with_reason
• ✅ All deliverable files exist + non-empty
• ✅ No zombie agents/sessions
• ✅ No critical errors

---

Phase 3: Verification#

Verification Team Composition (3~5 members)#

RoleResponsibilityCompleteness VerifierAll tasks executed, nothing missingAccuracy VerifierDeliverables match task spec + success criteriaHallucination VerifierDetect factual errors, logical contradictions, non-existent referencesIntegration VerifierCross-deliverable consistency, interface compatibilityFinal Reviewer (optional)Final review against original requirements

Verification Result Handling#

ResultActionAll PASSPhase 3 complete → normal terminationHIGH issueRegress to Phase 2 (re-execute affected tasks only)MED issueReport to user, confirm re-executionLOW issueRecord in report, proceed

Regression Conditions (Phase 3 → Phase 2)#

Automatic regression to Phase 2 if any of the following apply:

• hallucination_score >= 2 (2+ failures in 14-item check)
• Required deliverable missing/corrupted
• Test failure rate > 30%
• User-mandatory conditions unmet
• Mutual contradiction between deliverables

Regression Limits#

• retryCount maximum 3 times
• Same reason repeated 2 times → escalate to user
• Token budget 80% consumed → escalate to user

---

📦 State Management#

All orchestration state is recorded in workspace/orche-state.json. The watchdog and each phase share this file to track progress.

json

{
  "taskId": "orche-<timestamp>",
  "phase": 0,
  "status": "active",
  "startedAt": "<ISO>",
  "phaseStartedAt": "<ISO>",
  "requirements": null,
  "plan": null,
  "tasks": [],
  "agents": [],
  "watchdog": {
    "enabled": true,
    "lastCheck": null
  },
  "retryCount": 0,
  "maxRetries": 3,
  "tokenBudget": {
    "total": 500000,
    "used": 0,
    "currency": "tokens"
  },
  "errors": []
}

State Field Descriptions#

FieldTypeDescriptiontaskIdstringUnique identifier ( orche-<unix_timestamp>)phasenumberCurrent phase (0~3)statusstringactive / completed / aborted / rejected``requirementsobjectRequirements finalized in Phase 0planobjectPlan finalized in Phase 1tasksarrayPhase 2 task list + statusagentsarrayCurrently active sub-agent session key listretryCountnumberPhase 3 → 2 regression counttokenBudgetobjectToken budget managementerrorsarrayError log

---

📁 Directory Structure#

Each orchestration creates an independent working directory:

text

workspace/orche-<taskId>/
├── requirements.md              ← Phase 0 deliverable
├── round-1/                     ← Phase 1 debate records
│   ├── expert-1-proposal.md     ← Expert proposal
│   ├── expert-2-proposal.md     ← (if applicable)
│   ├── advocate-review.md       ← Advocate review
│   ├── critic-review.md         ← Critic review
│   └── moderator-summary.md     ← Moderator synthesis
├── round-2/                     ← (2nd round debate if needed)
├── final-plan.md                ← Phase 1 final plan
├── tasks/                       ← Phase 2 deliverables
│   ├── task-1/
│   │   └── output.md
│   ├── task-2/
│   │   └── output.md
│   └── ...
└── verification/                ← Phase 3 verification results
    ├── completeness-report.md   ← Completeness verification
    ├── accuracy-report.md       ← Accuracy verification
    ├── hallucination-report.md  ← Hallucination verification
    ├── integration-report.md    ← Integration verification
    └── final-verdict.md         ← Final verdict

---

🛡️ Harness Rules (Safety Mechanisms)#

On Orche Start — Execute Immediately#

1. Watchdog registration: Register task in watchdog.md (when using OpenClaw watchdog)
2. State initialization: Create orche-state.json
3. Report start to user

Phase Gate Harness (Mandatory Check Before Each Phase Transition)#

text

G0 not passed → Phase 1 entry blocked. Re-confirmation requested from user.
G1 not passed → Phase 2 entry blocked. Plan re-debate forced.
G2 not passed → Phase 3 entry blocked. Missing tasks re-executed.
Verification fail → Auto regression to Phase 2 (retryCount < 3).

Sub-Agent Harness#

Rules that must be included in every sub-agent spawn prompt:

text

[Harness Rules]
1. You must save results to the designated file path upon completion
2. Mark uncertain facts with "needs verification:" — no fabrication
3. Do not use non-existent APIs/libraries
4. On task failure, record failure reason in output file and terminate

These rules are injected into all sub-agents. This ensures:

• File-based communication is guaranteed (Rule 1)
• Hallucinations are caught early (Rules 2, 3)
• Failure causes are traceable (Rule 4)

Completion Harness#

text

On Phase 3 completion, you must:
1. Set orche-state.json status → "completed"
2. Mark task [x] in watchdog.md (if using watchdog)
3. Send final report to user

---

🔍 Watchdog Integration#

Orche integrates with OpenClaw's watchdog system to monitor the entire process.

What the Watchdog Does#

Detection ItemAuto ResponseAgent 15min+ no change (hang)kill + re-spawnEmpty deliverable (file size 0)Retry with reinforced promptAll agents lost (deadlock)Immediate user notificationToken budget 80% reachedUser warning

Watchdog Registration Method#

Register the task in watchdog.md at Orche start:

markdown

- [ ] orche <taskId> — Phase 0 (Query)
  session_keys: agent:main:subagent:xxxx
  state_file: workspace/orche-state.json
  evidence_paths:
    - workspace/orche-<taskId>/requirements.md
    - workspace/orche-<taskId>/final-plan.md
  done_when:
    - orche-state.json status == "completed"

Watchdog Design Principles#

These principles reflect lessons learned in production.

• ✅ Read only watchdog.md → query sessions_list using session_keys
• ✅ Do not judge failure by "no session" alone — if deliverables/state files exist, assume progress/completion first
• ✅ Judge normal termination only when: no tasks + 0 active sessions
• ⚠️ If anything is active, report status and wait

No watchdog in your environment? Orche works without a watchdog. The watchdog is an additional safety net; phase gates and harness rules function as core safety mechanisms without it.

---

✅ Hallucination Checklist (14 Items)#

Used by Phase 1's Critic and Phase 3's verification team.

Factual Verification#

IDItemVerification MethodH-1File path existenceVerify with stat() or lsH-2Command existenceVerify with which or command -vH-3URL validityVerify with HTTP request (optional)H-4Code syntax validityGrammar check with linter/parserH-5Numerical data cross-verificationConfirm with 2+ sources

Consistency#

IDItemVerification MethodH-6No self-contradictionDetect conflicting statements within documentH-7Plan-result alignment1:1 mapping verificationH-8Terminology consistencySame term for same concept

Completeness#

IDItemVerification MethodH-9No remaining TODO/FIXMEgrep -r "TODO|FIXME"H-10No placeholdersDetect [INSERT], TBD, ...H-11All deliverables existCross-check deliverable list against requirements

Hallucination Patterns#

IDItemVerification MethodH-12No fictional library/API referencesVerify existence on npm/pip/crates.io etc.H-13No unsourced statisticsVerify source citation or "needs verification:" labelH-14No overconfident expressionsDetect "always", "never", "100%" type claims

Judgment Criteria#

text

0~1 failures  → PASS ✅
2~3 failures  → WARNING ⚠️ (MED — user judgment)
4+ failures   → FAIL ❌ (HIGH — auto regression)

---

💰 Cost Management#

Orche is a multi-agent system, so cost management is essential.

Budget Tiers#

TierRatioAction🟢 Normal< 50%Normal operation🟡 Caution5080%Limit concurrent agents, prefer sonnet🔴 Warning8095%Stop new spawns, complete in-progress tasks only⛔ Exceeded> 95%Full stop, request user judgment

Cost Saving Tips#

1. Actively leverage model selection:

   • Simple execution: haiku (lowest cost)
   • Planning/debate/general execution: sonnet (best value)
   • Complex reasoning: opus (only when needed)

2. Limit concurrent agents to 3 (default). 8 is the maximum; typically 3~4 is sufficient.

3. Set token budget according to task scale:

Task ScaleRecommended Budget (tokens)Expected AgentsEstimated Cost (Claude Sonnet)Small (simple research)200,00068$0.6Medium (code refactoring)500,0001015$1.5Large (market analysis report)1,000,0001520$3.0

Note: Costs above are estimates based on Claude Sonnet. Actual costs vary by model, prompt length, and retry count.

1. Use Phase 0 well. Clear scope definition during initial queries reduces unnecessary tasks and cuts costs.

Token Budget Adjustment#

Adjust the budget by modifying tokenBudget.total in orche-state.json:

json

{
  "tokenBudget": {
    "total": 1000000,
    "used": 0
  }
}

---

🚨 Exception Handling Summary#

ExceptionDetection MethodAuto ResponseUser NotificationAgent hangWatchdog 15min no changekill + re-spawnOn 2 consecutive occurrencesEmpty deliverableFile size 0Retry with reinforced promptOn 2 failuresAPI error (429/500)HTTP statusRetry after 30sOn 3 failuresHallucination detectedCritic/verification teamRegenerate affected portionOn HIGH severityTotal deadlockAll agents lost—ImmediatelyContext exceededError messageRetry with reduced inputOn failuremaxRetries exceededCounter check—Immediate judgment requestToken budget exceededused/total ratioModel downgradeAt 80%

Error Logging#

All errors are recorded in orche-state.json's errors array:

json

{
  "errors": [
    {
      "timestamp": "2026-03-26T10:30:00Z",
      "phase": 2,
      "taskId": "task-3",
      "type": "AGENT_HANG",
      "message": "Agent orche-exec-task-3 unresponsive for 15+ minutes",
      "action": "kill + re-spawn"
    }
  ]
}

---

🙋 User Intervention Points#

TimingRequired?ContentPhase 0 complete✅ RequiredApprove requirementsPhase 1 completeOptionalReview plan (default: auto-proceed)Phase 2 failure✅ RequiredJudgment after 2 retry failuresPhase 3 MED issue✅ RequiredDecide on re-executionPhase 3 completeNotificationFinal results report

Auto-Proceed Mode#

Auto-proceeding from Phase 1 to Phase 2 is the default behavior. If you want to review the plan directly, specify "I want approval at each step" during Phase 0 queries.

---

🛑 Abort Procedure#

When the user requests task cancellation:

1. Terminate all active sub-agents (session kill)
2. Remove task from watchdog (if in use)
3. Set orche-state.json status → "aborted"
4. Report abort to user (including list of completed tasks)

text

🎼 /orche Abort Report

📋 Task: orche-1711432800
🛑 Abort reason: User request
✅ Completed tasks: 3/7
📁 Completed deliverables:
- workspace/orche-1711432800/tasks/task-1/output.md
- workspace/orche-1711432800/tasks/task-2/output.md
- workspace/orche-1711432800/tasks/task-3/output.md

---

🔄 Session Disconnection Recovery#

Problem#

If the main session disconnects mid-process, the orchestration stops.

Recovery Mechanism#

1. orche-state.json is the recovery key.
   • Phase/task progress is recorded in the file, so after session restart, the state file can be read to resume.
2. State updated immediately on each task completion:
   • completedAt recorded in orche-state.json upon receiving each sub-agent result
3. Watchdog detects hangs: (when using watchdog)
   • If task exists in watchdog.md and main session is unresponsive for 20+ minutes in sessions_list, reports to user
4. Manual recovery:
   • User instructs orche to resume → reads orche-state.json → continues from incomplete tasks

Recovery Command Example#

text

/orche resume

This command reads orche-state.json and resumes execution from the last completed phase/task.

---

🎮 Demo Scenarios#

Scenario 1: Research Report Writing#

User Input:

text

/orche "Write a 2025 Korean GenAI market analysis report.
Must include market size, key players, investment trends, and regulatory landscape."

Phase 0 — Query (2~3 min):

text

🎼 Phase 0: Query

1. 📐 Scope: All GenAI? (LLM, image generation, code assistants, etc.)
2. 🎯 Depth: Individual company analysis? Or market overview level?
3. 📊 Data: Public data only? Paid research sources?
4. 📏 Length: How many pages (A4 equivalent)?
5. 🎨 Format: Markdown? PDF?
6. ⏰ Purpose: Internal report? Investment decision? Blog?

Phase 1 — Planning (5 min):

• Expert A (AI market analyst): Proposes report structure
• Expert B (Korean market specialist): Suggests Korea-specific data sources
• Critic: Points out "Market size estimates need cross-verification from 2+ sources"
• Moderator: Finalizes split into 5 tasks

Phase 2 — Execution (10~15 min):

TaskAgentDeliverableMarket overviewagent-1tasks/task-1/market-overview.mdKey playersagent-2tasks/task-2/key-players.mdInvestment trendsagent-3tasks/task-3/investment-trends.mdRegulatory landscapeagent-4tasks/task-4/regulatory.mdConsolidated reportagent-5tasks/task-5/final-report.md

Phase 3 — Verification (5 min):

• H-5 check: Market size figures cross-verified → 2 sources confirmed ✅
• H-13 check: Investment amounts have cited sources → ✅
• H-11 check: All sections complete → ✅
• Final verdict: PASS ✅

---

Scenario 2: Code Refactoring#

User Input:

text

/orche "Refactor our project's API layer.
Currently Express monolithic — want to separate modules by domain and increase test coverage."

Phase 0 — Query (3 min):

text

🎼 Phase 0: Query

1. 📐 Scope: Entire API? Specific domains only?
2. 🔧 Tech stack: Express + TypeScript? ORM?
3. 📁 Current structure: Source directory path?
4. 🎯 Target structure: Have an example? (NestJS-style? Layered?)
5. ✅ Tests: Current coverage? Test framework?
6. ⚠️ Constraints: Backward compatibility? Zero-downtime deployment?

Phase 1 — Planning (7 min):

• Expert A (Node.js architect): Proposes module separation strategy
• Expert B (Testing specialist): Proposes testing strategy
• Critic: Points out "Need to analyze dependency graph first to ensure no circular dependencies"
• Advocate: Argues "Gradual migration is safer"
• Moderator: Finalizes 6 tasks in order: dependency analysis → module separation → test writing

Phase 2 — Execution (15~20 min):

TaskAgentDeliverableDependency analysisagent-1tasks/task-1/dependency-graph.mdUser module separationagent-2tasks/task-2/user-module/Auth module separationagent-3tasks/task-3/auth-module/Order module separationagent-4tasks/task-4/order-module/Shared utilities cleanupagent-5tasks/task-5/shared/Test writingagent-6tasks/task-6/tests/

Phase 3 — Verification (7 min):

• H-1 check: All file paths exist → ✅
• H-4 check: TypeScript compilation successful → ✅
• H-12 check: No non-existent npm package references → ✅
• H-7 check: Plan-result alignment → Task 5 gap found ⚠️
• 1st regression: Task 5 re-executed → completed
• Final verdict: PASS ✅

---

Scenario 3: Market Analysis#

User Input:

text

/orche "Do a SaaS competitor analysis.
Target Notion, Coda, Slite — compare features, pricing strategy, and market positioning."

Phase 0 — Query (2 min):

text

🎼 Phase 0: Query

1. 📐 Scope: Any additional competitors beyond these 3?
2. 🎯 Analysis depth: Feature-level detail? Strategic level?
3. 📊 Data: Public pricing only? Actual usage experience needed?
4. 📏 Deliverables: Comparison table + strategy report?
5. 🔍 Our product: Is there a reference product to compare against?

Phase 1 — Planning (5 min):

• Expert (SaaS market specialist): Proposes analysis framework (Porter's Five Forces + Feature Matrix)
• Critic: Warns "Pricing should be based on public pages only — no guessing enterprise pricing"
• Moderator: Finalizes 4 tasks

Phase 2 — Execution (10 min):

TaskAgentDeliverableNotion analysisagent-1tasks/task-1/notion-analysis.mdCoda analysisagent-2tasks/task-2/coda-analysis.mdSlite analysisagent-3tasks/task-3/slite-analysis.mdComparative summaryagent-4tasks/task-4/comparison-report.md

Phase 3 — Verification (5 min):

• H-5 check: Pricing data cross-verified → public page basis ✅
• H-13 check: MAU/ARR figures have cited sources → "needs verification:" properly labeled ✅
• H-14 check: "Notion will definitely win" type overconfidence → none found ✅
• Final verdict: PASS ✅

---

📈 Production Run Records#

Below are summaries of actual projects completed with Orche.

Run #1: ClawHub Skill Packaging#

ItemDetailsTaskRepackage internal skills for ClawHub publishingDuration25 minutesAgents deployed12 (planning 4 + execution 5 + verification 3)By phaseQuery 3m → Plan 6m → Execute 10m → Verify 6mRegressions0 (passed first time)NotableCritic flagged "environment-dependent hardcoded cron IDs" → fixed during planning phase

Run #2: Multilingual Documentation Translation + Review#

ItemDetailsTaskTechnical doc translation (Korean/English/Japanese) + terminology unificationDuration35 minutesAgents deployed15 (planning 3 + execution 8 + verification 4)By phaseQuery 2m → Plan 5m → Execute 18m → Verify 10mRegressions1 (H-8 terminology consistency failure → glossary-based retranslation)NotableTerminology inconsistency auto-detected → Phase 2 regression → fixed and passed

Run #3: API Design + Implementation + Testing#

ItemDetailsTaskREST API design → implementation → test code → documentationDuration42 minutesAgents deployed18 (planning 5 + execution 8 + verification 5)By phaseQuery 4m → Plan 8m → Execute 20m → Verify 10mRegressions1 (H-12 non-existent middleware reference → affected task re-executed)NotableCritic debate on "implement auth middleware vs use library" → Moderator decided on verified library

Run Statistics Summary#

text

Total completions: 3
Average duration: 34 minutes
Average agents: 15
First-pass rate: 33% (1/3)
Resolved via auto-regression: 100% (2/2 regressions resolved within 3 retries)
Manual escalations: 0

---

🔗 hallucination-guard Integration#

If the hallucination-guard skill is installed, Orche can leverage it during the verification phase for more precise hallucination detection.

Integration Method#

1. Install hallucination-guard skill: bash

   # Install from ClawHub (needs verification: install command may vary by environment)
   mkdir -p ~/.agents/skills/hallucination-guard
   # Place SKILL.md in that directory
   
   

2. Auto-utilized in Phase 3 verification:

   • When hallucination-guard is installed, Phase 3's hallucination verifier additionally applies that skill's checklist.
   • Particularly improves detection accuracy for "non-existent APIs/libraries" in code-related tasks.

3. Integration Architecture:

text

Phase 3: Verification
├── Completeness Verifier
├── Accuracy Verifier
├── Hallucination Verifier ──── Uses hallucination-guard skill
│   ├── Orche's built-in 14-item check
│   └── + hallucination-guard additional checks (when installed)
├── Integration Verifier
└── Final Reviewer

1. When hallucination-guard is not installed:
   • Orche functions normally with its built-in 14-item checklist alone.
   • hallucination-guard is an optional enhancement tool.

Recommended Combinations#

Task TypeOrche Alone+ hallucination-guardResearch report✅ Sufficient✅✅ Enhanced numerical verificationCode refactoring✅ Sufficient✅✅✅ API existence check essentialMarket analysis✅ Sufficient✅✅ Enhanced statistics source verificationDocument translation✅ Sufficient✅ Minimal difference

---

⚙️ Advanced Configuration#

Adjusting Debate Round Count#

Default is up to 3 rounds. Complex domains may require more rounds. Specify "I want thorough plan debate" during Phase 0 to adjust the round count.

Verification Intensity Adjustment#

IntensityVerifier CountHallucination CheckRecommended Forlight2Essential 5 items onlySimple tasks, time savingsstandard (default)3~4All 14 itemsGeneral tasksthorough514 items + additional cross-verificationHigh-risk tasks

You can specify verification intensity during Phase 0:

text

/orche "Refactor the API. Use thorough verification."

Agent Model Configuration#

Specify different models per phase based on task characteristics:

json

{
  "modelConfig": {
    "planning": "anthropic/claude-sonnet-4-6",
    "execution": "anthropic/claude-sonnet-4-6",
    "verification": "anthropic/claude-sonnet-4-6",
    "complex": "anthropic/claude-opus-4-6"
  }
}

Concurrent Agent Limit#

Default is 3 (maximum 8). Adjust in orche-state.json:

json

{
  "concurrency": {
    "default": 3,
    "max": 8
  }
}

---

❓ FAQ#

Q: Can Phase 0 be skipped?#

A: No. Phase 0 is mandatory. Proceeding with ambiguous requirements causes direction change costs in Phase 2 to grow exponentially. Clear answers in Phase 0 actually reduce total time.

Q: How much does it cost?#

A: Depends on task scale. Small tasks (research report) use approximately 200K tokens (Claude Sonnet $0.6), large tasks (API design + implementation) approximately 1M tokens ($3.0). See the cost management section for budget settings.

Q: What happens if verification keeps failing?#

A: Auto-regression up to 3 times. If all 3 fail, escalated to user for direct judgment. Also escalated if the same reason fails 2 consecutive times.

Q: Can it work without a watchdog?#

A: Yes. The watchdog is an additional safety net; phase gates and harness rules are the core safety mechanisms. Orche functions normally without a watchdog.

Q: Can it be used alongside other orchestration skills?#

A: Orche operates independently. However, handling simple parallel tasks within Phase 2 using dispatching-parallel-agents patterns is naturally compatible.

Q: Is progress lost on session disconnect?#

A: No. All state is recorded in orche-state.json and the file system. Use /orche resume to continue from the last progress point.

Q: What if the Critic over-opposes in the debate panel?#

A: The Moderator builds consensus. Debate runs up to 3 rounds; if consensus isn't reached, the Moderator has final decision authority.

Q: Do I have to use the Opus model?#

A: No. Sonnet alone can handle most tasks. Opus is used selectively only for domain expert roles requiring complex reasoning. Sonnet is recommended as default for cost savings.

---

📋 Changelog#

v1.0.0 (2026-03-26)#

• 🎉 Initial ClawHub release
• Full Phase 0~3 pipeline implementation
• 14-item hallucination checklist
• Phase gate system
• Critic debate protocol
• Auto regression mechanism (up to 3 times)
• Watchdog integration (optional)
• 4-tier cost management
• Session disconnection recovery (state file based)
• 3 demo scenarios + production run records

---

Important Notes#

1. Sub-agents are created via sessions_spawn ( mode: "run")
2. Do not pass full session context to agents — pass only the minimum necessary information
3. File-based communication — no direct inter-agent communication
4. Concurrent agent limit — recommended 3, maximum 8
5. Phase 0 cannot be skipped
6. Be cost-conscious — don't deploy 7 agents for a simple task
7. Harness rules are injected into all sub-agents — this is the key to hallucination prevention

---

Made with 🎼 by reikys — Battle-tested in production environments.