Anthropic CCA-F: Preparing for Architect Foundations

The most useful way to prepare for Claude Certified Architect – Foundations is to build a small system, put it under pressure, and explain why its design still makes sense when something goes wrong. The Claude Architect Foundations exam is about decisions involved in designing Claude-based solutions, not merely writing better prompts for everyday office tasks. This practical preparation approach covers agentic orchestration, tools and MCP, Claude Code workflows, structured outputs, and context reliability. A study plan that never exercises those boundaries is preparing for the wrong kind of work.

Anthropic CCA-F is Claude Certified Architect – Foundations. It is the architect credential, not an additional or competing exam designation. It is distinct from Claude Certified Associate – Foundations and Claude Certified Developer – Foundations. As of October 2026, Anthropic says the certification exams are available to people at Claude Partner Network organizations using an eligible company-domain email; they are not an open public booking option. Confirm current eligibility through the issuer before scheduling or paying.

Anthropic’s published Architect Foundations blueprint gives candidates five weighted areas to practice: Agentic Architecture and Orchestration (27%), Claude Code Configuration and Workflows (20%), Prompt Engineering and Structured Output (20%), Tool Design and MCP Integration (18%), and Context Management and Reliability (15%). Those weights establish priorities, but they do not replace practicing how the decisions interact. Build one small runnable system, test its failure paths, and use the results to identify the design choices you cannot yet defend.

Begin with one system you can explain end to end

Pick a bounded application that is complex enough to expose architectural decisions but small enough to rebuild. A support assistant that classifies cases, retrieves policy information, drafts responses, and escalates sensitive requests is a good choice. A release assistant that analyzes a code change, runs tests, and prepares a review summary can serve the same purpose. Resist turning the exercise into a showcase of every available agent framework. You need a reference design whose data, permissions, outputs, and failure points you understand.

Before writing code, draw the decision path in plain language. What does the model receive? Which steps are deterministic? What information must be fetched? Which operation has a side effect? Who can approve that side effect? What happens when the model lacks evidence? Those questions form a baseline against which every later change can be measured. If the design contains an agent, specify its available actions, retained state, limits, and stopping criteria. An unbounded loop is not a more capable system; it is an unfinished control design.

Make one version that uses a predictable workflow and a second that introduces bounded model-directed action only where it adds value. Compare completion quality, error handling, elapsed time, and execution cost. If the agent achieves the same results more slowly and with more failure modes, document why the fixed path may be the better architecture. This is a central habit for an architect: prefer a demonstrated improvement over an impressive diagram.

A useful baseline review has another purpose. It reveals which terms you can repeat but cannot yet apply. Candidates sometimes know what a tool call or subagent is but struggle to explain where its authority comes from. They may describe retrieval-augmented generation without being able to test whether retrieval found the correct source. Note those gaps immediately. The rest of the study plan should produce evidence that you can make and defend the missing decisions.

Use agent loops to practice bounded autonomy

For agentic architecture practice, start by implementing a simple observe-decide-act loop with a narrow task and a small set of tools. Record each action, the data that informed it, and the condition that ends the loop. Then deliberately introduce an unexpected tool response. The purpose is not to see whether Claude can improvise a plausible message. It is to find out whether the application can distinguish a temporary problem from an unsafe or final state.

Practice failures that change what the agent should do. A source may return stale information, a search may yield nothing, an operation may time out after committing a write, or two pieces of evidence may disagree. For each case, write the acceptable behaviors before running the test. Perhaps a read can be retried twice, while a refund must be checked for an existing transaction identifier before any resubmission. Perhaps an ambiguous case must be returned for review. Explicit recovery rules are more valuable than instructions telling the model to be careful.

Only after the single-agent version is observable should you experiment with additional participants. Assign one agent to gather evidence and another to critique a proposed response, with a strict contract governing what each may see and return. Then evaluate whether separation genuinely improves results. If reviewers share the same missing source or misconception, multiplying agents may multiply agreement without increasing truth. The value of agent orchestration comes from clear roles and controlled exchanges, not the sheer number of autonomous actors.

The strongest practice question to ask yourself is: what would make me stop using an agent here? A workflow whose steps have become stable might be simplified. A low-risk drafting task may not need an elaborate approval engine. Conversely, a task that modifies sensitive systems may require explicit gates even when an agent produces consistently good responses. Your answer should reflect the actual constraints, not enthusiasm for one implementation pattern.

Build a tool that cannot casually exceed its authority

When practicing tool design and MCP integration, create two distinct capabilities: one that only reads information and one that would change something outside the conversation. A status lookup and a ticket update are a useful pair. Describe their inputs and outputs precisely. Require a stable record identifier, declare which fields may be changed, and define how errors are returned. Keep the update operation out of the model’s reach until authorization can be established independently.

Model Context Protocol offers a standard interface for connecting tools, resources, and related capabilities, but it does not grant automatic trust to an integration. Try exposing your read-only capability through a small MCP server and inspect what the client discovers. Then consider what would happen if the server returned instructions inside what should be ordinary data. The agent must not treat an external document or tool result as permission to ignore higher-level rules. Authenticated access, input validation, and audit records remain responsibilities of the application and the connected service.

Test malformed parameters, unexpected record IDs, expired credentials, duplicate requests, and timeouts. If a tool uses strict JSON Schema inputs, check that correctly formed data can still represent an unauthorized action. A valid schema protects the shape of a call; it does not decide whether the caller has permission to change a booking or access a customer’s account. This difference is at the center of safe MCP tool design.

One useful extension is to reduce tool exposure dynamically. A request to summarize a case does not need refund authority merely because the application supports refunds in another workflow. Loading the minimum relevant capabilities makes selection simpler and limits the consequences of a mistaken call. Record which tools were offered, which were selected, and why a sensitive operation was allowed. If that reasoning cannot be reconstructed after a failure, the integration needs more work.

Make Claude Code produce reviewable changes

For Claude Code configuration and workflow practice, treat the topic as an engineering governance exercise, not a list of command names. Create a small repository with a test suite, a documented development convention, and a deliberately imperfect implementation. Give Claude Code a request that requires reading source files, changing behavior, and demonstrating that the change is correct.

Project-level instructions can state which commands are expected, how the repository is organized, and which coding standards to follow. Hooks and workflow policies can introduce checkpoints that are enforced outside ordinary chat prose. Experiment with instructions that are clear enough to help the agent but do not grant it authority to run unrestricted shell operations. Put secrets outside the test environment, use a limited working directory, and require explicit approval for destructive actions. The key point is that a repository is not an isolated conversation: it contains resources, privileges, and downstream release processes.

Assess the resulting change as a reviewer would. Examine the diff rather than the agent’s summary alone. Run appropriate tests, look for unintended edits, and verify behavior at the boundaries of the request. If a dependency upgrade passes a unit test but changes an authorization default, the work is not complete. A mature Claude Code workflow produces evidence that a person or automated gate can independently inspect, including an accurate account of tests that failed or were not run.

Repeat the exercise with limited context. Hide an important implementation detail in a separate file that the agent must discover, and observe whether its file-inspection process is targeted. Then interrupt the workflow and resume it from preserved state. This exposes how project instructions, tool permissions, local context, and recovery intersect. A candidate who can explain those interactions is learning architecture rather than memorizing a product interface.

Test prompts and structured outputs as a complete contract

Prompt engineering and structured output are equally useful areas to test. For this domain, have the reference application return a structured decision to another component rather than a free-form answer for a person to read. Define a schema with a case identifier, decision category, evidence references, and an explicit indication that human review is required when a rule is not satisfied. Use realistic examples with incomplete and contradictory data, not only ideal inputs.

Write the prompt so the model has a clear task, relevant context, and limits on what may be inferred. Then separate its responsibilities from the application’s. Claude can interpret a customer’s explanation and propose a category; application code should verify the case identifier, allowed transition, and permission to apply an update. If the model returns syntactically valid JSON but cites an unrelated policy, the answer is still wrong. If an output omits required evidence, schema or policy checks should reject it instead of silently filling in the gap.

Challenge the system with retrieved text that contains adversarial directions, a document with a conflicting date, and instructions that sound authoritative but come from the wrong source. Observe whether the system preserves the distinction between trusted instructions and untrusted material being analyzed. Strengthen it with source attribution, retrieval controls, structured validation, and explicit fallback behavior. This is where context engineering becomes a system-level concern rather than a prompt-writing trick.

Make one evaluation focus on a safety boundary, another on factual fidelity, and a third on integration behavior. A model can produce a beautifully formatted incorrect decision; a schema can accept values that should never trigger a side effect. Reliable architecture requires both semantic evaluation and mechanical enforcement. Keep failed examples in a repeatable test set so the next prompt or model change is checked against the same problems.

Deliberately overload the context and break the dependencies

Context management and reliability are important cross-cutting skills, but its problems can weaken every other domain. Start by giving the reference application more material than it needs. Mix relevant policy excerpts with obsolete versions, duplicates, long logs, and contradictory summaries. Compare directly including a large collection in context with retrieving only the evidence needed for a question. The useful result is not a blanket claim that long context or retrieval always wins. It is an account of which approach preserved the needed evidence under your workload.

Next, study persistence across a sequence of interactions. An agent may need to remember that a customer approved a particular action, or that a tool already committed a transaction. Those are pieces of operational state, not merely conversation memories. Keep durable identifiers and status in controlled storage. When you compact or summarize an interaction, test whether the surviving context preserves what the next step requires. If a summary drops a constraint, the design should make the omission discoverable rather than allow the model to improvise.

Introduce failures that force a safe choice: a retrieval server is unreachable, a tool responds slowly, a previously used source has been revoked, or a model output fails validation. Specify retry ceilings and escalation paths in advance. For high-impact actions, let the system stop and request review instead of searching for an alternative way around a restriction. A reliable workflow should behave sensibly when it cannot complete the ideal path, not just when every service works.

Use Claude evaluations to preserve evidence of these tests. Record the input, system state, expected acceptable behavior, observed tool calls, and actual outcome. Compare changes to both correct completion and failure handling. If a model update makes simple answers better but causes the agent to overuse a write-capable tool, the regression is architectural. The case is not resolved by praising the overall quality of the answers.

Convert the labs into timed architecture judgments

Anthropic’s current Architect Foundations page lists 60 questions, a 120-minute exam (approximately 135 minutes of seat time), a scaled passing score of 720 on a 100–1,000 scale, and a $125 USD list price before any partner discount. Delivery is online proctored or at a Pearson test center for eligible candidates. Those are issuer-published program parameters, not proof of your own booking access or a guarantee that a third-party question set matches the current blueprint. Use the official sample-question style to rehearse architecture judgments: identify constraints, authority, failure recovery and the reason to reject a plausible alternative.

For a support-assistant scenario, one proposed answer may add multiple agents, another may give the model broad account access, and a third may use a simpler retrieval workflow with a confirmation-gated update. Do not choose by feature count. Ask which solution satisfies the stated latency, security, audit, and accuracy requirements. Explain why each rejected option violates an actual condition or adds a cost without a compensating benefit. This process is more transferable than remembering how a single example was answered.

Build your own practice scenarios from the systems you tested. Change one constraint at a time: remove write permission, impose a tighter latency budget, introduce a partial tool failure, increase document volume, or require a human to approve a sensitive transition. Then note whether your architecture choice changes. If it never changes despite materially different requirements, the reasoning may be too attached to a preferred pattern.

The final readiness check should be practical. Can you distinguish Associate, Developer, and Architect scope without resorting to labels alone? Can you justify an agent over a workflow, design a narrow tool boundary, explain a Claude Code review path, and trace a structured decision to supporting evidence? Can you describe how your application degrades when sources or permissions fail? Those are the kinds of capabilities the exam’s domains reward, and they also make an actual Claude system easier to trust.

Check eligibility before committing to an exam date

CCA-F registration and identity verification are controlled by Anthropic and its exam-delivery partners. A non-partner reader should not assume direct exam eligibility or purchase access from a study article. Check the current Anthropic Partner Academy registration information for your organization rather than inferring access from an older certification chart or an unverified ExamCollection exam-product URL. Architect Foundations sits within a wider role-based program. Claude Associate Foundations concerns reliable everyday professional use, while Claude Developer Foundations focuses more directly on application-building with Claude. Architect Foundations assesses design responsibility across the system.

Keep the study plan anchored to demonstrated ability. A personal note that says ‘review MCP’ is too vague to reveal whether you can use it safely. A passing test that shows a read-only MCP tool stays read-only under adversarial inputs is meaningful evidence. A diagram of an agent loop is less persuasive than a run log showing that the system stops after a bounded failure and does not duplicate a transaction. The difference is what makes Architect Foundations preparation worthwhile: you are preparing to make production decisions that someone else can examine and trust.

img