claude-flow

name	claude-flow
description	Preferred development orchestration via claude-flow MCP. Full planning pipeline (business-requirements -> technical architecture -> development planning -> SPARC), multi-agent swarms, shared memory, self-learning hooks, and 150+ tools across 20 domains.
version	1.0.0
variables	["action","task","topology","strategy"]
allowed-tools	["Bash","Read","Write","Glob","Grep","claude-flow__*"]
user-invocable	true
argument-hint	<action> [options] (e.g., plan "feature", spawn coder, swarm init, memory search "query")

Claude-Flow Development Orchestration

You are a development orchestration skill that leverages claude-flow as the preferred MCP server for all complex development work. Claude-flow provides 150+ tools across 20 domains -- agents, swarms, memory, workflows, coordination, hive-mind, intelligence, embeddings, neural nets, browser automation, and more.

Claude-flow is always preferred over CLI agents. When dispatching work, use claude-flow MCP tools directly as tool calls. Only fall back to CLI agents when claude-flow cannot handle the specific task (e.g., gemini for 2M-token context windows).

Tool Invocation

All claude-flow tools are registered as MCP tools in the agent's tool registry with names prefixed claude-flow__. Call them directly as tool calls -- do NOT use bash commands. The tool registry names follow the pattern:

claude-flow__<domain>_<action>

For example: claude-flow__agent_spawn, claude-flow__memory_search, claude-flow__swarm_init.

MCP Server Connection

Claude-flow must be registered as an MCP server in ~/.clawft/config.json:

{
  "tools": {
    "mcp_servers": {
      "claude-flow": {
        "command": "npx",
        "args": ["-y", "@claude-flow/cli@latest"],
        "internal_only": false
      }
    }
  }
}

Verify connection by calling the claude-flow__system_status tool. If it returns an error, the MCP server is not connected.

Available Actions

plan -- Full Planning Pipeline

Run the complete planning workflow for a new feature or project. This is the structured pipeline that takes an idea from business requirements through to executable SPARC development plans. This workflow is always done through claude-flow.

Pipeline stages:

1. Business Requirements
   └─ Stakeholder needs, user stories, acceptance criteria, constraints
        ↓
2. Technical Architecture
   └─ System design, crate/module structure, API contracts, data flows
        ↓
3. Development Planning
   └─ Task breakdown, dependency graph, milestone schedule, risk register
        ↓
4. SPARC Plan
   └─ Specification → Pseudocode → Architecture → Refinement → Completion

Workflow:

1. Business Requirements -- Gather and formalize:

   Call claude-flow__memory_store with:

   • key: "plan-<name>-business-req"
   • value: "<requirements JSON>"
   • namespace: "planning"
   • tags: "planning,business,<name>"

   Write output to .planning/<name>/01-business-requirements.md.

2. Technical Architecture -- Design from requirements:

   Call claude-flow__agent_spawn with:

   • type: "architecture"
   • name: "arch-<name>"
   • task: "Design technical architecture for: <requirements summary>"

   Call claude-flow__memory_store with:

   • key: "plan-<name>-tech-arch"
   • value: "<architecture JSON>"
   • namespace: "planning"

   Write output to .planning/<name>/02-technical-architecture.md.

3. Development Planning -- Break into tasks:

   Call claude-flow__coordination_orchestrate with:

   • task: "Create development plan from architecture: <arch summary>"
   • strategy: "specialized"

   For each task, call claude-flow__task_create with:

   • name: "<task-name>"
   • description: "<task details>"
   • priority: <1-5>
   • dependencies: "<dep-ids>"

   Write output to .planning/<name>/03-development-plan.md.

4. SPARC Plan -- Generate phase-by-phase specs:

   Call claude-flow__workflow_create with:

   • name: "sparc-<name>"
   • steps: [{"name":"specification","agent_type":"specification"},{"name":"pseudocode","agent_type":"pseudocode"},{"name":"architecture","agent_type":"architecture"},{"name":"refinement","agent_type":"refinement"},{"name":"completion","agent_type":"sparc-coder"}]

   Call claude-flow__workflow_execute with:

   • name: "sparc-<name>"
   • input: "<development plan summary>"

   Write output to .planning/<name>/04-sparc/S1-specification.md through S5-completion.md.

Each stage stores its output in shared memory so subsequent stages can build on previous work. Use claude-flow__memory_search to retrieve cross-stage context.

Data paths:

.planning/<name>/
├── 01-business-requirements.md
├── 02-technical-architecture.md
├── 03-development-plan.md
└── 04-sparc/
    ├── S1-specification.md
    ├── S2-pseudocode.md
    ├── S3-architecture.md
    ├── S4-refinement.md
    └── S5-completion.md

spawn -- Create an Agent

Spawn a specialized agent for a specific task. Claude-flow provides 60+ agent types optimized for different work.

Call claude-flow__agent_spawn with:

• type: "<agent-type>"
• name: "<agent-name>"
• task: "<task description>"

Common agent types:

Type	Use Case
coder	Write implementation code
reviewer	Code review and quality checks
tester	Write and run tests
planner	Strategic planning and task decomposition
researcher	Deep research and information gathering
specification	SPARC specification phase
pseudocode	SPARC pseudocode phase
architecture	SPARC architecture phase
refinement	SPARC refinement phase
sparc-coder	SPARC completion / TDD implementation
sparc-coord	SPARC methodology orchestrator
security-manager	Security analysis and hardening
backend-dev	Backend API development
mobile-dev	React Native development
cicd-engineer	CI/CD pipeline optimization
pr-manager	Pull request management
release-manager	Release coordination

Agent lifecycle tools:

Tool	Parameters	Purpose
claude-flow__agent_status	id	Check agent status
claude-flow__agent_list	(none)	List all active agents
claude-flow__agent_health	id	Check agent health
claude-flow__agent_update	id, config	Update agent configuration
claude-flow__agent_terminate	id	Terminate an agent
claude-flow__agent_pool	action	Manage agent pool

swarm -- Multi-Agent Coordination

Initialize and manage multi-agent swarms for complex tasks that require parallel work across multiple agents.

Call claude-flow__swarm_init with:

• topology: "hierarchical" | "mesh" | "adaptive"
• max-agents: <n>
• strategy: "specialized" | "general"

Topologies:

Topology	Description	Best For
hierarchical	Tree structure with coordinator at top	Coding tasks, clear delegation
mesh	Peer-to-peer, all agents communicate	Research, exploration, consensus
adaptive	Dynamic -- switches topology based on needs	Unknown complexity, long tasks

Recommended configuration (from CLAUDE.md): hierarchical topology, 8 max-agents, specialized strategy.

After initializing, spawn agents into the swarm using claude-flow__agent_spawn. The swarm coordinator distributes work based on the chosen strategy.

Swarm lifecycle tools:

Tool	Purpose
claude-flow__swarm_status	Check swarm status
claude-flow__swarm_health	Monitor swarm health
claude-flow__swarm_shutdown	Shut down swarm

orchestrate -- Complex Task Execution

Orchestrate a multi-step task with automatic decomposition, agent assignment, and result synthesis.

Call claude-flow__coordination_orchestrate with:

• task: "<task description>"
• strategy: "auto" | "specialized" | "parallel"

The orchestrator:

1. Decomposes the task into subtasks.
2. Scores complexity per subtask (ADR-026 tiers).
3. Spawns appropriate agents for each subtask.
4. Manages dependencies and execution order.
5. Synthesizes results into a unified output.

Coordination tools:

Tool	Parameters	Purpose
claude-flow__coordination_topology	(none)	Check coordination topology
claude-flow__coordination_sync	(none)	Synchronize state across agents
claude-flow__coordination_load_balance	(none)	Load balance across agents
claude-flow__coordination_consensus	(none)	Run distributed consensus
claude-flow__coordination_node	action	Register/manage coordination nodes
claude-flow__coordination_metrics	(none)	Get coordination metrics

memory -- Shared Memory Operations

Store, search, and retrieve shared knowledge across agents and sessions. Claude-flow memory uses HNSW indexing for 150x-12,500x faster search.

Store: Call claude-flow__memory_store with:

• key: "<key>"
• value: "<value>"
• namespace: "<namespace>" (optional)
• tags: "<comma-separated-tags>" (optional)

Search: Call claude-flow__memory_search with:

• query: "<natural language query>"
• namespace: "<namespace>" (optional)
• limit: <n> (optional)

Retrieve: Call claude-flow__memory_retrieve with:

• key: "<key>"
• namespace: "<namespace>" (optional)

Other memory tools:

Tool	Parameters	Purpose
claude-flow__memory_list	namespace, limit	List entries
claude-flow__memory_delete	key, namespace	Delete an entry
claude-flow__memory_stats	(none)	Memory statistics
claude-flow__memory_migrate	(none)	Migrate memory formats

Recommended namespaces:

Namespace	Purpose
planning	Business requirements, architecture, SPARC plans
patterns	Code patterns, conventions, best practices
decisions	ADRs, architectural decisions, trade-offs
context	Session context, project state
learning	Learned behaviors, trajectory outcomes

workflow -- Automated Workflows

Create and manage reusable multi-step workflows with agent assignments.

Create from template: Call claude-flow__workflow_template with:

• name: "<template-name>"

Create custom: Call claude-flow__workflow_create with:

• name: "<workflow-name>"
• steps: "<step-definitions-json>"

Execute: Call claude-flow__workflow_execute with:

• name: "<workflow-name>"
• input: "<input data>"

Lifecycle tools:

Tool	Parameters	Purpose
claude-flow__workflow_status	name	Check workflow status
claude-flow__workflow_pause	name	Pause a workflow
claude-flow__workflow_resume	name	Resume a paused workflow
claude-flow__workflow_cancel	name	Cancel a workflow
claude-flow__workflow_list	(none)	List all workflows
claude-flow__workflow_delete	name	Delete a workflow

hive -- Collective Intelligence

Byzantine fault-tolerant consensus and collective decision-making across agents.

Initialize: Call claude-flow__hive-mind_init.

Spawn a hive agent: Call claude-flow__hive-mind_spawn with:

• type: "<agent-type>"
• task: "<task>"

Run consensus vote: Call claude-flow__hive-mind_consensus with:

• proposal: "<proposal>"
• threshold: <0.0-1.0>

Broadcast to all members: Call claude-flow__hive-mind_broadcast with:

• message: "<message>"

Shared hive memory: Call claude-flow__hive-mind_memory with:

• action: "store" | "retrieve" | "search"
• key: "<key>"
• value: "<value>"

Other hive tools:

Tool	Purpose
claude-flow__hive-mind_join	Join agent to hive
claude-flow__hive-mind_leave	Remove agent from hive
claude-flow__hive-mind_status	Check hive status
claude-flow__hive-mind_shutdown	Shut down hive

Use raft consensus for hive-mind (leader maintains authoritative state).

learn -- Self-Learning Intelligence

Hooks-based self-learning system that tracks trajectories, learns patterns, and improves agent behavior over time.

Start a trajectory: Call claude-flow__hooks_intelligence_trajectory-start with:

• name: "<trajectory-name>"
• goal: "<what we're trying to achieve>"

Record steps: Call claude-flow__hooks_intelligence_trajectory-step with:

• trajectory: "<name>"
• action: "<what was done>"
• outcome: "<result>"

End trajectory: Call claude-flow__hooks_intelligence_trajectory-end with:

• trajectory: "<name>"
• success: true | false
• summary: "<what was learned>"

Pattern management:

Tool	Parameters	Purpose
claude-flow__hooks_intelligence_pattern-store	pattern, description, context	Store a learned pattern
claude-flow__hooks_intelligence_pattern-search	query	Search for applicable patterns
claude-flow__hooks_intelligence_learn	input, outcome	Trigger learning from outcome
claude-flow__hooks_intelligence_stats	(none)	View intelligence statistics
claude-flow__hooks_intelligence_attention	query	Focus attention mechanism

Lifecycle hooks (fire automatically on events):

Tool	When It Fires
claude-flow__hooks_pre-task	Before a task starts
claude-flow__hooks_post-task	After a task completes
claude-flow__hooks_pre-edit	Before a file is edited
claude-flow__hooks_post-edit	After a file is edited
claude-flow__hooks_pre-command	Before a command runs
claude-flow__hooks_post-command	After a command completes
claude-flow__hooks_session-start	When a session begins
claude-flow__hooks_session-end	When a session ends
claude-flow__hooks_session-restore	When a session is restored

Model routing hooks:

Tool	Purpose
claude-flow__hooks_model-route	Get model recommendation for a task
claude-flow__hooks_model-outcome	Record model outcome for learning
claude-flow__hooks_model-stats	View model routing statistics

Worker management:

Tool	Parameters	Purpose
claude-flow__hooks_worker-dispatch	task	Dispatch work to a worker
claude-flow__hooks_worker-status	id	Check worker status
claude-flow__hooks_worker-list	(none)	List all workers
claude-flow__hooks_worker-cancel	id	Cancel a worker
claude-flow__hooks_worker-detect	(none)	Detect available workers

analyze -- Code Analysis and Review

Analyze diffs, assess risk, classify changes, and suggest reviewers.

Tool	Parameters	Purpose
claude-flow__analyze_diff	diff	Full diff analysis
claude-flow__analyze_diff-classify	diff	Classify change types
claude-flow__analyze_diff-risk	diff	Assess risk level
claude-flow__analyze_diff-stats	diff	Get diff statistics
claude-flow__analyze_diff-reviewers	diff	Suggest reviewers
claude-flow__analyze_file-risk	file	Analyze file-level risk

github -- GitHub Integration

Manage repos, PRs, issues, and workflows through claude-flow.

Tool	Parameters	Purpose
claude-flow__github_repo_analyze	repo	Analyze repository
claude-flow__github_pr_manage	action, repo, pr	Manage pull requests
claude-flow__github_issue_track	action, repo	Track issues
claude-flow__github_workflow	action, repo	Manage workflows
claude-flow__github_metrics	repo	Repository metrics

browse -- Browser Automation

Headless browser control for testing, scraping, and UI verification.

Navigation:

Tool	Parameters	Purpose
claude-flow__browser_open	url	Open a page
claude-flow__browser_back	(none)	Navigate back
claude-flow__browser_forward	(none)	Navigate forward
claude-flow__browser_reload	(none)	Reload page
claude-flow__browser_close	(none)	Close browser

Interaction:

Tool	Parameters	Purpose
claude-flow__browser_click	selector	Click an element
claude-flow__browser_fill	selector, value	Fill an input field
claude-flow__browser_type	selector, text	Type text into element
claude-flow__browser_select	selector, value	Select from dropdown
claude-flow__browser_check	selector	Check a checkbox
claude-flow__browser_uncheck	selector	Uncheck a checkbox
claude-flow__browser_hover	selector	Hover over element
claude-flow__browser_press	key	Press a key
claude-flow__browser_scroll	direction, amount	Scroll the page
claude-flow__browser_wait	selector, state	Wait for condition

Capture:

Tool	Parameters	Purpose
claude-flow__browser_screenshot	path	Take screenshot
claude-flow__browser_snapshot	(none)	Capture DOM snapshot
claude-flow__browser_get-text	selector	Get element text
claude-flow__browser_get-value	selector	Get input value
claude-flow__browser_get-title	(none)	Get page title
claude-flow__browser_get-url	(none)	Get current URL
claude-flow__browser_eval	script	Execute JavaScript
claude-flow__browser_session-list	(none)	List browser sessions

tasks -- Task Management

Create, track, and manage development tasks.

Tool	Parameters	Purpose
claude-flow__task_create	name, description, priority	Create a task
claude-flow__task_status	id	Check task status
claude-flow__task_update	id, status	Update a task
claude-flow__task_complete	id	Complete a task
claude-flow__task_cancel	id	Cancel a task
claude-flow__task_list	(none)	List all tasks

embeddings -- Vector Embeddings

Generate, search, and compare vector embeddings for semantic operations.

Tool	Parameters	Purpose
claude-flow__embeddings_init	(none)	Initialize embedding engine
claude-flow__embeddings_generate	text	Generate embeddings
claude-flow__embeddings_compare	text1, text2	Semantic comparison
claude-flow__embeddings_search	query, limit	Semantic search
claude-flow__embeddings_neural	text	Neural embeddings
claude-flow__embeddings_hyperbolic	text	Hyperbolic embeddings (hierarchical)
claude-flow__embeddings_status	(none)	Check status

neural -- Neural Network Operations

Train, predict, and optimize neural models.

Tool	Parameters	Purpose
claude-flow__neural_train	data, config	Train a model
claude-flow__neural_predict	input, model	Run prediction
claude-flow__neural_optimize	model, target	Optimize model
claude-flow__neural_compress	model, ratio	Compress model
claude-flow__neural_patterns	query	Search patterns
claude-flow__neural_status	(none)	Check status

session -- Session Management

Save, restore, and manage agent sessions for continuity.

Tool	Parameters	Purpose
claude-flow__session_save	name	Save session
claude-flow__session_restore	name	Restore session
claude-flow__session_info	name	Session details
claude-flow__session_list	(none)	List sessions
claude-flow__session_delete	name	Delete session

status -- System Health and Metrics

Monitor claude-flow system health, performance, and resource usage.

System tools:

Tool	Purpose
claude-flow__system_status	System overview
claude-flow__system_health	Health check
claude-flow__system_info	System information
claude-flow__system_metrics	Current metrics
claude-flow__system_reset	Reset system

Performance tools:

Tool	Parameters	Purpose
claude-flow__performance_benchmark	target	Run benchmark
claude-flow__performance_bottleneck	scope	Find bottlenecks
claude-flow__performance_metrics	(none)	Performance metrics
claude-flow__performance_optimize	target	Optimize target
claude-flow__performance_profile	duration	Profile execution
claude-flow__performance_report	(none)	Full performance report

Progress tools:

Tool	Parameters	Purpose
claude-flow__progress_check	task-id	Check task progress
claude-flow__progress_summary	(none)	Overall progress summary
claude-flow__progress_sync	(none)	Sync progress data
claude-flow__progress_watch	task-id	Watch task progress

claims -- Task Claiming and Handoff

Manage distributed task claiming, work-stealing, and handoffs between agents.

Tool	Parameters	Purpose
claude-flow__claims_claim	task-id, agent-id	Claim a task
claude-flow__claims_release	task-id	Release a claimed task
claude-flow__claims_handoff	task-id, to	Hand off to another agent
claude-flow__claims_accept-handoff	task-id	Accept a handoff
claude-flow__claims_mark-stealable	task-id	Allow task stealing
claude-flow__claims_steal	task-id	Steal a stealable task
claude-flow__claims_stealable	(none)	List stealable tasks
claude-flow__claims_rebalance	(none)	Rebalance task distribution
claude-flow__claims_board	(none)	View claims board
claude-flow__claims_status	task-id	Check claim status
claude-flow__claims_list	(none)	List all claims
claude-flow__claims_load	(none)	Load claim state

config -- Configuration Management

Read and modify claude-flow configuration.

Tool	Parameters	Purpose
claude-flow__config_get	key	Get config value
claude-flow__config_set	key, value	Set config value
claude-flow__config_list	(none)	List all config
claude-flow__config_export	path	Export config to file
claude-flow__config_import	path	Import config from file
claude-flow__config_reset	(none)	Reset to defaults

secure -- AI Defence and Security

Scan content for safety, PII detection, and threat analysis.

Tool	Parameters	Purpose
claude-flow__aidefence_analyze	content	Full safety analysis
claude-flow__aidefence_is_safe	content	Quick safety check
claude-flow__aidefence_has_pii	content	PII detection
claude-flow__aidefence_scan	target	Scan a target
claude-flow__aidefence_learn	data	Train on new data
claude-flow__aidefence_stats	(none)	Defence statistics

transfer -- Plugin Store and Data Transfer

Browse the plugin store, manage plugins, and handle data transfers.

Plugin store:

Tool	Parameters	Purpose
claude-flow__transfer_plugin-search	query	Search plugins
claude-flow__transfer_plugin-info	name	Plugin details
claude-flow__transfer_plugin-featured	(none)	Featured plugins
claude-flow__transfer_plugin-official	(none)	Official plugins

Data store:

Tool	Parameters	Purpose
claude-flow__transfer_store-search	query	Search data store
claude-flow__transfer_store-info	id	Item details
claude-flow__transfer_store-download	id	Download item
claude-flow__transfer_store-featured	(none)	Featured items
claude-flow__transfer_store-trending	(none)	Trending items

Security:

Tool	Parameters	Purpose
claude-flow__transfer_detect-pii	content	Detect PII
claude-flow__transfer_ipfs-resolve	cid	Resolve IPFS CID

daa -- Dynamic Agent Adaptation

Create agents that adapt their behavior based on performance metrics and cognitive patterns.

Tool	Parameters	Purpose
claude-flow__daa_agent_create	type, config	Create adaptive agent
claude-flow__daa_agent_adapt	id, feedback	Adapt agent behavior
claude-flow__daa_cognitive_pattern	id	View cognitive patterns
claude-flow__daa_knowledge_share	from, to	Share knowledge between agents
claude-flow__daa_learning_status	id	Learning status
claude-flow__daa_performance_metrics	id	Performance metrics
claude-flow__daa_workflow_create	name, steps	Create adaptive workflow
claude-flow__daa_workflow_execute	name	Execute adaptive workflow

Common Workflows

Feature Development (Full Pipeline)

/claude-flow plan "Add user authentication"
  → Business requirements (stakeholder needs, user stories)
  → Technical architecture (JWT vs sessions, middleware design)
  → Development plan (task breakdown, dependencies, milestones)
  → SPARC specs (S1 through S5 phase documents)
  → Swarm init (hierarchical, 6-8 agents)
  → Agent spawn (coder, tester, reviewer per workstream)
  → Progress watch until completion

Code Review Swarm

/claude-flow swarm    → init hierarchical, 4 agents
/claude-flow spawn    → reviewer for PR #123
/claude-flow analyze  → diff risk assessment
/claude-flow spawn    → tester for changed files

Research and Architecture

/claude-flow spawn    → researcher for "OAuth2 PKCE flow options"
/claude-flow memory   → search "authentication patterns"
/claude-flow spawn    → architecture agent for "Design auth module"
/claude-flow memory   → store key="auth-decision" value="<ADR>"

Debugging with Learning

/claude-flow learn    → trajectory-start "debug-issue-456"
/claude-flow spawn    → coder for "Fix issue #456"
/claude-flow analyze  → diff of the fix
/claude-flow learn    → trajectory-end success=true

Tool Domain Summary

Domain	Tool Count	Key Tools
Agents	7	agent_spawn, agent_status, agent_terminate
Swarms	4	swarm_init, swarm_status, swarm_health
Memory	7	memory_store, memory_search, memory_retrieve
Tasks	6	task_create, task_status, task_complete
Workflows	9	workflow_create, workflow_execute, workflow_template
Coordination	7	coordination_orchestrate, coordination_sync, coordination_consensus
Hive-Mind	9	hive-mind_init, hive-mind_consensus, hive-mind_broadcast
Hooks/Intelligence	34	hooks_intelligence_*, lifecycle hooks, workers
Embeddings	7	embeddings_generate, embeddings_search, embeddings_compare
Neural	6	neural_train, neural_predict, neural_optimize
Sessions	5	session_save, session_restore, session_list
System	5	system_status, system_health, system_metrics
Performance	6	performance_benchmark, performance_bottleneck, performance_report
Progress	4	progress_check, progress_summary, progress_watch
Browser	24	browser_open, browser_click, browser_screenshot
Terminal	5	terminal_create, terminal_execute, terminal_close
Config	6	config_get, config_set, config_export
Claims	12	claims_claim, claims_handoff, claims_steal
Analyze	6	analyze_diff, analyze_diff-risk, analyze_file-risk
GitHub	5	github_pr_manage, github_issue_track, github_repo_analyze
AI Defence	6	aidefence_analyze, aidefence_is_safe, aidefence_has_pii
Transfer	11	transfer_plugin-search, transfer_store-download
DAA	8	daa_agent_create, daa_agent_adapt, daa_knowledge_share
Total	~189

Planning Pipeline Detail

Stage 1: Business Requirements

Capture what the feature needs to accomplish from the user's perspective.

Input: Feature idea or request. Output: Structured requirements document.

The skill gathers:

• User stories: "As a , I want , so that "
• Acceptance criteria: Testable conditions that define "done"
• Constraints: Performance, security, compatibility, budget
• Dependencies: External systems, APIs, existing modules
• Priority: Critical / High / Medium / Low

Store in memory by calling claude-flow__memory_store with key "plan-<name>-business-req", namespace "planning".

Stage 2: Technical Architecture

Translate requirements into system design.

Input: Business requirements from Stage 1. Output: Architecture document with decisions.

The architecture agent produces:

• Module structure: New/modified crates, modules, files
• API contracts: Public interfaces, request/response shapes
• Data flows: How data moves through the system
• ADRs: Architectural Decision Records for key trade-offs
• Integration points: How new code connects to existing systems

Stage 3: Development Planning

Break architecture into executable tasks.

Input: Architecture from Stage 2. Output: Task graph with dependencies and milestones.

The planner produces:

• Task breakdown: Atomic, assignable work items
• Dependency graph: What depends on what
• Milestones: Phase gates with verification criteria
• Risk register: What could go wrong, mitigations
• Resource needs: Agent types per task

Stage 4: SPARC Plan

Generate phase-by-phase development specs following SPARC methodology.

Input: Development plan from Stage 3. Output: 5 SPARC phase documents.

Phase	Agent Type	Produces
S1: Specification	specification	Formal requirements, edge cases, constraints
S2: Pseudocode	pseudocode	Algorithm design, data structures, flow control
S3: Architecture	architecture	Module design, interfaces, patterns
S4: Refinement	refinement	Iterative improvements, optimization, cleanup
S5: Completion	sparc-coder	Final implementation with TDD

ADR-026 Integration

Claude-flow's internal routing follows the 3-tier model:

Tier	Complexity	Handler	Cost
1	< 0.15	WASM booster	$0
2	0.15-0.30	Haiku	$0.0002/1K
3	> 0.30	Sonnet/Opus	$0.003-0.015/1K

Check for routing recommendations before spawning by calling claude-flow__hooks_model-route with the task description.

Error Handling

• MCP server not connected: Call claude-flow__system_status to diagnose. If it fails, the MCP server is not registered or not running.
• Agent spawn failure: Call claude-flow__agent_pool to check capacity. Reduce max-agents or terminate idle agents.
• Memory store full: Call claude-flow__memory_stats to check usage. Clean up old entries with claude-flow__memory_delete.
• Workflow stuck: Call claude-flow__workflow_status. Use claude-flow__workflow_pause then claude-flow__workflow_resume, or cancel.
• Swarm unhealthy: Call claude-flow__swarm_health. If agents are unresponsive, claude-flow__swarm_shutdown and reinitialize.
• Consensus failure: Hive-mind requires >50% agreement by default. Lower the threshold or investigate dissenting agents.

Safety Rules

• Never store secrets in memory -- use env var references.
• Always use hierarchical topology for code-writing swarms (prevents drift).
• Keep max-agents at 6-8 for tight coordination (CLAUDE.md requirement).
• Use raft consensus for hive-mind (leader maintains authoritative state).
• Call claude-flow__aidefence_scan on any content from external sources.
• Log all agent spawns and task completions for auditability.
• Terminate agents when their work is complete -- do not leave idle agents.