Creates multi-agent orchestration workflows for complex tasks. Handles enterprise workflows, operational procedures, and custom orchestration patterns. Use when user needs to automate multi-phase processes with agent coordination.
Creates multi-agent orchestration workflows for complex tasks. Handles enterprise workflows, operational procedures, and custom orchestration patterns. Use when user needs to automate multi-phase processes with agent coordination.
REGISTRY_MATCH: Warn user — artifact is registered but file may be missing. Investigate before creating. Ask user to confirm.
SIMILAR_FOUND: Display candidates with scores. Ask user: "Similar artifact(s) exist. Continue with new creation or update existing?"
NO_MATCH: Proceed to Step 0.5 (companion check).
Override: If user explicitly passes --force, skip this check entirely.
Step 0.5: Companion Check
Before proceeding with creation, run the ecosystem companion check:
Use companion-check.cjs from .claude/lib/creators/companion-check.cjs
Call checkCompanions("workflow", "{workflow-name}") to identify companion artifacts
Review the companion checklist — note which required/recommended companions are missing
Plan to create or verify missing companions after this artifact is complete
Include companion findings in post-creation integration notes
This step is informational (does not block creation) but ensures the full artifact ecosystem is considered.
Step 1: Verify No Existing Workflow
# Search for relevant workflows
Glob: .claude/workflows/**/*.md
Grep: "<topic>"in .claude/workflows/
If a suitable workflow exists, consider enhancing it instead of creating a duplicate.
Step 2.5: Workflow Pattern Research (MANDATORY)
Before creating a workflow, research existing patterns.
1. Check existing workflows:
Glob: .claude/workflows/**/*.md
2. Research workflow patterns (minimum 2 queries):
WebSearch({ query: 'best <domain/topic name> agent workflow process 2026' });
WebSearch({ query: 'industry standard <workflow-type> orchestration phases 2026' });
3. Document patterns found in workflow comments
BLOCKING: Workflow creation cannot proceed without pattern research. This ensures workflows follow established patterns rather than reinventing solutions.
Step 2: Identify Phases and Agents
Analyze the process to break into phases:
Question
Determines
What are the distinct stages?
Phase boundaries
Which agent handles each stage?
Agent assignments
Can any stages run in parallel?
Parallel execution opportunities
What outputs feed into next stage?
Data flow and handoffs
What can go wrong at each stage?
Error recovery procedures
Common Phase Patterns:
Pattern
Phases
When to Use
Discovery -> Design -> Review -> Implement
Feature development
Analyze -> Fix -> Test -> Deploy
Bug fix workflow
Explore -> Plan -> Review
Planning workflow
Triage -> Investigate -> Resolve -> Document
Incident response
Code -> Component -> Container -> Context
C4 architecture documentation
Step 3: Define Agent Handoffs
For each phase transition, specify:
### Phase 1 -> Phase 2 Handoff**Output from Phase 1**: .claude/context/plans/phase1-output.md
**Input to Phase 2**: Read output from Phase 1
**Handoff validation**: [Check output exists and is valid]
Step 4: Generate Workflow Definition
Write to .claude/workflows/<category>/<workflow-name>.md:
---
name: { workflow-name }
description: { Brief description of workflow purpose }
version: 1.0.0
agents:
- { agent-1 }
- { agent-2 }
tags: [{ tag1 }, { tag2 }, workflow]
---# {Workflow Title}
{Brief description of workflow purpose and when to use it.}
**Extended Thinking**: {Detailed explanation of workflow rationale, approach, and design decisions.}
## Overview
{Detailed description of what this workflow accomplishes.}
## Configuration Options### {Option Category 1}-**{value_1}**: {Description}
- **{value_2}**: {Description}
## Phase 1: {Phase Name}### Step 1: {Step Name}**Agent**: {agent-name}
**Task Spawn**:
```javascript
Task({
task_id: 'task-1',
subagent_type: 'general-purpose',
description: '{Task description}',
prompt: `You are the {AGENT_NAME} agent.
## Task
{Task description}
## Instructions
1. Read your agent definition: .claude/agents/{category}/{agent}.md
2. **Invoke skills**: Skill({ skill: "{skill-name}" })
3. {Additional instructions}
4. Save output to: .claude/context/{output-path}
## Context
- {Context item 1}
- {Context item 2}
## Memory Protocol
1. Read .claude/context/memory/learnings.md first
2. Record decisions to .claude/context/memory/decisions.md
`,
});
```
Expected Output: {Description of expected output}
Phase 2: {Phase Name}
Step 2: {Step Name} (Parallel)
Agents: {agent-a} + {agent-b} (spawned in parallel)
Task Spawn:
// Spawn both agents in parallel for efficiencyTask({
task_id: 'task-2',
subagent_type: 'general-purpose',
description: '{Agent A task}',
prompt: `You are {AGENT_A}...`,
});
Task({
task_id: 'task-3',
subagent_type: 'general-purpose',
description: '{Agent B task}',
prompt: `You are {AGENT_B}...`,
});
### Step 5: Validate Workflow References (BLOCKING)
**Before writing workflow file, verify ALL references are valid:**
| Reference | Validation |
|-----------|-----------|
| Agent files | All agents in `agents:` array exist in `.claude/agents/` |
| Skills | All skills referenced in prompts exist in `.claude/skills/` |
| Output paths | All output directories exist or will be created |
| Context files | All context files referenced are accessible |
**Validation checklist before writing:**
[ ] All referenced agents exist
[ ] All referenced skills exist
[ ] Output paths are valid
[ ] Error recovery procedures are complete
[ ] Success criteria are measurable
**BLOCKING**: Do not write workflow file if any reference is invalid.
### Step 5.5: Model and Tool Validation (CRITICAL)
**Model Validation for Agent Spawns (CRITICAL):**
When workflow templates spawn agents via Task tool:
- model field MUST be base name only: `haiku`, `sonnet`, or `opus`
- DO NOT use dated versions like `claude-opus-4-5-20251101`
- Choose model based on task complexity:
- `haiku`: Quick validation, simple tasks
- `sonnet`: Standard work (default)
- `opus`: Complex reasoning, architecture
**Example:**
```javascript
// CORRECT
Task({
task_id: 'task-5',
model: 'sonnet',
// ...
});
// WRONG - causes validation failures
Task({
task_id: 'task-6',
model: 'claude-sonnet-4-20250514',
// ...
});
Tools Array Validation:
When specifying allowed_tools for spawned agents:
Use standard tools: Read, Write, Edit, Bash, TaskUpdate, TaskList, etc.
DO NOT include MCP tools (mcp__*) unless whitelisted in routing-table.cjs
mcp__github__* - Only for specific GitHub operations
Other MCP tools - Must be whitelisted in routing-table.cjs
Validation checklist for agent spawns:
[ ] Model field uses base name (haiku/sonnet/opus)
[ ] allowed_tools contains only standard tools OR explicitly whitelisted MCP tools
[ ] No dated model versions (e.g., claude-opus-4-5-20251101)
Insert in appropriate location (alphabetical or at end of section)
Verify with:
grep "{workflow-name}" .claude/CLAUDE.md || echo"ERROR: CLAUDE.md NOT UPDATED - BLOCKING!"
BLOCKING: If CLAUDE.md update fails, workflow creation is INCOMPLETE. Do NOT proceed.
Step 7: System Impact Analysis (BLOCKING)
After creating ANY workflow, analyze and update system-wide impacts.
[WORKFLOW-CREATOR] System Impact Analysis for: <workflow-name>
1. CLAUDE.md UPDATE (MANDATORY)
- Add entry to Section 8.6 (Enterprise Workflows)
- Add to Section 3 (Multi-Agent Workflows) if referenced by Router
- Verify with grep
2. AGENT COORDINATION CHECK
- Do all agents referenced exist?
- Do agents need new skills for this workflow?
- Should any agent's definition reference this workflow?
3. SKILL AVAILABILITY CHECK
- Are all skills referenced available?
- Does this workflow need new skills? -> Invoke skill-creator
- Should existing skills be enhanced?
4. MEMORY INTEGRATION CHECK
- Does workflow use Memory Protocol?
- Are output paths writable?
- Will artifacts be properly persisted?
5. RELATED WORKFLOW CHECK
- Does this duplicate existing workflow functionality?
- Should existing workflows reference this one?
- Are there workflow dependencies to document?
6. WORKFLOW-AGENT MAP UPDATED (MANDATORY)
- Added new workflow to @WORKFLOW_AGENT_MAP.md Section 1 matrix
- Determined which agent archetypes use this workflow
- Updated affected agents' `## Related Workflows` sections
- Verified: `grep "<workflow-name>" .claude/docs/@WORKFLOW_AGENT_MAP.md || echo "ERROR: Workflow not in agent map!"`
Validation Checklist (Run After Every Creation) - BLOCKING
# Validate workflow file existsls .claude/workflows/<category>/<workflow-name>.md
# Verify all referenced agents existfor agent in $(grep -oE '\\.claude/agents/[^"]+\\.md' .claude/workflows/<category>/<workflow>.md); do
[ -f "$agent" ] || echo"BROKEN: $agent"done# Verify all referenced skills existfor skill in $(grep -oE 'skill: "[^"]+"' .claude/workflows/<category>/<workflow>.md | cut -d'"' -f2); do
[ -f ".claude/skills/$skill/SKILL.md" ] || echo"BROKEN: $skill"done# Check CLAUDE.md has workflow entry - MANDATORY
grep "<workflow-name>" .claude/CLAUDE.md || echo"ERROR: Not in CLAUDE.md - WORKFLOW CREATION INCOMPLETE"
Completion Checklist (all must be checked):
[ ] Workflow pattern research completed (Step 2.5)
[ ] Workflow file created at .claude/workflows/<category>/<name>.md
[ ] All referenced agents exist in .claude/agents/
[ ] All referenced skills exist in .claude/skills/
[ ] Model fields use base names only (haiku/sonnet/opus)
[ ] allowed_tools arrays contain only standard or whitelisted tools
[ ] CLAUDE.md Section 8.6 updated
[ ] Workflow entry verified with grep
[ ] Memory Protocol included in all agent prompts
BLOCKING: If ANY item fails, workflow creation is INCOMPLETE. Fix all issues before proceeding.
This step is CRITICAL. After creating the workflow artifact, you MUST register it in the workflow discovery system.
Phase 3 Context: Phase 1 created tool manifests (tools), Phase 2 created skill indices (skills), Phase 3 creates workflow registries so workflows can be discovered and invoked by orchestrators.
After workflow file is written and validated:
Create/Update Workflow Registry Entry in appropriate location:
If registry doesn't exist, create .claude/context/artifacts/catalogs/workflow-registry.json:
Workflows cannot be dynamically selected for complex tasks
System loses visibility into workflow network
"Invisible artifact" pattern emerges
Phase 3 Integration: Workflow registry is the discovery mechanism for Phase 3, enabling orchestrators to query available workflows and select appropriate ones for complex multi-agent tasks.
Step 9: Integration Verification (BLOCKING - DO NOT SKIP)
This step verifies the artifact is properly integrated into the ecosystem.
Before calling TaskUpdate({ status: "completed" }), you MUST run the Post-Creation Validation workflow:
Missing orchestrator reference -> Add to orchestrator definition
Missing memory update -> Update learnings.md
Re-run validation until exit code is 0
Only proceed when validation passes
This step is BLOCKING. Do NOT mark task complete until validation passes.
Why this matters: The Party Mode incident showed that fully-implemented artifacts can be invisible to the Router if integration steps are missed. This validation ensures no "invisible artifact" pattern.
These rules are INVIOLABLE. Breaking them causes silent failures.
1. NO WORKFLOW WITHOUT AGENT VALIDATION
- Every agent referenced must exist in .claude/agents/
- Verify with: ls .claude/agents/<category>/<agent>.md
2. NO WORKFLOW WITHOUT SKILL VALIDATION
- Every skill referenced must exist in .claude/skills/
- Verify with: ls .claude/skills/<skill>/SKILL.md
3. NO PARALLEL EXECUTION WITHOUT INDEPENDENCE
- Only spawn agents in parallel if their work is independent
- Dependent work must be sequential
4. NO HANDOFF WITHOUT OUTPUT SPECIFICATION
- Every phase must specify its output location
- Every phase must specify what it reads from previous phases
5. NO WORKFLOW WITHOUT MEMORY PROTOCOL
- Every agent prompt must include Memory Protocol section
- Without it, learnings and decisions are lost
6. NO CREATION WITHOUT CLAUDE.MD UPDATE
- After creating workflow, add to Section 8.6
- Unregistered workflows are never invoked by Router
7. NO CREATION WITHOUT SYSTEM IMPACT ANALYSIS
- Check if new agents are needed
- Check if new skills are needed
- Update @WORKFLOW_AGENT_MAP.md with new workflow row (MANDATORY)
- Update affected agents' Related Workflows sections (MANDATORY)
- Document all system changes made
8. NO AGENT SPAWN WITHOUT MODEL VALIDATION
- model field MUST be base name only: haiku, sonnet, or opus
- DO NOT use dated versions like claude-opus-4-5-20251101
- Dated versions cause validation failures
9. NO AGENT SPAWN WITH UNRESTRICTED MCP TOOLS
- Use standard tools: Read, Write, Edit, Bash, TaskUpdate, etc.
- MCP tools (mcp__*) require explicit whitelisting
- Unwhitelisted MCP tools cause router enforcement failures
10. NO WORKFLOW WITHOUT PATTERN RESEARCH
- Research existing workflow patterns before creating new ones
- Minimum 2 WebSearch queries for domain patterns
- Document patterns found in workflow comments
Workflow Integration
This skill is part of the unified artifact lifecycle. For complete multi-agent orchestration:
This skill is part of the Creator Ecosystem. After creating a workflow, consider whether companion creators are needed:
Gap Discovered
Required Artifact
Creator to Invoke
When
Domain knowledge needs a reusable skill
skill
Skill({ skill: 'skill-creator' })
Gap is a full skill domain
Existing skill has incomplete coverage
skill update
Skill({ skill: 'skill-updater' })
Close skill exists but incomplete
Capability needs a dedicated agent
agent
Skill({ skill: 'agent-creator' })
Agent to own the capability
Existing agent needs capability update
agent update
Skill({ skill: 'agent-updater' })
Close agent exists but incomplete
Domain needs code/project scaffolding
template
Skill({ skill: 'template-creator' })
Reusable code patterns needed
Behavior needs pre/post execution guards
hook
Skill({ skill: 'hook-creator' })
Enforcement behavior required
Process needs multi-phase orchestration
workflow
Skill({ skill: 'workflow-creator' })
Multi-step coordination needed
Artifact needs structured I/O validation
schema
Skill({ skill: 'schema-creator' })
JSON schema for artifact I/O
User interaction needs a slash command
command
Skill({ skill: 'command-creator' })
User-facing shortcut needed
Repeated logic needs a reusable CLI tool
tool
Skill({ skill: 'tool-creator' })
CLI utility needed
Narrow/single-artifact capability only
inline
Document within this artifact only
Too specific to generalize
Integration Workflow
After creating a workflow that needs additional capabilities:
// 1. Workflow created but needs new agentSkill({ skill: 'agent-creator' });
// Create the agent, then update workflow's agents: array// 2. Workflow needs new skillSkill({ skill: 'skill-creator' });
// Create the skill, then reference in workflow prompts// 3. Workflow needs hooks for critical steps// Create hooks in .claude/hooks/workflows/<workflow-name>/// Reference in workflow's hooks: section
Post-Creation Checklist for Ecosystem Integration
After workflow is fully created and validated:
[ ] Does workflow need agents that don't exist? -> Use agent-creator
[ ] Does workflow need skills that don't exist? -> Use skill-creator
[ ] Does workflow need entry/exit hooks? -> Create hooks
[ ] Does workflow need input validation? -> Create schemas
[ ] Should workflow be part of larger orchestration? -> Update master-orchestrator
[ ] Run post-creation validation -> node .claude/tools/cli/validate-integration.cjs .claude/workflows/<category>/<workflow-name>.yaml
Examples
Example 1: Creating Feature Development Workflow
Request: "Create a workflow for end-to-end feature development"
Search arXiv for academic research (mandatory for AI/ML, agents, evaluation, orchestration, memory/RAG, security):
Via Exa: mcp__Exa__web_search_exa({ query: 'site:arxiv.org <topic> 2024 2025' })
Direct API: WebFetch({ url: 'https://arxiv.org/search/?query=<topic>&searchtype=all&start=0' })
Record decisions, constraints, and non-goals in artifact references/docs.
Keep updates minimal and avoid overengineering.
arXiv is mandatory (not fallback) when topic involves: AI agents, LLM evaluation, orchestration, memory/RAG, security, static analysis, or any emerging methodology.
Regression-Safe Delivery
Follow strict RED -> GREEN -> REFACTOR for behavior changes.
Run targeted tests for changed modules.
Run lint/format on changed files.
Keep commits scoped by concern (logic/docs/generated artifacts).
Optional: Evaluation Quality Gate
Run the shared evaluation framework to verify workflow quality:
