🎼 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. 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:

Problem	Symptom	Result
Hallucination	Uses non-existent APIs/libraries	Non-executable code
Execution without planning

Starts writing code immediately | Direction change costs explode |
| No verification | Deliverables "look plausible" | Don't actually work |
| Linear-only progression | Keeps going forward even on failure | Root cause unresolved |
| Cost explosion | Indiscriminate agent deployment | Budget exhaustion |

Solution: Orche's 4-Phase Engine

CODEBLOCK0

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

Feature	INLINECODE0	INLINECODE1	INLINECODE2	orche
Parallel execution	✅	✅	❌ (sequential)	✅
Pre-query phase

❌ | ❌ | ❌ | ✅ Phase 0 |
| Debate/discussion | ❌ | ❌ | ❌ | ✅ Includes Critic |
| Phase gates | ❌ | ❌ | ✅ (checkpoints) | ✅ 4 gates |
| Hallucination check | ❌ | ❌ | ❌ | ✅ 14 items |
| Auto regression on verification failure | ❌ | ❌ | ❌ | ✅ Up to 3 retries |
| Watchdog integration | ❌ | ❌ | ❌ | ✅ |
| Cost management | ❌ | ❌ | ❌ | ✅ 4-tier budget |
| Session disconnection recovery | ❌ | ❌ | ❌ | ✅ State file based |
| Best for | Simple parallel tasks | Codebase splitting | Sequential plan execution | Complex 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 → INLINECODE4
• File-by-file codebase splitting → INLINECODE5
• Sequential execution with an already-confirmed plan → INLINECODE6

---

🚀 Quick Start — First Orchestration in 5 Minutes

Step 1: Install the Skill (30 Seconds)

Place the skill file in the OpenClaw skills directory:

CODEBLOCK1

Step 2: Trigger (10 Seconds)

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

CODEBLOCK2

Or in natural language:

CODEBLOCK3

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

Orche will ask 3~10 questions. Answer clearly:

CODEBLOCK4

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

CODEBLOCK5

---

🔄 Phase Overview

CODEBLOCK6

Phase Gate System

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

Gate	Transition	Key Conditions
G0	Phase 0 → 1	Requirements structured + ambiguous expressions removed + user approval
G1

Phase 1 → 2 | final-plan.md created + hallucination check passed + no circular dependencies |
| G2 | Phase 2 → 3 | All tasks completed + deliverables exist + no zombie agents |
| Verification | Phase 3 → Done | 14-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. 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 INLINECODE8

Question Categories

Category	Example
Scope	What's in scope? What should be excluded?
Technical constraints

Language/framework/environment limitations? | | Priority | What matters most? (speed/quality/cost) | | Success criteria | How to judge completion? Deliverables? | | Dependencies | External systems/APIs/data? | | Risk | Impact 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. 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 → INLINECODE10

---

Phase 1: Planning

Debate Panel Composition (3~7 members)

Role	Responsibility
Domain Expert (1~2)	Draft plan based on domain expertise
Advocate

Strengthen plan merits, argue feasibility | | Critic | Point out weaknesses/risks/gaps + hallucination check | | Moderator | Synthesize debate, build consensus, write final plan |

Sub-Agent Spawning

CODEBLOCK7

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. 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?

1. 4. Moderator → synthesize → write INLINECODE15

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:

CODEBLOCK8

Task Status Flow: INLINECODE18

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. 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 INLINECODE20
• ✅ All deliverable files exist + non-empty
• ✅ No zombie agents/sessions
• ✅ No critical errors

---

Phase 3: Verification

Verification Team Composition (3~5 members)

Role	Responsibility
Completeness Verifier	All tasks executed, nothing missing
Accuracy Verifier

Deliverables match task spec + success criteria | | Hallucination Verifier | Detect factual errors, logical contradictions, non-existent references | | Integration Verifier | Cross-deliverable consistency, interface compatibility | | Final Reviewer (optional) | Final review against original requirements |

Verification Result Handling

Result	Action
All PASS	Phase 3 complete → normal termination
HIGH issue

Regress to Phase 2 (re-execute affected tasks only) | | MED issue | Report to user, confirm re-execution | | LOW issue | Record 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.

CODEBLOCK9

State Field Descriptions

Field	Type	Description
INLINECODE24	string	Unique identifier (orche-<unix_timestamp>)
INLINECODE26

number | Current phase (0~3) | | status | string | active / completed / aborted / rejected | | requirements | object | Requirements finalized in Phase 0 | | plan | object | Plan finalized in Phase 1 | | tasks | array | Phase 2 task list + status | | agents | array | Currently active sub-agent session key list | | retryCount | number | Phase 3 → 2 regression count | | tokenBudget | object | Token budget management | | errors | array | Error log |

---

📁 Directory Structure

Each orchestration creates an independent working directory:

CODEBLOCK10

---

🛡️ Harness Rules (Safety Mechanisms)

On Orche Start — Execute Immediately

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

Phase Gate Harness (Mandatory Check Before Each Phase Transition)

CODEBLOCK11

Sub-Agent Harness

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

CODEBLOCK12

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

CODEBLOCK13

---

🔍 Watchdog Integration

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

What the Watchdog Does

Detection Item	Auto Response
Agent 15min+ no change (hang)	kill + re-spawn
Empty deliverable (file size 0)

Retry with reinforced prompt | | All agents lost (deadlock) | Immediate user notification | | Token budget 80% reached | User warning |

Watchdog Registration Method

Register the task in watchdog.md at Orche start:

CODEBLOCK14

Watchdog Design Principles

These principles reflect lessons learned in production.

• - ✅ Read only watchdog.md → query sessions_list using INLINECODE44
• ✅ 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

ID	Item	Verification Method
H-1	File path existence	Verify with stat() or INLINECODE46
H-2

Command existence | Verify with which or command -v | | H-3 | URL validity | Verify with HTTP request (optional) | | H-4 | Code syntax validity | Grammar check with linter/parser | | H-5 | Numerical data cross-verification | Confirm with 2+ sources |

Consistency

ID	Item	Verification Method
H-6	No self-contradiction	Detect conflicting statements within document
H-7

Plan-result alignment | 1:1 mapping verification | | H-8 | Terminology consistency | Same term for same concept |

Completeness

ID	Item	Verification Method
H-9	No remaining TODO/FIXME	INLINECODE49
H-10

No placeholders | Detect [INSERT], TBD, ... | | H-11 | All deliverables exist | Cross-check deliverable list against requirements |

Hallucination Patterns

ID	Item	Verification Method
H-12	No fictional library/API references	Verify existence on npm/pip/crates.io etc.
H-13

No unsourced statistics | Verify source citation or "needs verification:" label | | H-14 | No overconfident expressions | Detect "always", "never", "100%" type claims |

Judgment Criteria

CODEBLOCK15

---

💰 Cost Management

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

Budget Tiers

Tier	Ratio	Action
🟢 Normal	< 50%	Normal operation
🟡 Caution

50~80% | Limit concurrent agents, prefer sonnet | | 🔴 Warning | 80~95% | Stop new spawns, complete in-progress tasks only | | ⛔ Exceeded | > 95% | Full stop, request user judgment |

Cost Saving Tips

1. 1. Actively leverage model selection:

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

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

1. 3. Set token budget according to task scale:

Task Scale	Recommended Budget (tokens)	Expected Agents	Estimated Cost (Claude Sonnet)
Small (simple research)	200,000	6~8	~$0.6
Medium (code refactoring)

500,000 | 10~15 | ~$1.5 | | Large (market analysis report) | 1,000,000 | 15~20 | ~$3.0 |

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

1. 4. 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:

CODEBLOCK16

---

🚨 Exception Handling Summary

Exception	Detection Method	Auto Response	User Notification
Agent hang	Watchdog 15min no change	kill + re-spawn	On 2 consecutive occurrences
Empty deliverable

File size 0 | Retry with reinforced prompt | On 2 failures |
| API error (429/500) | HTTP status | Retry after 30s | On 3 failures |
| Hallucination detected | Critic/verification team | Regenerate affected portion | On HIGH severity |
| Total deadlock | All agents lost | — | Immediately |
| Context exceeded | Error message | Retry with reduced input | On failure |
| maxRetries exceeded | Counter check | — | Immediate judgment request |
| Token budget exceeded | used/total ratio | Model downgrade | At 80% |

Error Logging

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

CODEBLOCK17

---

🙋 User Intervention Points

Timing	Required?	Content
Phase 0 complete	✅ Required	Approve requirements
Phase 1 complete

Optional | Review plan (default: auto-proceed) |
| Phase 2 failure | ✅ Required | Judgment after 2 retry failures |
| Phase 3 MED issue | ✅ Required | Decide on re-execution |
| Phase 3 complete | Notification | Final 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. 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)

CODEBLOCK18

---

🔄 Session Disconnection Recovery

Problem

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

Recovery Mechanism

1. 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.

1. 2. State updated immediately on each task completion:

- completedAt recorded in orche-state.json upon receiving each sub-agent result

1. 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

1. 4. Manual recovery:

- User instructs orche to resume → reads orche-state.json → continues from incomplete tasks

Recovery Command Example

CODEBLOCK19

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

---

🎮 Demo Scenarios

Scenario 1: Research Report Writing

User Input:
CODEBLOCK20

Phase 0 — Query (2~3 min):
CODEBLOCK21

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

Task	Agent	Deliverable
Market overview	agent-1	INLINECODE70
Key players

agent-2 | tasks/task-2/key-players.md |
| Investment trends | agent-3 | tasks/task-3/investment-trends.md |
| Regulatory landscape | agent-4 | tasks/task-4/regulatory.md |
| Consolidated report | agent-5 | tasks/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:
CODEBLOCK22

Phase 0 — Query (3 min):
CODEBLOCK23

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

Task	Agent	Deliverable
Dependency analysis	agent-1	INLINECODE75
User module separation

agent-2 | tasks/task-2/user-module/ |
| Auth module separation | agent-3 | tasks/task-3/auth-module/ |
| Order module separation | agent-4 | tasks/task-4/order-module/ |
| Shared utilities cleanup | agent-5 | tasks/task-5/shared/ |
| Test writing | agent-6 | tasks/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:
CODEBLOCK24

Phase 0 — Query (2 min):
CODEBLOCK25

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

Task	Agent	Deliverable
Notion analysis	agent-1	INLINECODE81
Coda analysis

agent-2 | tasks/task-2/coda-analysis.md |
| Slite analysis | agent-3 | tasks/task-3/slite-analysis.md |
| Comparative summary | agent-4 | tasks/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

Item	Details
Task	Repackage internal skills for ClawHub publishing
Duration

25 minutes | | Agents deployed | 12 (planning 4 + execution 5 + verification 3) | | By phase | Query 3m → Plan 6m → Execute 10m → Verify 6m | | Regressions | 0 (passed first time) | | Notable | Critic flagged "environment-dependent hardcoded cron IDs" → fixed during planning phase |

Run #2: Multilingual Documentation Translation + Review

Item	Details
Task	Technical doc translation (Korean/English/Japanese) + terminology unification
Duration

35 minutes | | Agents deployed | 15 (planning 3 + execution 8 + verification 4) | | By phase | Query 2m → Plan 5m → Execute 18m → Verify 10m | | Regressions | 1 (H-8 terminology consistency failure → glossary-based retranslation) | | Notable | Terminology inconsistency auto-detected → Phase 2 regression → fixed and passed |

Run #3: API Design + Implementation + Testing

Item	Details
Task	REST API design → implementation → test code → documentation
Duration

42 minutes | | Agents deployed | 18 (planning 5 + execution 8 + verification 5) | | By phase | Query 4m → Plan 8m → Execute 20m → Verify 10m | | Regressions | 1 (H-12 non-existent middleware reference → affected task re-executed) | | Notable | Critic debate on "implement auth middleware vs use library" → Moderator decided on verified library |

Run Statistics Summary

CODEBLOCK26

---

🔗 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. 1. Install hallucination-guard skill:

CODEBLOCK27

1. 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.

1. 3. Integration Architecture:

CODEBLOCK28

1. 4. 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 Type	Orche Alone	+ hallucination-guard
Research report	✅ Sufficient	✅✅ Enhanced numerical verification
Code refactoring

✅ Sufficient | ✅✅✅ API existence check essential | | Market analysis | ✅ Sufficient | ✅✅ Enhanced statistics source verification | | Document 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

Intensity	Verifier Count	Hallucination Check	Recommended For
light	2	Essential 5 items only	Simple tasks, time savings
standard (default)

3~4 | All 14 items | General tasks | | thorough | 5 | 14 items + additional cross-verification | High-risk tasks |

You can specify verification intensity during Phase 0:
CODEBLOCK29

Agent Model Configuration

Specify different models per phase based on task characteristics:

CODEBLOCK30

Concurrent Agent Limit

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

CODEBLOCK31

---

❓ 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. 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.