How Anthropic Builds Effective AI Agents: Practical Patterns and Principles

Core Insight

The most successful agents rely on simple, composable patterns rather than heavyweight frameworks; start with the simplest solution and only add complexity when necessary, weighing latency and cost against performance gains.

Workflow vs. Agent

Anthropic separates two concepts:

Workflow : a predefined code path that orchestrates tools and steps.

Agent : the LLM decides autonomously how to complete a task and dynamically controls tool usage.

Simple, well‑structured tasks are best handled with a workflow, while open‑ended problems require an agent.

Building Block: Enhanced LLM

An effective agent rests on an LLM equipped with retrieval, tool‑calling, and memory capabilities, allowing it to generate search queries, select appropriate tools, and decide what information to retain.

Five Architecture Patterns

1️⃣ Prompt Chaining

Idea: Decompose a task into sequential steps, feeding each step’s output to the next, optionally inserting guard checks.

When to use: Tasks that can be clearly split into fixed subtasks and where latency can be traded for accuracy.

Examples: Generate marketing copy then translate it; write an outline, verify it, then expand into a full document.

2️⃣ Routing

Idea: Classify input first, then route it to a specialized processing pipeline.

When to use: Tasks with clear classification boundaries and distinct handling strategies.

Examples: Customer‑service triage (general inquiry / refund / technical support); cheap queries to a small model, complex ones to a larger model.

3️⃣ Parallelization

Idea: Run multiple LLMs on subtasks concurrently and aggregate results. Two variants: Sectioning (independent subtasks) and Voting (same task multiple times, then consensus).

When to use: Subtasks can be parallelized for speed and multiple perspectives improve confidence.

Examples: One model handles a user request while another performs content‑safety checks; multiple prompts review code from different angles.

4️⃣ Orchestrator‑Workers

Idea: A central LLM dynamically breaks a task into subtasks and assigns them to worker LLMs; unlike parallelization, subtasks are not predefined.

When to use: The number of subtasks cannot be predicted in advance and task complexity varies with input.

Examples: Simultaneously edit multiple files; gather and analyze information from many sources.

5️⃣ Evaluator‑Optimizer

Idea: One LLM generates output, another evaluates it and provides feedback, forming an iterative improvement loop.

When to use: Clear evaluation criteria exist and iterative refinement yields measurable gains.

Examples: Literary translation where an evaluator suggests subtle improvements; complex search where the evaluator decides whether further searching is needed.

What Makes a Real Agent

When an LLM can reliably understand complex inputs, plan, use tools, and recover from errors, it becomes production‑ready. The execution flow includes:

Start from a human instruction or dialogue.

After task clarification, plan and act independently.

At each step, obtain real feedback from the environment (tool results, code execution).

Pause at checkpoints or when blocked to await human input.

Terminate when the task is complete or a stop condition is met.

Key cautions: Autonomous agents increase cost and can accumulate errors; thorough sandbox testing and clear tool documentation are essential.

High‑Value Application Domains

Customer‑service – dialogue + tool calls + measurable success metrics.

Programming agents – code is verifiable, iterable, and objectively measurable.

Three Core Principles

1. Keep it Simple

Avoid unnecessary complexity; start with simple prompts and let evaluation drive optimization.

2. Prioritize Transparency

Expose the agent’s planning steps; opaque black‑box systems are hard to maintain.

3. Design a Robust Agent‑Computer Interface (ACI)

Invest as much effort in tool documentation as in prompt engineering; treat tool docs like developer‑facing docstrings.

Rule of thumb: the effort you spend on HCI should be matched by effort on ACI.

Frameworks vs. Bare‑bones Implementation

Many agent SDKs exist (Claude Agent SDK, AWS Strands, Rivet, Vellum). Anthropic advises using frameworks for rapid start‑up but not letting abstraction hide the underlying logic—most patterns can be built with a few LLM API calls.

Practical Insight: Tool Optimization Beats Prompt Optimization

When building the SWE‑bench agent, Anthropic found that time spent refining tools exceeded time spent refining prompts. A concrete issue was relative‑path failures after directory changes; forcing tools to use absolute paths eliminated the error entirely.

Takeaway: every detail of a tool definition—parameter names, clear descriptions, input formats, edge‑case handling—determines an agent’s reliability.

Conclusion

Success comes from building the system that best fits your needs, not the most complex one. Begin with simple prompts, iterate based on evaluations, and only introduce multi‑step agent architectures when simpler solutions fall short.