References: Six effective-agent patterns

Source material

Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Building with the Claude API" course (agent patterns sections)
  License: Anthropic Academy course content is account-gated;
    Clawdemy structurally mirrors the Academy's lesson progression
    as inspiration and cites it as further study. Every substantive
    claim in this lesson is verifiable against the public Anthropic
    engineering post.

Primary public-source anchor (THE source for all six patterns;
every substantive claim verified against):
• Anthropic engineering, "Building effective AI agents"
   Authors: Erik Schluntz and Barry Zhang
   Published: 2024-12-19
  https://www.anthropic.com/engineering/building-effective-agents

Supporting public-source anchors:
• Anthropic, "Tool use with Claude" overview (tool_choice + the
   per-mode token cost table from L8)
  https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview

Verbatim claims sourced from the engineering post:
• Workflow definition: "systems where LLMs and tools are
   orchestrated through predefined code paths" (referenced from L8)
• Agent definition: "systems where LLMs dynamically direct their
   own processes and tool usage, maintaining control over how
   they accomplish tasks" (referenced from L8)
• Pattern 1: "Prompt chaining decomposes a task into a sequence
   of steps, where each LLM call processes the output of the
   previous one"
• Pattern 1 trade-off: "The main goal is to trade off latency for
   higher accuracy, by making each LLM call an easier task"
• Pattern 2: "Routing classifies an input and directs it to a
   specialized followup task"
• Pattern 2 benefit: "This workflow allows for separation of
   concerns, and building more specialized prompts"
• Pattern 3 top-line: "LLMs can sometimes work simultaneously
   on a task and have their outputs aggregated programmatically"
• Pattern 3 sectioning: "Breaking a task into independent
   subtasks run in parallel"
• Pattern 3 voting: "Running the same task multiple times to
   get diverse outputs"
• Pattern 3 principle: "For complex tasks with multiple
   considerations, LLMs generally perform better when each
   consideration is handled by a separate LLM call"
• Pattern 4: "A central LLM dynamically breaks down tasks,
   delegates them to worker LLMs, and synthesizes their results"
• Pattern 4 distinction: "The key difference from parallelization
   is its flexibility ... subtasks aren't pre-defined, but
   determined by the orchestrator based on the specific input"
   (the source has an em-dash where this elision sits; the
   elision marks the source punctuation per A1 fidelity)
• Pattern 5: "One LLM call generates a response while another
   provides evaluation and feedback in a loop"
• Pattern 5 success indicators: "LLM responses can be demonstrably
   improved when a human articulates their feedback" and "the LLM
   can provide such feedback"
• Pattern 5 analogy: "This is analogous to the iterative writing
   process a human writer might go through when producing a
   polished document"
• Pattern 6: "Agents begin their work with either a command from,
   or interactive discussion with, the human user. Once the task
   is clear, agents plan and operate independently"
• Pattern 6 use case: "Open-ended problems where it's difficult
   or impossible to predict the required number of steps, and
   where you can't hardcode a fixed path"
• Pattern 6 warning: "The autonomous nature of agents means
   higher costs, and the potential for compounding errors. We
   recommend extensive testing in sandboxed environments, along
   with the appropriate guardrails"
• Pattern 6 toolset note: "It is therefore crucial to design
   toolsets and their documentation clearly and thoughtfully.
   You must have some level of trust in its decision-making"
• The post's summary thesis: "Success in the LLM space isn't about
   building the most sophisticated system. It's about building
   the right system for your needs"

Required attribution: "Based on the structure of the Anthropic
  Academy 'Building with the Claude API' course
  (https://anthropic.skilljar.com/) and Anthropic engineering,
  'Building Effective AI Agents' (Erik S. and Barry Zhang,
  2024-12-19, https://www.anthropic.com/engineering/building-
  effective-agents). This lesson is an independent structural
  mirror in original prose; every substantive claim is verified
  against the named engineering post and the public Anthropic
  Claude documentation at https://platform.claude.com/docs/.
  Anthropic does not endorse it."

Read this next

• Anthropic, “Building effective AI agents”. The canonical engineering post for the six patterns. Read once before this lesson lands in production; reread once a quarter as the field evolves.
• Anthropic, “Tool use with Claude” overview. The reference for tool_choice, the per-mode token cost table from L8, and where the agent loop’s call-shape lives.
• Anthropic, “Handling stop reasons”. The per-value reference for the stop_reason dispatch in each pattern’s loop implementation.

Going deeper

A short, durable list. Each link is a specific next step inside Track 22.

• Lesson 10 of this track, “Agent Skills and Claude Code.” Where Agent Skills become the durable instructions each pattern can lean on (a router’s classification prompt as a Skill; an orchestrator’s task-decomposition Skill); Claude Code is the worked agent harness reading them.
• Lesson 11 of this track, “Subagents and Claude Managed Agents.” Where patterns 4 (orchestrator-workers) and 6 (autonomous agent) spawn focused inner loops. Subagents are the L8-loop-inside-an-outer-loop primitive; Managed Agents are the Anthropic-hosted version.
• Lesson 12 of this track, “Shipping a Claude application.” Where the usage telemetry, cost monitoring per pattern, and eval-set discipline wrap whichever patterns you chose for production.

Adjacent tracks (the natural next destinations)

• Track 20 (AI Agents and Tool Use): pick this if you want the full track-level depth on agent design, including the deeper engineering discipline of running agents (especially pattern 6) in production over time.
• Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of evaluation and observability for multi-pattern systems (lesson 7 LLMOps). The eval-set discipline that measures whether each pattern is doing useful work lives there.

Where this connects inside the track

The catalog the rest of Phase 3 specializes:

• Lesson 1 (first call): every pattern’s substrate is the same single-call shape.
• Lesson 3 (model selection): pattern 2 (routing) is the cleanest place to apply the effort-and-model dial deliberately (easy queries to a smaller model, hard ones to Sonnet 4.5 or Opus).
• Lessons 4, 5, 6 (custom + Anthropic-provided + MCP tools): every pattern can use any of the three tool layers; pattern 4 and pattern 6 typically use all three.
• Lesson 7 (prompt caching + context management): cache the shared prefix in patterns 3, 4, 5, and 6 so fan-out and iteration do not re-pay the prefix every call. Compaction and tool result clearing become load-bearing for pattern 6 specifically.
• Lesson 8 (single call to agent loop): the 30-line loop is the substrate every pattern in this lesson sits on top of. The stop_reason dispatch and the four loop disciplines carry over unchanged.
• Lesson 10 (next): Agent Skills as the durable-instructions layer per pattern; Claude Code as the worked harness.
• Lesson 11: Subagents + Claude Managed Agents are how patterns 4 and 6 actually spawn focused inner loops.
• Lesson 12 (shipping): usage fields, eval-set discipline, per-pattern cost monitoring.