25+ production-testedmulti-agent patterns.Full code. Two SDKs.
The Agent Orchestration Cookbook is a production reference for dev teams shipping multi-agent AI systems — research agents, code-review agents, data-pipeline agents, customer-support triage, and the core orchestration patterns underneath. Each pattern ships with full code in Claude Agent SDK and LangGraph, in both Python and TypeScript, plus evaluation harnesses, failure-mode notes, and cost-per-run analysis.
Every team is building agents. Almost everyone is reinventing the same patterns badly.
Your team ships its first agent. It works in the demo. It fails in three weeks of production because nobody handled the retry-with-reflection edge case where the model loops forever. You patch it. The next agent ships. Same loop happens.
Multi-agent patterns are not new. The orchestrator-worker pattern, the hierarchical-supervisor pattern, the parallel map-reduce — these are solved problems with known failure modes. The problem is the knowledge lives in Anthropic engineering blogs, LangChain Discord threads, a handful of conference talks, and the memories of senior engineers who learned the hard way.
The cookbook is what your senior engineer would build on their best week — written down, tested, with cost numbers and failure notes. Drop the patterns into your repo. Stop reinventing.
- 01Engineer writes a multi-step agent in 4 days; works in dev
- 02Production: agent loops forever on edge case in ticket 23
- 03Team adds max_iterations=10 as a band-aid; ticket 47 hits limit silently
- 04Adds reflection step that doubles token costs without measurable quality gain
- 05Reads a blog post about supervisor patterns; rewrites half of it
- 06Six weeks later: still no eval harness, no failure-mode docs, no cost dashboard
Six deliverables. Engineered to ship together.
The 25+ Pattern Library
Organized into five categories: core orchestration, research agents, code & engineering agents, data pipeline agents, customer operations agents. Each pattern is self-contained and composable.
Full Implementation Code
Each pattern in four paths: Claude Agent SDK (Python + TypeScript), LangGraph (Python + TypeScript). Drop-in ready. Real implementations, not pseudocode or architecture diagrams.
Evaluation Harnesses
Per-pattern eval scripts with golden datasets, scoring criteria, regression test scaffolds. Includes provider-agnostic benchmarks for Claude, GPT, and Gemini comparisons.
Failure-Mode Notes
For each pattern: where it breaks in production, why, what to do about it. The notes you'd otherwise pay senior engineers to learn through outages.
Cost-Per-Run Analysis
Token usage, API costs across providers, latency profiles (p50, p95), retry-rate impact. Pick patterns that match your unit economics, not just your accuracy targets.
Architecture Decision Records
Why graph vs. hierarchical. When subagents beat tools. When to use Claude SDK vs. LangGraph. The senior-engineer reasoning behind every pattern, written down so you can defend the choice in code review.
Five categories. Twenty-five patterns. Every one in four implementation paths.
Core Orchestration Patterns
- ·Sequential pipeline
- ·Orchestrator-worker
- ·Hierarchical supervisor
- ·Parallel map-reduce
- ·Handoff routing
- ·Voting / ensemble
- ·ReAct with memory
- ·Recursive decomposition
Research & Information Agents
- ·Web research agent
- ·Multi-source synthesis
- ·Citation-tracked research
- ·Iterative literature review
Code & Engineering Agents
- ·Code review agent
- ·Refactor planner
- ·Test generation
- ·Bug triage with root-cause
Data Pipeline Agents
- ·ETL coordinator
- ·Data validation agent
- ·Schema inference
- ·Anomaly detection
Customer Operations Agents
- ·Support ticket triage
- ·Intent classifier + router
- ·Escalation logic
- ·FAQ generation
- ·Sentiment-aware response
Pattern Composition Guide
Most production agent systems combine 3 to 5 patterns. The composition guide shows common combinations and the interface gotchas that emerge when patterns meet.
Pattern count is 25 across the five categories plus the composition guide. New patterns are added when material new orchestration approaches emerge (and survive 90 days in production somewhere). Existing buyers get those additions included in the lifetime updates.
Sample: the Customer Support Triage pattern. Code, evals, failure notes, cost.
Customer Support Triage
A classifier agent routes incoming tickets to specialist agents based on detected intent. Specialist agents handle their domain end-to-end, with optional subagent delegation for complex cases. The classifier is cheap (Haiku); the specialists are capable (Sonnet). Cost-efficient and accurate at scale.
Incoming ticket
│
▼
┌──────────────┐
│ Classifier │ ← Haiku 4.5
│ (intent) │
└──────┬───────┘
│
├──→ Billing agent ← Sonnet 4.6
├──→ Technical agent ← Sonnet 4.6 + subagents
└──→ Account agent ← Sonnet 4.6from claude_agent_sdk import Agent
from typing import Literal
Intent = Literal["billing", "technical", "account", "unknown"]
classifier = Agent(
model="claude-haiku-4-5",
system="Classify the ticket. Return one of: billing, technical, account.",
output_schema={"intent": Intent, "confidence": float},
)
specialists = {
"billing": Agent(model="claude-sonnet-4-6", system=BILLING_SYS_PROMPT),
"technical": Agent(model="claude-sonnet-4-6", system=TECHNICAL_SYS_PROMPT,
subagents=[diagnostics_subagent]),
"account": Agent(model="claude-sonnet-4-6", system=ACCOUNT_SYS_PROMPT),
}
async def triage(ticket: str) -> str:
result = await classifier.run(ticket)
if result.intent == "unknown" or result.confidence < 0.7:
return await human_handoff(ticket, reason="low_confidence")
return await specialists[result.intent].run(ticket, context=result)$ pattern-eval customer_support_triage PATTERN customer_support_triage DATASET golden/support_v2.jsonl (n=412) ───────────────────────────────────── Accuracy 92.7% Routing precision 94.1% Cost / ticket $0.043 p50 latency 1.8s p95 latency 2.4s Escalation rate 7.3% ───────────────────────────────────── exit: 0
- ·Short tickets (<3 words). Classifier hits low-confidence threshold; routes 18% to human handoff.
- ·Multi-issue tickets. Classifier picks dominant intent; secondary issue lost. Mitigation in §3.2.
- ·Specialist hallucination. Technical agent makes up account details. Mitigated by RAG + structured output.
| Component | Model | Cost / ticket | Notes |
|---|---|---|---|
| Classifier | Haiku 4.5 | $0.001 | Short input, structured output |
| Billing specialist | Sonnet 4.6 | $0.038 | ~38% of tickets |
| Technical specialist | Sonnet 4.6 + subagent | $0.072 | ~22% of tickets |
| Account specialist | Sonnet 4.6 | $0.027 | ~33% of tickets |
| Human handoff | — | $0 | ~7% of tickets |
| Weighted avg | $0.043 | per ticket |
One pattern. One of 25. Each one ships with the same depth: architecture, code in four implementation paths, eval harness, failure-mode notes, cost-per-run table. Your senior engineer’s best week, written down.
Two platforms. Two languages. Four implementation paths per pattern.
Two platforms hits roughly 80% of the serious multi-agent market with manageable scope. Claude Agent SDK is the Anthropic-native runtime that powers Claude Code — increasingly the default for production agent work. LangGraph is the dominant open-source orchestration framework and is provider-agnostic, so the LangGraph implementations work with Claude, GPT, or Gemini. Pick the path that matches your stack. Ignore the rest.
$ pip install claude-agent-sdk
Anthropic-committed stack. Deep tool-use, hooks, subagents, MCP. The runtime that powers Claude Code.
$ npm install @anthropic-ai/claude-agent-sdk
Anthropic-committed stack on Node. Feature-parity with the Python SDK. V1 stable interface targeted.
$ pip install langgraph
Provider portability. Graph-based state machines. Most production-proven open-source orchestration in market.
$ npm install @langchain/langgraph
Provider portability on Node. Feature parity with Python on core capabilities (StateGraph, checkpointing, streaming, human-in-the-loop).
The patterns themselves translate. If your stack is on a different framework — OpenAI Agents SDK, Mastra, CrewAI, bare provider APIs — the architectures, failure-mode notes, and cost analysis still apply. You’ll port the code yourself, but you don’t reinvent the patterns.
Be honest about what the $79 buys you. And what it doesn’t.
- 25+ patterns, full code in four implementation paths.
- Evaluation harnesses with golden datasets and scoring criteria.
- Failure-mode notes from real production deployments.
- Cost-per-run analysis with token, latency, and retry-rate breakdowns.
- Architecture decision records explaining why each pattern was designed this way.
- Not a managed platform. No UI, no hosted runtime, no observability dashboard. The cookbook is code and documentation; deployment is your problem.
- Not OpenAI Agents SDK, Mastra, or CrewAI. Two platforms deliberately. Patterns translate; ports are your problem.
- Not voice agents. Different product category. See the Voice Agent Deployment Kit if that’s your scope.
- Not fine-tuning or training. The cookbook assumes you’re using off-the-shelf models. Custom training is a separate discipline.
- Not a RAG cookbook. Some patterns use retrieval, but RAG architecture is a different category with its own cookbook-shaped book somewhere out there.
The cookbook is one thing — a pattern reference for multi-agent orchestration — and it does that one thing thoroughly. The boundaries are deliberate. Other RedHub AI products cover other parts of the AI engineering stack.
Be honest with yourself before you click buy.
- Your team ships multi-agent features in production or is about to.
- You’re using Claude Agent SDK, LangGraph, or considering either.
- You’ve already reinvented at least one pattern badly.
- You’re a senior engineer, AI/ML engineer, eng manager, or technical founder.
- You want production-tested patterns to own, not blog-post snippets to translate.
- You’re using OpenAI Agents SDK exclusively (patterns translate, code doesn’t).
- You haven’t shipped a single agent to production yet — start simpler.
- You want a managed platform with a UI and dashboards.
- You want done-for-you implementation, not a cookbook to own.
- Nobody on your team reads TypeScript or Python.
Orchestrate the agents, then prove they hold.
The patterns here stitch agents together; the rest of the reliability stack proves they work. The Agent Reliability Harness stress-tests the orchestrated flow end-to-end, the Prompt Eval System scores the prompts each step depends on, and the RAG Retrieval Grader grades the retrieval feeding them.
The questions engineers actually ask before pulling out the company card.
Two platforms hits roughly 80 percent of the serious multi-agent market with manageable scope. Claude Agent SDK is the Anthropic-native runtime that powers Claude Code — increasingly the default for production agent work. LangGraph is the dominant open-source orchestration framework and is provider-agnostic, so the LangGraph implementations work with any model (Claude, GPT, Gemini). OpenAI Agents SDK is excellent but OpenAI-locked. Mastra is the strongest TypeScript-native framework but newer. CrewAI is great for role-based prototyping but lighter on production controls. The patterns themselves translate — if you're on a different stack, the architectures and failure-mode notes still apply.
The patterns translate. Most LangGraph implementations work with any provider — you can swap the model client for the bare Anthropic SDK, OpenAI SDK, or Google AI SDK with minor adjustments. The Claude Agent SDK implementations are Anthropic-specific by design (they use the SDK's agent loop, tools, and hooks), but the architectural patterns they demonstrate apply to any provider-direct implementation you build yourself.
No. Pick the implementation path that matches your stack — Claude Agent SDK if you're committed to Anthropic and want the deep tool-use ergonomics, LangGraph if you want provider portability or framework-level abstractions. Each pattern is fully self-contained in your chosen path. The four paths exist so you don't have to translate; pick yours and ignore the rest. The architecture notes are platform-agnostic.
Both Claude Agent SDK and LangGraph ship updates roughly weekly. RedHub AI tracks both and updates the cookbook when (a) a major version ships that affects pattern correctness, or (b) a pattern's failure modes change because of platform updates. Existing buyers get lifetime updates included in the $79. The cookbook ships with a version-pin file so you can lock to specific SDK versions if you prefer stability over latest.
Directional, not predictive. Cost-per-run analysis uses public API pricing (Anthropic, OpenAI, Google) measured against our golden-dataset runs, with token counts and latency profiles for each pattern. Your actual costs will vary based on input size, model choice, retry rates, and how much your specific workflow exercises long tool-use loops. The cookbook documents the methodology so you can recalibrate for your own workloads.
Yes — most production agent systems combine three to five patterns. The cookbook includes a composition guide showing common combinations (e.g., orchestrator-worker + retry-with-reflection + human-in-the-loop checkpoints) and the gotchas that emerge at the interfaces. Each pattern is engineered to compose cleanly; the failure-mode notes explicitly flag composition-related failure modes.
Both. The Claude Agent SDK implementations are Anthropic-native. The LangGraph implementations are provider-agnostic — you can run them against Claude (Opus, Sonnet, Haiku), GPT (4o, 4o-mini, o1), or Gemini (Pro, Flash) with a model-client swap. The benchmark scaffolds in the eval harnesses cover all three providers.
Yes. The cookbook is licensed for single-operator use across unlimited projects — your own products, your agency clients, your portfolio. Team licensing for multi-operator engineering teams is available on request through the RedHub AI support inbox.
30-day no-questions refund. If the cookbook doesn't save you the engineering weeks your team would otherwise spend reinventing these patterns badly, you shouldn't have paid. Email RedHub AI support and the $79 comes back.
Stop reinventing patterns.
Ship the ones that work.
$79 once. 25+ patterns. Full code in Claude Agent SDK and LangGraph, Python and TypeScript. Eval harnesses, failure notes, cost analysis. Your senior engineer’s best week, written down.
Sold by RedHub AI LLC · Secured by Stripe · redhub.ai