Claude Opus 4.7: Weaving Workflow Cookbook - A Practical Handbook for Multi-Agent Orchestration

One-sentence takeaway

织经 is a practical handbook for Claude Code Dynamic Workflows. It provides 29 chapters and 6 appendices, covering the complete path to multi-Agent orchestration from the ground up. Every recipe has been run in a real local environment and includes a Run ID, with support for both Chinese and English.

Use cases

• Suitable tasks:

  • Multi-Agent orchestration and coordination

  • Complex workflow automation (such as code review pipelines, dependency audits, and log analysis)

  • Scenarios requiring deterministic orchestration (using JavaScript scripts to control Agent execution order)

  • Workflows that need to be reusable, testable, and shareable

• Unsuitable tasks:

  • Simple single-Agent tasks

  • Temporary scripts that do not require orchestration

• Applicable model version: Claude Opus 4.7

• Applicable client, Agent, or API: Claude Code CLI (Dynamic Workflows must be enabled)

• Recommended reasoning levels and parameters: xhigh or ultracode (for proactive orchestration)

Ready-to-use content

Enabling Dynamic Workflows

Dynamic Workflows is an engine in Claude Code that lets you deterministically orchestrate multiple Agents with JavaScript scripts.

How to enable it:

1. Open the "Dynamic workflows" switch in /config

2. Or set the environment variable: CLAUDE_CODE_WORKFLOWS=1

3. Starting with v2.1.154, use /effort ultracode to make Claude proactively orchestrate by default in the current session

Core APIs

agent()

Launches a single Agent to perform a task.

parallel()

Launches multiple Agents in parallel.

pipeline()

Creates an Agent execution pipeline, with the output from the preceding Agent serving as the input to the next.

schema

Defines schema validation for Agent inputs and outputs.

Book structure

Part I · Concepts — Build a mental model

• Understand the role of Dynamic Workflows in Claude Code's extension mechanism

Part II · Fundamentals — A complete API guide

• Master all of the agent() / parallel() / pipeline() / schema APIs

Part III · Practice — 7 recipes run in real environments

• Every recipe includes a Run ID and usage data

Advanced content:

• Adversarial verification

• Loop-to-dry

• Budgeting

• Continuation

• Comparing four community systems and extracting their best ideas

Example: Simple Pipeline

// Example: code review pipeline
const review = await pipeline([
  agent({ role: "Code Analysis", task: "Analyze code structure" }),
  agent({ role: "Security Check", task: "Check for security vulnerabilities" }),
  agent({ role: "Performance Assessment", task: "Assess performance issues" }),
  agent({ role: "Comprehensive Report", task: "Generate comprehensive review report" })
]);

Example: Parallel execution

// Example: analyze multiple files in parallel
const results = await parallel([
  agent({ task: "Analyze src/api/users.ts" }),
  agent({ task: "Analyze src/api/orders.ts" }),
  agent({ task: "Analyze src/api/products.ts" })
]);

Key concepts

Warp threads (meta and phase):

• A deterministic structural skeleton

• Defines the overall framework of the workflow

Weft threads (agent() and pipeline()):

• Intelligent units that move through the skeleton to execute tasks

• The warp and weft interweave to form a pipeline

Testing/workflow steps

1. Enable Dynamic Workflows:

   • Run /config in Claude Code

   • Open the "Dynamic workflows" switch

   • Or set CLAUDE_CODE_WORKFLOWS=1

2. Learn the basic APIs:

   • Read Part II (the complete API guide)

   • Understand how to use agent() / parallel() / pipeline() / schema

3. Run your first Workflow:

   • Choose a simple recipe from Part III

   • Run it according to the recipe instructions and verify the Run ID

4. Create a custom Workflow:

   • Start with a simple scenario (such as analyzing multiple files in parallel)

   • Gradually increase complexity (adding pipeline and schema validation)

5. Advanced patterns:

   • Learn adversarial verification, loop-to-dry, and budgeting

   • Refer to the comparison of the four community systems

6. Share a Workflow:

   • Save the Workflow as a reusable script

   • Include the Run ID and usage data

   • Share it with the community

Original evidence and data

• Provides the complete content of 29 chapters and 6 appendices

• Every practical recipe includes a Run ID and usage data

• Supports both Chinese and English

• An online reading version is available: https://agi-is-going-to-arrive.github.io/workflow-cookbook/

• Licensed under the MIT License

Book data (extracted from the README):

• Number of chapters: 29 chapters + 6 appendices

• Practical recipes: 7 (with Run IDs)

• Languages: Chinese + English

• License: MIT

Scope and limitations

• Requires Claude Code CLI v2.1.154 or later

• Dynamic Workflows is an experimental feature and may change in future versions

• Complex Workflows require JavaScript programming skills

• Some advanced patterns (such as adversarial verification) may require additional configuration

• The book is covered only through its README; all 29 chapters were not read

Source excerpts or observations (short excerpts for compliance only)

The README emphasizes: "This is a practical Cookbook, not API documentation. The recipes are grounded in real execution: those that have actually been run include Run IDs and usage data, while scripts intended only as illustrations are clearly labeled."

"When everyone else is manually directing Agents, this book teaches you to let them form their own teams."

"Dynamic workflows is an engine in Claude Code that lets you deterministically orchestrate multiple Agents with a JavaScript script."