Anthropic's 'Building Effective Agents': What the Most-Cited Agent Definition Essay Actually Says

Forum topic · 小凯 · 2026-07-05

Summary

A Chinese forum post dissects Anthropic's widely cited engineering essay 'Building Effective Agents' (December 19, 2024). The post explains Anthropic's core distinction between workflows, where LLMs and tools follow predefined code paths, and agents, where the LLM dynamically directs its own process and tool use. It walks through the essay's five workflow patterns—prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer—and Anthropic's advice to find the simplest solution possible and increase complexity only when needed. Key highlights include the concept of the Agent-Computer Interface (ACI), with Anthropic noting it spent more time optimizing tools than prompts on SWE-bench; practical guidance on when agents are truly warranted (open-ended tasks with unpredictable steps and environment feedback); and validated use cases in customer support and coding. The post concludes that successful agentic systems rely on simple, composable patterns rather than complex frameworks.

This post analyzes Anthropic's influential engineering essay Building Effective Agents (December 19, 2024, by Erik Schulman and Barry Zhang), which has become one of the most-cited definitions of AI agents.

Key points

Core thesis: The most successful agent implementations use simple, composable patterns—not complex frameworks. Anthropic found that the flashier the agent system, the more likely it is to fail.
Two categories of agentic systems:
Workflows: LLMs and tools orchestrated through predefined code paths. The developer controls every step.
Agents: The LLM dynamically directs its own process and tool use, retaining control over how tasks are accomplished.
A common self-deception: Many products marketed as "agents" are actually workflows—and Anthropic says that is often the right choice. Only open-ended problems need agents.

The most important sentence

> "Find the simplest solution possible, and only increase complexity when needed."

The upgrade path is one-directional: simple prompts → add retrieval/examples → workflows → agents. Each step trades latency and cost for better results. Start left; only move right when necessary.

Five workflow patterns

1. Prompt chaining: Decompose a task into fixed subtasks, with optional gates to check quality (e.g., generate marketing copy, then translate it). 2. Routing: Classify input and direct it to specialized follow-up prompts (e.g., general questions vs. refunds vs. technical support; Haiku for easy tasks, Sonnet for hard ones). 3. Parallelization: Run tasks concurrently via *sectioning* (independent subtasks, e.g., one LLM answers while another screens for content safety) or *voting* (multiple attempts, e.g., three code-review prompts flagging vulnerabilities). 4. Orchestrator-workers: A central LLM dynamically decomposes tasks and delegates to worker LLMs—useful when the number and nature of subtasks cannot be predetermined (e.g., a code change may touch 3 or 15 files). 5. Evaluator-optimizer: One LLM generates, another evaluates and gives feedback in a loop (e.g., literary translation refinement, iterative search).

When do you actually need an agent?

Anthropic's criterion: open-ended problems where the number of steps is unpredictable, the path cannot be hard-coded, and each step requires feedback from the environment ("ground truth") to proceed. Costs: more expensive, slower, and errors compound. Recommendation: test extensively in sandboxes with appropriate guardrails.

A counterintuitive detail: tools matter more than prompts

From Appendix 2:

> "We spent more time optimizing tools than optimizing prompts on SWE-bench."

Example: instead of adding prompts to fix relative-path errors, Anthropic changed the tool to require absolute paths—the error class disappeared entirely. This is the ACI (Agent-Computer Interface) principle, analogous to HCI but with the LLM as the user. Rule of thumb: if a tool requires complex prompting to use correctly, the tool design itself is likely flawed.

Frameworks

Start with direct LLM API calls—many patterns take only a few lines of code. If using frameworks (Claude Agent SDK, AWS Strands Agents SDK, Rivet, Vellum), make sure you understand the underlying code; framework misunderstandings are a top source of customer errors.

Two validated agent use cases

Customer support: naturally open-ended conversations, tool integration (customer data, order history, knowledge bases), programmable actions (refunds, ticket updates), and clear success metrics—some companies already price by "charge only on successful resolution."
Coding agents: code is verifiable via automated tests, which provide natural feedback signals. Anthropic's agents can resolve real GitHub issues on SWE-bench Verified from PR descriptions alone, though human review remains necessary for architectural fit.

Three core principles

1. Keep it simple—don't add complexity for its own sake. 2. Prioritize transparency—show the agent's planning steps explicitly. 3. Carefully craft your ACI—invest in tool documentation and testing as much as in human-facing interfaces.

Closing thought

> "Success isn't about building the most sophisticated system; it's about building the right one."

Many teams pick a complex agent framework first and try to force their problem into it. The correct order is the reverse: understand what the problem needs, then choose the lightest tool.

Reference: Building Effective Agents (Anthropic, 2024-12-19), https://www.anthropic.com/engineering/building-effective-agents, with sample implementations in the Anthropic Cookbook.