Anthropic Architect: Professional

Claude has to work inside existing systems. You compare integration patterns for APIs, events and batch processes, connect to systems of record through tools and MCP, and carry user identity through every call.

• Request-response, event-driven and batch integration
• Gateways and a shared access layer for model calls
• Connecting systems of record with tools and MCP servers
• Propagating user identity and permissions
• Idempotency, retries and error handling across systems
• Designing for partial failure

You build An integration reference architecture for one enterprise, with three worked flows.

Many teams will build on Claude. You decide between direct API access and cloud platforms, plan regions, quotas and data residency, and design shared services so that each team does not rebuild the basics.

• Direct API and cloud-platform hosting compared
• Regions, residency and network paths
• Quotas, rate limits and capacity sharing
• Shared services: gateway, prompt library and evaluation
• Multi-tenant isolation
• Platform team and product team responsibilities

You build A platform blueprint that shows shared services and team boundaries.

Large workflows involve many agents and many owners. You design orchestration, shared state and handoffs across teams, set boundaries between agents, and keep a system of agents traceable and debuggable.

• Orchestration across teams and systems
• Shared state, memory and handoffs
• Boundaries and permissions between agents
• Skills and reusable components at scale
• Tracing work across agents
• Failure containment and recovery

You build A multi-agent architecture for a cross-department workflow, with its trace design.

Governance turns good intentions into controls. You define acceptable use, risk tiers, approval gates, roles and exception handling, and write policy that teams can follow without slowing every release.

• Acceptable-use policy for AI
• Risk tiers and the controls each requires
• Approval gates and review boards
• Roles: owners, reviewers and operators
• Exception handling and escalation
• Measuring policy adoption

You build A governance framework with risk tiers, gates and role definitions.

At enterprise scale, every weakness is multiplied. You apply least privilege, secrets management and data classification, defend against prompt injection through tools and documents, and set retention and audit rules.

• Data classification and what may reach a model
• Least privilege for agents and tools
• Secrets, credentials and key handling
• Prompt injection through tools, files and web content
• Audit logs and retention
• Privacy and regulatory duties

You build A security architecture review with a threat model for one agent platform.

Evaluation must scale beyond one team’s notebook. You design shared test sets and graders, gate releases on results, monitor quality in production, and decide how human review fits in.

• Evaluation strategy for a portfolio of systems
• Shared test sets and golden examples
• Model-graded and code-graded checks at scale
• Release gates and regression suites
• Online monitoring and sampling
• Human review capacity and calibration

You build An evaluation program design with release gates for a portfolio of systems.

Usage grows faster than budgets. You forecast spend, plan for rate limits, use caching, batching and model routing to control cost, and set reliability targets with fallbacks for when a service degrades.

• Forecasting usage and spend
• Cost controls: caching, batching and routing
• Capacity and rate-limit planning
• Reliability targets and fallbacks
• Degraded-mode behavior
• Showing teams their own cost

You build A cost and capacity model with reliability targets for a growing platform.

Models, prompts and tools all change. You manage version transitions, re-evaluate before each move, control prompt and configuration changes, and plan model retirement without surprises for users.

• Versioning models, prompts and tools
• Migrating to a new model safely
• Change control and approval
• Re-evaluation triggers
• Deprecation and retirement planning
• Communicating change to users

You build A change management process with a worked model migration plan.

Someone must answer for what an agent does. You define human oversight for high-stakes steps, assign accountability, prepare incident response for AI failures, and keep records that stand up to review.

• Human oversight by risk level
• Accountability and decision records
• Detecting and classifying AI incidents
• Incident response and communication
• Post-incident learning
• Preparing for audits and regulators

You build An oversight model and an incident playbook for AI failures.

Architecture fails without people. You set up a platform team or center of excellence, train builders and users, share patterns, and measure whether adoption delivers value across the enterprise.

• Centers of excellence and platform teams
• Reusable patterns and reference implementations
• Training builders and everyday users
• Funding and chargeback models
• Measuring adoption and value
• Communities of practice

You build An enablement plan with training paths, patterns and success measures.

Produce the artifacts a large enterprise would need. You design the integration, governance, security and evaluation model for one organization, test it against hard scenarios, and defend it to a review panel.

• Analyzing a large-enterprise scenario
• Designing integration and platform
• Defining governance, security and evaluation
• Stress-testing against failure scenarios
• Presenting and defending the architecture

You build An enterprise reference architecture with a governance pack, evaluation program and rollout plan.