Free Claude CCDV-F Exam Questions (2026 Update)

Explanation

This question tests the context engineering principle of scoping context to each step. When a workflow has steps that must reason independently (i.e., without seeing full prior history), the correct technique is to isolate context per step — either by:

- Subagents: Spawning separate agent instances, each with its own freshly scoped context window containing only the inputs relevant to that step.

- Multi-step agentic workflows: Orchestrating discrete steps where each step receives a curated subset of context (e.g., only the outputs/handoffs it needs), rather than the entire accumulated transcript.

The key idea is: context is a scarce, curated resource — you pass each step only what it needs, which both enforces isolation and improves reasoning quality (less noise, less distraction, lower token cost).

Why the other options are wrong

Option A — "Augment with all available content at every step":
This is the opposite of isolation. Flooding every step with the entire prior history violates the requirement that some steps must not see prior conversation, and it degrades reasoning by introducing irrelevant context ("context rot"/distraction).

Option B — "Single global prompt for every step":
A global prompt doesn't isolate context at all; it just applies the same instructions everywhere. It says nothing about what history each step sees, so it fails to meet the requirement.

Option D — "Embed full prior history in each step regardless of need":
Explicitly contradicts the goal. Embedding full history everywhere means no step is isolated, and it wastes context budget on content a step doesn't need.

References

- Context engineering (Anthropic's framing): Treat the context window as a finite, carefully managed resource — curate, isolate, and hand off only relevant information between steps.

Explanation

This question tests the build-and-deploy lifecycle of an MCP server intended for multi-client, shared use. The correct approach is the standard, documented MCP server workflow:

1. Author the server — define the three primitives MCP exposes:
- Resources: Readable data/context (e.g., the internal data sources being exposed).
- Tools: Callable functions the model can invoke.
- Prompts: Reusable prompt templates.

2. Choose a communication pattern (transport) — select the appropriate MCP transport for the deployment model:
- stdio: For local, process-spawned servers.
- Streamable HTTP (or SSE): For remote/shared servers reachable over a network.

3. Deploy to an accessible hosting environment — since multiple Claude applications must integrate with it, the server must run somewhere reachable (a shared/remote host), not just locally.

Because the requirement is shared, multi-application access, you design the server once, generically, and deploy it to an accessible host so all clients can connect.

Why the other options are wrong

Option B — "Scope to the first app, extend per integration request":
This builds a client-specific server and grows it reactively. It's poor design for a shared server — it couples the server to individual consumers, duplicates or entangles definitions, and doesn't reflect MCP's intent of a reusable, capability-exposing server. It also risks inconsistent behavior across applications.

Option C — "Deploy only on individual developer machines":
Directly violates the requirement that multiple Claude applications can integrate with it. Local-only (e.g., stdio on a developer's laptop) is unreachable by other apps unless separately exposed through a network-accessible service.

Option D — "Bypass MCP and embed each data source directly in every app":
Throws away MCP entirely. It creates N separate integrations to maintain, duplicates logic, and defeats the purpose of a single server exposing the data sources once to all consumers.

References / Concepts

- MCP (Model Context Protocol) server primitives: resources, tools, and prompts.
- MCP transports: stdio (local) versus Streamable HTTP / SSE (remote, shared). The transport choice determines reachability.

Explanation

The symptoms described — declining focus and ignored earlier task constraints after approximately 20 tool calls — are classic signs of context bloat / "context rot." The conversation history has grown with accumulated tool outputs (often verbose), and the model's reasoning gets diluted by irrelevant or stale content. The fix is context engineering:

- Tool output pruning: Trim or summarize verbose tool results so only the useful information remains in context (e.g., collapse large JSON payloads, drop redundant fields, and keep key results).
- Compaction: Periodically summarize or condense older turns into a compact representation, preserving essential task state (constraints, decisions, and progress) while discarding low-value details.

The goal is to keep the active task state salient (so earlier constraints are still honored) while reducing the volume of older content that distracts the model. This directly addresses both symptoms: focus improves and earlier constraints stay visible.

Why the other options are wrong

Option A — "Remove tool calling entirely":
Overkill and destructive. Tool use is core to the agentic workflow; the problem isn't tool calling itself but unmanaged context growth. Removing tools eliminates the agent's ability to accomplish the task effectively.

Option C — "Just increase the context window":
A bigger window delays but doesn't solve the problem. More capacity doesn't fix focus — dumping full-detail outputs for every call still produces distraction and context rot, while costs and latency grow. Capacity does not equal relevance. This is the key distinction: more context is not necessarily better context.

Option D — "Restart every five tool calls":
Restarting loses all task state at each restart, which would cause constraint violations rather than fix them. The agent forgets its progress and instructions. You would trade focus problems for loss of continuity. A state-preserving restart or compaction is essentially option B done well; a blind restart is not.

References

- Context engineering (Anthropic): Manage the context window as a finite resource — curate, prune, and compact information.

Explanation

The problem is context drift: the model keeps surfacing stale but still-visible content from many turns ago, weighting it too heavily relative to the current task. The targeted fix is compaction — summarize older portions of the conversation into a condensed form. This:

- Preserves the gist — important long-term context (decisions, facts, constraints) is retained in summary form.
- Reduces the weight of stale specifics — verbose, outdated detail is collapsed, so the model no longer over-indexes on old-but-irrelevant content.

Compaction directly addresses drift because it keeps continuity while removing the salience of stale detail, rather than the all-or-nothing extremes in the other options. ✅

Why the other options are wrong

- A — "Increase the context window so all turns stay in full detail": This makes drift worse, not better. Keeping every old turn at full detail gives the model more stale content to weight heavily. Capacity isn't relevance — you don't fix over-weighting of old content by adding more of it.
- B — "Reset after every turn, losing all prior turns": Destroys conversation continuity entirely. The model would forget everything each turn — no multi-turn task is possible. It "fixes" drift by eliminating all context, which is not a solution.
- D — "Truncate to only the most recent turn": Also destroys continuity — the model loses all earlier context and can't track an ongoing task. Truncation is blunt; it drops the gist along with the specifics, unlike compaction, which retains the gist.

The distinction being tested: compaction (summarize → keep gist, reduce stale weight) vs. truncation/reset (drop → lose continuity) vs. expansion (add more → worsens drift).

References / concepts

- Context drift: model over-weights stale, no-longer-relevant content as history accumulates.
- Compaction: summarize older turns to retain essential meaning while reducing the volume and salience of stale specifics — a core context-engineering technique for long conversations.

Explanation

The key phrase in the scenario is that each step's output is "needed only briefly" — after the agent consumes it and moves on, that tool output is dead weight in the context window. The correct technique is tool output pruning: actively remove tool outputs once they've served their purpose and are no longer required by subsequent steps.

This directly addresses the problem: the cumulative irrelevant tool output stops filling the context window, freeing budget and reducing distraction/noise, while keeping the content that later steps actually need. ✅

Why the other options are wrong

- B — "Apply prompt caching to the accumulated tool outputs": Prompt caching reduces cost/latency for re-sending the same prefix — it does not reduce the volume of content in context. The stale tool outputs are still present, still consuming the context window, and still distracting the model. Caching solves a pricing problem, not the context accumulation problem. This is the key distractor: it sounds cost-smart but doesn't remove irrelevant content.

- C — "Switch to a smaller model, accept quality loss": This degrades capability to work around a context management problem that should be fixed directly. It's the wrong lever — you're trading quality for cost instead of pruning irrelevant content, and a smaller model may handle the workflow worse.

- D — "Keep every tool output indefinitely for a full record": This is exactly the anti-pattern causing the problem. Retaining all outputs "just in case" is precisely what fills the context window with irrelevant content. (If a durable record is genuinely needed, that belongs in external storage/logging — not the active context window.)

The distinction being tested: pruning (remove irrelevant content from context) vs. caching (cheaper re-send of the same content) vs. model downgrade (weaker reasoning) vs. hoarding (the cause of the problem).

References :

- Tool output pruning: remove tool results that later steps don't need — a core context-engineering technique for agentic workflows with many tool calls.

Explanation

Session lifecycle design must cover three distinct concerns the product team raised: when sessions expire, how state is reset, and how stale context is prevented from leaking into new conversations. Option A is the only choice that addresses all three explicitly. It treats lifecycle as a first-class concern — time- and/or event-based expiration, defined reset triggers (user action, idle timeout, error state, task completion), and fresh-session rules that guarantee a new conversation starts with a clean context window. Per-session scoping ensures one session's reset never affects others, and explicit isolation rules prevent old state from bleeding forward. This is defense in depth: multiple complementary mechanisms rather than a single blunt control.

Why other options are incorrect

- B reduces the entire lifecycle to a single fixed timeout — that covers only expiration, ignoring reset triggers and fresh-session rules. A timeout alone cannot prevent stale-context leakage between conversations.

- C includes expiration but omits automatic reset triggers, offloading freshness to users. If a user never manually starts over, stale context persists indefinitely — failing the "how state is reset" requirement.

- D has reset triggers but no per-session expiration, and applies resets globally — meaning one session's reset could wipe unrelated sessions. It also lacks fresh-session isolation rules.

References

- Anthropic, Building effective agents — workflows, state handoff, and scoped context between steps.

Explanation

Two requirements compete here: a hard constraint (customer data is subject to enterprise data residency policy) and a soft preference (ship quickly, avoid managing infrastructure). Residency is a compliance obligation, not a nice-to-have — so it must be satisfied before launch, while speed and operational convenience are negotiable. Option C correctly prioritizes the constraint: BYOC in your own AWS account keeps customer data within your controlled residency boundary, and the plan actively mitigates the soft preference's downside by partnering with the infrastructure team to reduce ops overhead. It respects the requirement instead of routing around it, and it addresses both sides of the tradeoff rather than sacrificing one.

Why other options are incorrect

- A — "Treat BYOC as a temporary pilot while presuming later migration to hosted infrastructure" — hosted deployment conflicts with the residency policy, so this defers an unavoidable compliance decision and assumes a migration that may never be permissible.

- B — "Deploy on hosted infrastructure first and seek a policy change afterward" — this inverts the priority by treating a compliance obligation as negotiable and risking violation during the gap.

- D — "Ship on hosted infrastructure and defer residency to post-launch review" — this knowingly launches in violation of stated policy, creating compliance exposure that later review cannot undo.

The tested principle: hard constraints outrank soft preferences, and the right answer mitigates the preference rather than compromising the constraint.

References

- Anthropic deployment options — hosted API vs. bring-your-own-cloud (BYOC) models and their data-handling boundaries.

Explanation

The scenario is precise: the context window is large enough, yet relevant information still gets buried as the conversation grows. This is context rot / attention dilution — a relevance problem, not a capacity problem. When 10–15 tool calls accumulate, earlier results remain technically present but lose salience against the volume of newer content. The fix is a context-management pattern: summarize or prune older tool outputs so they shrink and stay lightweight, while explicitly preserving the active task state (constraints, key findings, progress) so later steps still have what matters. This targets the actual cause — burying — by reducing noise and keeping signal salient. ✅

Why the other options are incorrect

- A — Switch frameworks hoping for "automatic" management: This outsources the fix to a tool without addressing why information is buried; the same accumulation pattern persists regardless of framework.

- B — Reduce tool calls by merging tools: This is a legitimate optimization, but it changes your tool architecture rather than managing context, and 10–15 calls will still accumulate enough content to bury relevant details.

- C — Increase the context window further: This is the trap option: the window is already large enough. More capacity adds more stale content to compete for attention, worsening burying rather than fixing it.

The tested distinction: capacity ≠ relevance — when content is present but buried, the answer is curation (summarize/prune), not more space.

References

- Anthropic, Effective context engineering for AI agents — context as a finite, curated resource; compaction and pruning patterns.

Explanation

The symptom — correctly formatted JSON early, gradually losing structure in later turns — is a textbook case of format drift: the model's adherence to an output contract degrades as conversation context accumulates. The correct response is a diagnose-then-fix approach: name the failure mode, inspect how context evolves across turns (e.g., older examples, verbose tool outputs, or stale instructions diluting the format signal), then address it with the appropriate lever — context management (compaction/pruning, re-anchoring the schema instruction) and/or output validation (schema validation with retry/repair). This targets the actual root cause rather than working around it. ✅

Why the other options are incorrect

- B — Truncate responses to the first few characters: This corrupts output rather than validating it, and guarantees invalid JSON. It's a nonsensical workaround that destroys the data.

- C — Restart the application every turn: This eliminates multi-turn continuity entirely and abandons the conversation-state problem instead of fixing it; it also can't reveal turn-dependent drift.

- D — Switch to a smaller model: This reduces capability rather than addressing context-driven drift; a weaker model is more likely to drift, not less.

The tested distinction: diagnose the failure mode and fix the cause (context + validation) versus blunt workarounds that either destroy output, eliminate continuity, or downgrade capability.

References

- Anthropic, Effective context engineering for AI agents — context evolution across turns and drift mitigation.

Explanation

The key detail is that the MCP server will be invoked by a local Claude Code session — client and server run on the same machine. MCP's STDIO transport is purpose-built for exactly this: the client spawns the server as a local child process and communicates over standard input/output. It requires no network configuration, no ports, no authentication setup, and offers low-latency, tightly-coupled local process communication. This matches the documented guidance: use STDIO for local servers, and Streamable HTTP/SSE for remote or shared servers. Since there's no remote-access requirement, STDIO is the simplest correct choice. ✅

Why the other options are incorrect

- A — Run STDIO and HTTP simultaneously "for redundancy": This doubles the operational surface with no stated benefit, and redundancy across transports isn't a standard MCP pattern; you choose the transport that fits the deployment model.

- B — Use HTTP because it is "preferable in any context": This is false. HTTP adds network setup, port binding, and authentication overhead that are unnecessary for a local process; transport choice should follow the deployment model, not a blanket preference.

- C — Use HTTP polling as a substitute: Polling isn't a standard MCP transport pattern; MCP uses STDIO or Streamable HTTP/SSE, not ad-hoc polling.

The tested distinction: match the transport to the deployment model — local → STDIO; remote/shared → HTTP. No unnecessary network layer for a local invocation.

References

- Anthropic, Model Context Protocol documentation — transports: STDIO (local process) vs. Streamable HTTP/SSE (remote).