Anthropic CCA-F: What the Architect Exam Tests

Designing a useful Claude application is one challenge; designing a system that continues to behave predictably when tools fail, context changes, and real users arrive is another. Anthropic’s Claude Architect Foundations certification focuses on that second responsibility. It assesses the decisions involved in building Claude-based agent systems, including orchestration, tool boundaries, Claude Code workflows, structured outputs, and reliability. The person it addresses is not merely a proficient Claude user but someone expected to explain why a particular architecture is appropriate and how it will hold up in production.

That distinction matters because Anthropic also offers Claude Certified Associate: Foundations, a separate credential for people who use Claude in everyday professional work. Anthropic CCA-F means Claude Certified Architect – Foundations, a credential separate from Claude Certified Associate – Foundations. Anthropic Partner Academy currently requires candidates to belong to an eligible Claude Partner Network organization and use a recognized company-domain email. The official Architect Foundations exam page and FAQ—not a third-party product listing—govern registration and delivery. The current Architect Foundations examination has five published content domains, so preparation should be guided by concrete design responsibilities rather than generic prompt-writing advice.

Those domains are Agentic Architecture & Orchestration (27%), Tool Design & MCP Integration (18%), Claude Code Configuration & Workflows (20%), Prompt Engineering & Structured Output (20%), and Context Management & Reliability (15%). The percentages describe the issuer’s published exam emphasis, not a recommendation to spend exactly that percentage of study time on each subject. A candidate who already writes robust tool integrations but has never operated a multi-step agent may need to allocate practice differently.

The architectural decision comes before the agent

The heaviest domain, agentic architecture and orchestration, starts with a question that is easy to skip: does the problem actually need an agent? A fixed workflow can take a customer request, classify it, retrieve relevant policy documents, and produce a structured draft using predetermined steps. It may be simpler to test and easier to control than an agent allowed to choose its own sequence of tool calls. An agent becomes more defensible when the next action cannot be specified in advance—for example, when investigating a software failure requires selecting diagnostics based on what previous checks revealed.

Good architecture therefore distinguishes a single model call, a fixed multi-step workflow, an agent loop, and a collection of collaborating agents. None is automatically more advanced in the sense that matters to a user. Every additional decision point consumes time, increases opportunities for errors, and demands clearer state management. A team investigating support tickets might benefit from routing straightforward requests through predictable paths while reserving bounded agentic investigation for unusual cases. The design is stronger because autonomy is selective, not because every request enters the most complex system.

Once an agent is justified, the architect must specify what it observes, which actions it may request, where its working state lives, and what causes it to stop. Suppose an assistant is reconciling two inconsistent inventory reports. If one data source becomes unavailable, should it retry, switch to a known backup, return a partial answer, or escalate to a person? A design that says only ‘keep trying until the task is done’ has no credible boundary for cost, latency, or failure. Set call and time budgets, preserve the evidence behind decisions, and identify a termination or escalation path before letting the agent operate.

Multiple agents introduce another layer of tradeoffs. Splitting research, implementation, and review among specialists can make sense when work can proceed independently and the outputs have clear contracts. For a narrow transaction, the same arrangement may waste tokens and make accountability murky. A coherent agent orchestration design explains what each participant owns, how context is transferred, how contradictory recommendations are resolved, and which component has authority to commit the final result. It does not assume that adding reviewers guarantees correctness.

Tools and MCP define where model reasoning ends

Tool integration is the point where a language-model application can affect systems outside the conversation. Claude may propose a database query, a calendar update, or a code change, but the surrounding software decides whether the operation actually runs. In a client-executed tool cycle, the application receives a structured request, checks it, performs an authorized operation, returns the result, and allows the model to continue. The security boundary sits in that application code, not in an instruction asking the model to behave responsibly.

A well-designed tool has a specific purpose and clear inputs. Consider a customer-service agent that can read an order, issue a refund, and send a confirmation. These should not be one broad ‘manage customer’ tool with unrestricted parameters. Reading an order is different from moving money. The refund operation needs independent authorization, bounded amounts, idempotency checks, and an audit record. Even a tool call that perfectly matches its declared JSON schema can request an action the current user is not allowed to perform. Schema validity is necessary for integration, not sufficient for security.

Model Context Protocol, or MCP, standardizes how applications expose tools and other capabilities to compatible clients. That can reduce custom integration work, but standardization does not settle which servers to trust or which permissions to grant. Architects still need to inspect the capabilities offered by a server, the scope of its credentials, the sources of content it returns, and the possible consequences of invoking its tools. A seemingly harmless retrieved document can contain adversarial instructions; it must remain untrusted data rather than become system authority.

Good MCP tool design also considers failure semantics. What happens if a tool times out after committing a write? Retrying blindly may duplicate a transaction. What if a tool responds with partial records or an unfamiliar schema version? The agent should not be invited to invent missing fields. Separate retryable reads from potentially irreversible writes, preserve operation identifiers, and return errors in a form the orchestrator can handle. The exam’s tool-integration domain is best understood through these design questions rather than memorizing a directory of connector names.

Claude Code belongs inside the engineering workflow

Claude Code adds a different architectural surface: a coding agent that operates amid repositories, commands, project instructions, testing systems, and developer permissions. A candidate who understands the Claude API but has never thought about repository-level control can miss how strongly the surrounding engineering workflow influences the quality of a coding agent’s decisions. The relevant question is not just whether Claude can edit a file. It is how a team specifies the task, restricts the environment, reviews the resulting changes, and obtains evidence that the code behaves as intended.

Project instructions and configuration help establish conventions that an agent can use consistently: where tests live, which package manager is expected, which modules own particular responsibilities, and how to report failures. They are not a substitute for enforced repository permissions. A command that can modify deployment secrets or run privileged scripts needs operating-system and workflow controls, whether or not instructions forbid the action. Hooks, approval boundaries, and CI checks are useful precisely because they operate outside the model’s prose.

Imagine an agent asked to update an authentication library in a large application. It discovers affected files, edits dependencies, and sees a passing unit test. An architect should ask what the test actually covered. Were integration contracts exercised? Did a configuration change introduce a broader permission? Can the patch be reviewed and rolled back? The workflow needs a diff, targeted tests, reproducible commands, and a human or automated release gate that examines the risky effects of the change. Passing one test is evidence, not blanket authorization for deployment.

Claude Code configuration also intersects with context management. A repository can contain far more files and history than are useful for one task. Feeding all of it to an agent can obscure the relevant interfaces and increase cost. Better Claude Code workflows expose the necessary project guidance, retrieve or inspect files as needed, and keep execution logs clear enough for a reviewer to reconstruct the work. The architect has to design that workflow, not merely hope a tool-using model will discover one.

Prompting and structured output are application contracts

Prompt engineering matters in Architect Foundations, but the emphasis is different from experimenting with clever wording in a chat interface. A production prompt has a role within a system: it communicates task boundaries, supplies relevant context, requests an output shape, and identifies uncertainty. The surrounding application must still define its actual permissions, data handling, and acceptance criteria. A prompt that says ‘never reveal private information’ cannot enforce access control if an unrestricted retrieval tool exposes that information in the first place.

Architects must distinguish instructions from content. A policy document retrieved for summarization may contain a sentence telling an assistant to ignore earlier requirements. In the application, that document remains evidence to interpret, not a fresh command channel. Defensive design combines instruction hierarchy, narrow retrieval, source attribution, and explicit tool policies. The objective is to keep the model useful when the data is messy without granting external text control over the workflow.

Structured outputs are especially important when the model’s response feeds another service. If a claims assistant must return a case identifier, a recommended route, a confidence indicator, and supporting reasons, those fields should have defined types and constraints. A valid JSON object is only the beginning: the application must still verify that a case ID exists, that the route is permitted, and that the cited evidence supports the decision. Strict schema-constrained tool inputs can prevent malformed arguments; they cannot certify that an otherwise well-formed decision is appropriate.

The deepest lesson is that reliability is shared between the model and ordinary software. Use code to enforce invariants that must never be optional. Use prompts for interpretation where judgment is needed. Evaluate the combined system, not a sample answer in isolation. This relationship between prompt and context engineering becomes clearer when a design is tested with incomplete records, contradictory sources, unusual formats, and malicious instructions rather than only tidy examples.

Context is a reliability budget, not an unlimited memory

Context management and reliability account for a smaller share of the published blueprint than agentic architecture, but problems in this area can quietly undermine every other component. Models operate on the information made available to them in a particular interaction. The fact that an application stores a document, an earlier message, or a tool result somewhere does not mean the model currently has it. Architects need to know which context is included, how it is selected, which parts have priority, and what is lost as an interaction grows.

Long context can be useful for analyzing a compact body of closely connected material. Retrieval can be better when a system needs selected evidence from a large changing collection. Neither approach is universally superior. A retrieval system may omit the decisive document; a very long prompt may drown the key exception in irrelevant content. Good design uses task-specific retrieval tests, source freshness checks, and citation or evidence tracking so that answers can be traced to what the model actually saw.

Compaction, summarization, caching, and state persistence introduce additional failure modes. A summary can preserve the broad objective while dropping a constraint that matters three steps later. Cached material can become stale, and an agent may treat an earlier tentative result as verified fact. For a high-value workflow, retain durable machine-readable state where possible—completed actions, pending approvals, immutable IDs, and relevant evidence—rather than relying entirely on a conversational summary. A practical study exercise is to interrupt an agent halfway through a task and test whether it can resume without repeating an irreversible operation.

Reliable systems also have a plan for degradation. When retrieval fails, they may report uncertainty instead of fabricating a source. When model output violates a schema, they may retry within a limited budget or escalate. When a tool returns an unexpected permission error, they should stop rather than discover an alternate route around the restriction. Linking Claude evaluations to these edge cases turns context management from a token-count optimization into a measurable engineering discipline.

Scenario questions test the quality of a design decision

Anthropic’s current Architect Foundations listing describes a 120-minute exam that includes multiple-choice and multiple-response items. It publishes a scaled passing score of 720 on a scale of 100 to 1,000. That number is not interchangeable with getting 72 percent of the questions correct: scaled scoring and raw item counts are different measures. Candidates should use the current issuer listing for booking and delivery details, especially because access and program policies can change.

The most useful way to approach an architecture scenario is to extract the constraints before considering the technologies. Identify the outcome required, the data sensitivity, permitted side effects, latency ceiling, reliability target, and likely operational failures. Then compare architectures against those constraints. A multi-agent design may provide specialized reasoning but fail a tight response-time objective. A single prompt may be fast but lack the tool access needed for a live status check. The correct decision is the one whose tradeoffs fit the case, not the option containing the most recognizable feature names.

For example, consider a travel-support assistant that may read an itinerary but cannot change a booking without explicit customer confirmation. A response that proposes an unrestricted booking tool would violate the trust boundary even if it used excellent retrieval and produced polished JSON. A sound design separates read-only investigation from a confirmation-gated write, keeps the customer’s identity bound to the operation, and records what was changed. If the booking service fails after a request is sent, the application checks transaction status before retrying. Several exam domains meet in that one scenario: orchestration, tool schemas, security, reliable state, and output contracts.

When studying architecture scenarios, explain why rejected designs would fail a stated constraint. That discipline exposes weak understanding more quickly than memorizing an answer pattern. It also resembles real design review, where the important question is often not whether a proposed system can work, but whether it can be operated, audited, and repaired when conditions change.

Choose the credential that matches the responsibility

Anthropic’s program now distinguishes four different roles. Claude Associate Foundations covers effective everyday use of Claude. Claude Developer Foundations addresses developers building applications with its API and tools. Architect Foundations is aimed at the person making system-level design choices, while Claude Architect Professional extends into enterprise integration, governance, and evaluation at larger scale. These descriptions are about the work being assessed; they should not be flattened into a mandatory ladder that every candidate must follow in the same order.

A professional whose daily work is writing, analysis, or project communication may find Associate Foundations closer to the tasks they perform. An engineer building application features may be better served by the Developer route. Architect Foundations fits someone who must decide when a tool is safe, how an agent retains state, what failures can be tolerated, and how the overall solution will be tested.

At the time of Anthropic’s published program guidance, certification exams were offered through the Claude Partner Network with supervised, identity-verified delivery. Candidates should check current eligibility and booking details through Anthropic rather than assume that access, fees, or a code used on a preparation website guarantees registration. The Architect Foundations certificate is evidence of a defined body of technical judgment, but its practical value depends on whether the holder can apply that judgment to real constraints.

The central skill is the ability to defend an architecture. A dependable Claude solution has a reason for using an agent instead of a fixed workflow, a clear boundary between model reasoning and system authority, explicit contracts for tool calls and outputs, controlled context, and a realistic account of failure. Those are the decisions that connect the Architect Foundations exam to production engineering—and the decisions worth practicing long after the test is over.

img