Anthropic Architect: Foundations

Good architecture starts with the right question. You gather requirements, decide whether an LLM is the right tool, define success and constraints, and turn a vague request into a scoped solution with measurable goals.

• Discovery questions that expose real requirements
• Deciding whether a task needs an LLM
• Defining success measures before building
• Constraints: data, latency, cost and compliance
• Scoping a first release
• Writing a solution brief

You build A solution brief for a client use case, with scope, success measures and constraints.

In an agent system, context is the main design surface. You structure system prompts, examples and output formats, and decide what goes into the context window and what stays out of it.

• System prompts that set role and rules
• Structured instructions and XML-style tags
• Examples and their cost
• Structured output for downstream systems
• Context engineering: what to include and omit
• Versioning prompts like code

You build A prompt and context design for one agent, with its output format and a version history.

Tools let Claude act. You design tool schemas that Claude uses correctly, decide what to expose through MCP, and handle results, errors and permissions at the boundary with client systems.

• Designing tool names, schemas and descriptions
• Handling tool-use blocks and results
• Errors and retries in tool calls
• Exposing capabilities through MCP servers
• Permissions and least privilege for tools
• Choosing tools or built-in capabilities

You build A tool set and MCP server design for a client system, with a permission model.

Not every task needs an agent. You compare chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer designs, and pick the simplest pattern that meets the requirement.

• Workflows against agents
• Prompt chaining and routing
• Parallelization
• Orchestrator-workers
• Evaluator-optimizer loops
• Choosing the simplest pattern that works
• Subagents and context isolation

You build An architecture decision record that selects a pattern for three client scenarios.

Agents are limited by what they can see. You design retrieval pipelines, use citations to ground answers, manage long contexts with caching and summarization, and give agents memory that survives a session.

• Retrieval design: chunking, embeddings and keyword search
• Combining search methods and reranking
• Citations and grounded answers
• Prompt caching for repeated context
• Summarizing and trimming long sessions
• Memory across sessions

You build A knowledge-access design for an agent, with retrieval, citation and memory choices explained.

Turn a design into a working system. You use the API and SDKs, extended thinking, files, batch processing and streaming, and choose between direct API access and a cloud platform such as Bedrock or Google Cloud.

• API and SDK building blocks
• Extended thinking for harder tasks
• Files, images and PDF input
• Streaming and batch processing
• Claude through Bedrock or Google Cloud
• Using Claude Code as part of a build process

You build A working prototype of the designed agent, built on the API.

A demo proves little. You build test sets from real tasks, grade outputs by code and by model, measure agents on whole tasks, and use the results to decide whether a change is an improvement.

• Building a test set from real tasks
• Grading with code and with a model
• Measuring end-to-end task success for agents
• Regression testing prompts and tools
• Human review and sampling
• Reporting results to a client

You build An evaluation suite for the prototype, with graded results and a regression run.

Systems that act must be hard to misuse. You design against prompt injection, limit data exposure and tool power, add human approval where stakes are high, and plan for the failures that still occur.

• Prompt injection and untrusted content
• Least-privilege tool and data access
• Human approval and escalation points
• Handling sensitive and personal data
• Content and behavior safeguards
• Incident response for AI features

You build A threat model and safeguard plan for an agent system.

Production adds constraints a prototype ignores. You manage rate limits, latency and spend with caching and model choice, add logging and tracing, and plan rollout, monitoring and change over time.

• Latency and cost budgets
• Rate limits, retries and fallbacks
• Caching, batching and model routing
• Logging, tracing and observability
• Rollout, versioning and rollback
• Monitoring quality after launch

You build A production readiness checklist and cost model for the prototype.

Design one agent solution as you would for a client. You scope it, choose the pattern and tools, prototype and evaluate it, address safety and operations, and present the architecture and its trade-offs.

• Scoping the client problem
• Choosing the architecture
• Prototyping and evaluating
• Covering safety and operations
• Presenting and defending the design

You build A complete solution package: brief, architecture, prototype, evaluation and launch plan.