CCAR-P practice questions: The five CCAR-F foundations domains.

A multi-agent system fails in cascades when one worker misbehaves. What architectural controls apply?

• Redundant workers per task with majority voting, so a single misbehaving worker is outvoted by the others
• Timeouts, bounded retries, circuit breakers per worker, and a coordinator that can stop the run
• Stricter output schemas and a shorter system prompt per worker, reducing the chance that any worker misbehaves
• A larger context window for the coordinator so it can hold every worker transcript and spot problems itself

Prompts are edited by several engineers and quality varies release to release. What fixes the process?

• Freeze the prompts for a quarter at a time and batch all edits into a single tested release
• Move the variable parts of each prompt into a config service so engineers edit settings rather than prose
• Version prompts in source control with review, and run the eval set in CI on every change
• Assign one owner per prompt who approves edits by hand and keeps a changelog in the team wiki

A multi-agent system has a planner, three workers, and a verifier. The verifier rejects 40% of worker output. Where do you look first?

• The planner's decomposition, adding a second verifier pass so borderline output gets a tie-breaking judgment
• The verifier's rubric, since a strict rubric applied to reasonable output is the more common cause of a high rejection rate in practice
• The worker model tier, since a stronger model usually cuts the rejection rate faster than editing prompts does
• The worker briefs and acceptance criteria, since a high rejection rate usually means the task or the criteria are unclear

Your agent's tool surface has grown to 60 tools and accuracy is falling. Best structural fix?

• Group tools behind fewer well-scoped interfaces or route to specialist subagents with small tool sets
• Rewrite all 60 descriptions with examples and add a tool-selection few-shot block to the system prompt
• Move to a larger model tier, since tool selection accuracy scales with capability at this tool count
• Order the tool list by call frequency so the most used tools appear first in the model's context

A long-running agent must survive process restarts. What is required?

• Idempotent tools, so that re-running the task from the first turn after a restart produces the same result
• A larger context window so the full history fits when the process reloads the last transcript
• Durable state: the plan, progress, and pending tool results persisted outside the process
• A supervisor that restarts the process and re-sends the original request with a note to continue where it left off

Which design keeps a coordinator's context from growing without bound over hundreds of subtasks?

• Each subagent appends its full transcript so the coordinator can re-check work without re-running it
• Subagents return compact results; the coordinator keeps a structured ledger and compacts periodically
• Restart the coordinator on a fixed cadence and hand the new instance the last user message plus the task list
• Stream subagent output straight to the user and keep the coordinator stateless between subtasks

You need a prompt that behaves the same across model upgrades. What practice helps most?

• Few-shot examples drawn from the previous model's best outputs so the new model imitates them
• A detailed persona and tone section, since style stability is what users notice most across model versions
• Explicit, testable instructions plus a golden eval set that runs on every model change
• Pin the model version in config and treat any upgrade as a new project with a freshly written prompt

An MCP server exposes tools with side effects to several agents. What must the server enforce itself?

• Authorization per caller and idempotency on side-effecting operations
• Structured logging of every call with the caller's agent id so misuse can be traced after the fact
• Rate limits per client and a global concurrency cap so no single agent can exhaust the backend
• Tool descriptions that state the side effects clearly so calling agents gate them appropriately

Which caching strategy suits a system with a large stable policy document and per-user variable content?

• Skip caching, since per-user variation means most requests miss and the cache write premium is wasted
• Cache the policy document as the prefix and put per-user content after the breakpoint
• Cache each user's full conversation as its own prefix so that repeat visits hit the cache
• Place the user content first so the model sees it before the policy, then cache the policy block

An agent's plan step produces good plans but execution drifts. What is the architectural response?

• Increase the planning depth so the plan covers more of the edge cases the executor might wander into during long runs
• Add a retry at the end of execution that reruns the task when the output fails validation
• Drop the separate planning step and let a single stronger model plan and execute in one pass
• Make the plan an explicit artifact that execution checks against, with a review step when it deviates

Which of these is the right place for a hard spending limit on an agent?

• The system prompt, as a stated token budget the model tracks and stops at on its own
• The runtime: a budget enforced by the loop or a hook that stops the run
• The tool descriptions, with a cost annotation so the model prefers cheaper calls
• The billing dashboard, with an alert to the on-call engineer at 80% of budget

A system uses one prompt for five customer segments and quality varies by segment. Approach?

• Add few-shot examples from the weakest segment until its scores match the others
• Raise the model tier for all segments, since the variance reflects a capability limit
• Expand the single prompt with a section per segment so the model applies the right guidance
• Route by segment to specialized prompts and evaluate each route separately

What is the main risk of letting subagents spawn their own subagents without limits?

• Duplicate work, since sibling subagents cannot see each other's results without a shared store
• Loss of detail, since each level summarizes upward and precision degrades with depth
• Rate limit exhaustion at the API layer, which the provider handles with backoff in any case
• Unbounded cost and untraceable behavior, so depth and fan-out need caps

A retrieval-augmented agent returns confident answers from stale documents. Fix?

• A system prompt instruction telling the model to hedge when it is unsure whether a source is current
• A larger retrieval window so that newer documents are more likely to appear among the results
• Freshness metadata in the index, ranking or filtering by recency, and surfacing dates in the answer
• A reranker tuned on relevance so the most on-topic chunk wins regardless of its age

Which is the strongest reason to keep tool results out of the system prompt?

• System prompts have a hard length cap that tool results would exceed on most real tasks
• Tool results in the system prompt are billed at a higher rate than the same tokens in messages
• The system prompt is for instructions; data belongs in turns so it stays data and can be managed
• Prompt caching only applies to the system prompt, so adding data there invalidates the cache

When should an architect prefer a deterministic function over a model call inside a workflow?

• Only for arithmetic and date math, where model error rates are known to be high
• When the step is on the critical path, keeping model calls for background work
• Only when latency matters, since a model call on a small tier is comparable in cost
• Whenever the logic is fully specifiable; code is cheaper, faster, and testable

A Claude Code deployment across a 200-engineer org needs consistent behavior. Which lever scales?

• Each engineer's user-level settings and memory, tuned during an onboarding workshop
• An internal wiki with recommended prompts and a Slack channel for questions
• A central prompt-engineering team that reviews a sample of each engineer's session transcripts weekly
• Checked-in CLAUDE.md, shared skills, hooks, and project-scoped MCP config

What should an evaluator in an evaluator-optimizer loop output?

• A single numeric score, keeping the evaluator cheap and its output easy to threshold
• A pass or fail flag plus the full reasoning trace so that humans can audit the decision later without re-running it
• A corrected version of the output, so the loop converges in one step instead of several
• A structured verdict against explicit criteria with specific feedback the generator can act on

Which context strategy suits an agent that reads thousands of tickets a day?

• One agent per ticket with no shared state, relying on the ticket system for any aggregation
• Embed all tickets and let the agent retrieve as needed with no persistent working state
• Load the full day's tickets into one long-context call so the model can spot cross-ticket patterns
• Process in batches with per-batch summaries and a rolling state document

A team asks whether to expose a tool as one call with many options or several narrow tools. Guidance?

• Prefer one tool with an options schema, since fewer tools keep the definitions block small
• Mirror the backend REST endpoints one to one so that the mapping between each tool and its API call is obvious to maintainers
• Prefer many tools in every case, since each extra tool adds a few tokens and selection is cheap
• Prefer narrow, clearly described tools; combine only when the model routinely needs them together

A production agent's accuracy dropped after a tool provider changed its response format. What should have caught it?

• A larger eval set run before each of your own releases, covering more of the tool paths
• Contract tests on tool responses plus a scheduled eval that alerts on drift
• Pinning the provider's API version in the client so that format changes could not reach production
• Schema validation in the tool wrapper that coerces unexpected fields to safe defaults

Which design keeps a multi-tenant agent from leaking one customer's context into another's?

• Per-tenant context, memory, and tool credentials, with tenant id enforced in every tool call
• A system prompt instruction that names the current tenant and forbids any reference to others
• Random session ids per conversation so that contexts cannot be guessed across tenants
• A shared memory store partitioned by a tenant tag that the model includes in each query

A coordinator agent spends most of its tokens re-reading subagent transcripts. Fix?

• A larger context window on the coordinator so that full transcripts fit without truncation or summarization
• Prompt caching on each transcript so that repeated reads cost less per token
• Subagents return structured summaries; the coordinator keeps a ledger instead of transcripts
• Fewer, larger subagents so there are fewer transcripts for the coordinator to read

How should an architect decide between extended thinking and a second verification call?

• By task type: extended thinking for reasoning-heavy tasks, verification for extraction and formatting work
• Extended thinking by default, since it keeps the workflow to one call and one bill
• A verification call by default, since a second independent pass catches more errors
• By measuring: run both on the eval set and compare accuracy, cost, and latency for that task

Which practice makes a prompt library maintainable across a large team?

• A single senior owner for the whole library who personally approves every change
• Ownership per prompt, versioning, an eval per prompt, and a change process
• A shared document where any engineer can edit, with a weekly review of the accumulated diff
• A freeze on all prompts outside a monthly release window, with edits batched

What is the failure mode of caching aggressively in an agent with per-user personalization?

• Cached prefixes go stale, so users keep seeing policy text from before the last deployment
• The cache lifetime expires in the middle of a conversation, forcing a full uncached re-read of the prefix on the very next turn
• Personal content placed before the breakpoint defeats the cache, or a shared prefix built wrong leaks user data
• Cache writes cost more than reads, so low-repeat traffic pays a premium for no benefit

A client wants the agent to remember everything forever. Your design answer?

• Append every transcript to a vector index and retrieve the top matches into each prompt
• Store durable facts and decisions in a memory store with retention rules; load what a task needs
• Decline memory entirely and require the user to restate context at the start of each session
• Keep full transcripts in the prompt and rely on a long-context model tier to hold them

An MCP server is shared by several teams' agents and performance degrades under load. First architectural move?

• Add a second server instance and split the teams by name across the two
• Rate limits and per-client quotas on the server, plus caching of read-heavy resources
• Reduce the number of tools exposed so each call carries less schema overhead
• Switch transports from HTTP to stdio so that each agent gets its own dedicated server process

Which signal tells you a workflow step should become a model call rather than code?

• It is slow in code, and a small model tier would return an answer faster
• It runs on every request, so a model call's consistency matters more than its cost
• Its inputs are unstructured or ambiguous and rules keep failing on edge cases
• It is the step users complain about most, regardless of what the complaints say

How do you keep a 60-tool integration surface manageable for an agent?

• Merge related tools into a few generic ones with a mode parameter that selects the behavior
• Sort the tool list by usage and drop the bottom 40, since rarely used tools add noise
• Give the model all 60 with a routing table in the system prompt that maps each user intent to the right tool
• Partition tools by task into specialist subagents or dynamic tool loading, each with a small relevant set