CCAR-F practice questions: Context management.

You want prompt caching to work across many requests that share a large system prompt and tool set. How should the prompt be ordered?

• Volatile user content first, then the system prompt and tool definitions, with a cache breakpoint at the very end
• Everything inside one user message in a fixed order, so the whole request is cached as one block
• Tools first, then the user content, then the system prompt, with a breakpoint after each section
• Stable content first (system prompt, tool definitions), a cache breakpoint after it, volatile content last

A coordinator delegates research to a subagent. What should the coordinator pass, and what should it get back?

• The whole conversation so far, and the subagent's complete transcript back, so nothing is lost
• A pointer to the coordinator's memory file, and the subagent's full transcript back for review
• A complete, self-contained brief with everything the subagent needs, and only the conclusion back
• A one-line task title, since the subagent shares the coordinator's context and can look up the rest

What is 'context rot'?

• A caching bug in which a stale cached prefix is served after the system prompt has changed
• The gradual loss of tool results when compaction summarizes older turns
• The decline in response quality as the window fills with stale or irrelevant content
• The drift in a model's behavior over weeks as the provider updates it

An agent needs occasional access to a 500-page manual. Best approach?

• Load the whole manual into every prompt and rely on prompt caching to keep it cheap
• Summarize it once into a few pages and give the agent only the summary
• Index it and retrieve relevant sections on demand, giving the model identifiers it can fetch
• Split it into ten chunks and run a subagent per chunk on every question

Which content should sit at the start of the prompt for prompt caching to help?

• The conversation history, since it is the largest part of the request
• The user's latest question, so the model reads it before the long material
• The stable system prompt and tool definitions
• The most recent tool results, since those are reused across turns

A long-running agent needs to remember decisions across sessions. Which mechanism fits?

• A longer system prompt that lists the decisions made so far
• A larger max_tokens value so the agent can restate all of its decisions in each response
• Prompt caching on the previous session's transcript so it is cheap to include
• A memory file or structured notes the agent reads at start and updates as it works

Why hand a subagent a task instead of doing everything in one context?

• The subagent's working context stays separate and only its conclusion returns, preserving the main window
• Subagents can call tools the main session is not allowed to use
• Subagents run on a different model, so the main session's model stays available
• Subagents share the main session's context, so they start with full knowledge of the task

A prompt includes the full history of a two-hour support chat. Most of it is resolved. What should you do?

• Summarize the resolved parts and keep the open issue verbatim
• Keep the last twenty messages and drop everything before them
• Drop the history and restate the open issue in a fresh prompt
• Keep the full history, since the model may need context from resolved issues

Which is a symptom that a context window is being wasted?

• Responses that arrive faster than the previous session's
• Frequent cache hits on the system prompt across many consecutive requests from the same client
• Large tool results the model never uses and repeated boilerplate in every turn
• Short prompts that leave most of the window empty

What is the trade-off of aggressive summarization in an agent loop?

• Summaries make later turns slower because the model must reconstruct the details
• Headroom and speed at the cost of detail, so keep exact values and identifiers later steps need
• Summaries break tool use because tool_result blocks cannot be summarized
• Summaries are safe as long as the summary is written by a larger model

Which information should be kept verbatim through compaction?

• The earliest turns, since they set up the task
• Resolved errors and their stack traces, in case they recur
• Identifiers, exact values, and the current task definition
• The greetings and pleasantries, since tone carries across turns

A team wants to cut cost on a chat product with a long, stable system prompt and many short user turns. First lever?

• Prompt caching on the system prompt and tool definitions
• Batching user turns so several are answered in one request
• Switching to a smaller model for every turn after the first
• Trimming the system prompt to a few lines so every request is smaller

What does 'give the agent lightweight identifiers' mean in context engineering?

• Pass file paths, record ids, and URLs so the agent can fetch details when needed instead of front-loading everything
• Replace user names with anonymous ids before content reaches the model
• Use short variable and file names in the code the agent works on so tokens are saved
• Give each tool a short alias so the tool list occupies fewer tokens

How should an architect decide the context budget for a step in a workflow?

• From what the step must read and produce, leaving headroom for tool results and reasoning
• Split the total window evenly across the steps in the workflow
• Reuse the budget from the last project that used the same model
• Use the model's maximum on every step so no step runs out of room

A prompt is 150k tokens and quality is uneven. What is the first question to ask?

• Whether a newer model with a larger context window would handle the same 150k tokens more evenly
• Whether raising max_tokens would give the model more room to work through the material
• How much of that context the task needs, and whether retrieval or summarization could replace the bulk
• Whether the prompt has a clear persona so the model knows how to weigh the material

What goes in a memory file that an agent maintains across sessions?

• Every tool result, so the agent can avoid repeating calls it already made
• Decisions, open items, and pointers to sources, kept short and current
• Full transcripts of each session so nothing is lost between runs
• Credentials and endpoints the agent needs, so it can start without setup

Which practice supports prompt caching across many users of the same app?

• Randomize the order of instructions so no single prefix dominates the cache
• Disable the system prompt and pass all instructions in the first user message
• Put each user's profile at the start of the system prompt so it is cached per user
• A shared stable prefix, with user-specific content after the cache breakpoint

How should long tool outputs be handled in an agent loop?

• Kept in full, since dropping any part of a tool result risks losing something the task needs
• Moved into the system prompt so they are cached and do not consume the conversation budget
• Deleted after the turn that used them, since the model has already acted on them
• Truncated or summarized to the essentials, keeping identifiers so details can be re-fetched

What is a reasonable trigger for compaction in a long session?

• Approaching the context budget or finishing a subtask
• Only when a tool call fails, since errors usually mean the context is polluted
• Only when the user asks, since the model cannot judge when to compact
• After every message, so the window stays as small as possible

Why can a smaller, curated context beat a larger one?

• Less irrelevant material means better attention to what matters, alongside lower cost
• The claim does not hold; more context is better as long as it fits inside the model's window
• Models are trained on short prompts, so long prompts fall outside the distribution
• Smaller contexts are cheaper, and the cost saving is the only real difference

An agent must reference a style guide on every task. Where does it belong?

• Pasted into each user message so it is always the most recent input
• Summarized to one line in the system prompt to save tokens
• In the stable prefix so it caches, or loaded once per session
• Returned through a tool result on the first turn of each task

What should be true of the summary you carry forward after compaction?

• It is as short as possible, ideally one sentence describing the goal
• It keeps the full tool results, since those are the hardest to reconstruct
• It restates the system prompt so the instructions survive the reset
• It preserves task definition, decisions, exact values, and next steps

Which is a symptom of context overflow rather than a bad prompt?

• The model asks for information that was never provided in the conversation
• Late-conversation instructions ignored and earlier details contradicted
• Answers that are shorter than usual and skip the requested formatting
• Slower responses and higher cost per turn as the conversation grows

How do subagents relate to context budgets?

• They share the coordinator's budget, so each subagent reduces what is left for the rest
• Each has its own budget, so heavy subtasks do not consume the coordinator's window
• They have no budget of their own and rely on the coordinator to compact for them
• They double the coordinator's window, since each subagent adds its own context to it

An agent's context contains three copies of the same document from repeated tool calls. What is the fix?

• Tell the model in the system prompt to ignore repeated documents and use the first copy
• Increase the context window so the duplicates fit alongside the rest of the task
• Deduplicate tool results and cache the document by identifier so it loads once
• Add a compaction step after every tool call so older copies are summarized away

What is the value of a 'scratchpad' or notes file for a long task?

• It gives the model a place to write longer prompts for itself on the next turn
• It lets tools run faster because their results are written to disk instead of context
• Durable working memory outside the window, so progress survives compaction and restarts
• It replaces the need for compaction, since the window stops growing once notes are kept

Which order helps prompt caching for a multi-tenant assistant with shared instructions?

• Shared instructions and tools first, tenant data after the breakpoint
• Tenant data in the system prompt and shared instructions in the user turn
• Tenant data first so each tenant's cache is warm from the first token
• Alternate shared and tenant content so both are covered by the cache

A workflow step needs only two fields from a large upstream result. Best practice?

• Merge the step into the upstream one so no data has to be passed between them
• Pass the whole upstream result so the step has the full context available if it turns out to need more
• Extract the two fields and pass only those, keeping an identifier to fetch more if needed
• Summarize the upstream result in prose and pass the summary to the step

What does compaction risk if done carelessly?

• Slower responses, since the model must re-read the summary before it can act
• Dropping exact values, identifiers, or the current task definition that later steps need
• More tool calls, since the model re-fetches everything the summary mentions
• Cache misses on the next turn, since the compacted conversation prefix no longer matches the cached one

An agent must consult a policy document on every decision. Which approach balances cost and accuracy?

• Keep it in the cached prefix, or retrieve the relevant section per decision
• Paste the full document into each user turn so it is always the freshest input
• Summarize it once at session start and rely on the summary for every decision
• Load it through a tool call on each decision so it never occupies the prefix

Which is a symptom of too little context rather than too much?

• Responses slow down and cost per turn rises as the conversation grows longer
• Cache misses increase because the shared prompt prefix changes from one turn to the next as history grows
• The model asks for information it should have, or guesses at details that were never provided
• Instructions from early in the conversation are contradicted late in the conversation

How should you size retrieval chunks for a technical manual?

• As large as the context window allows, so each retrieved chunk carries the full surrounding material of the manual with it
• One sentence each, so retrieval can match the exact line the question is asking about
• Whole chapters, since a manual's own structure already groups the related material together and keeps procedures whole
• Large enough to hold one complete idea, like a procedure or section, and small enough to keep only relevant material in context

A coordinator agent's window is filling with subagent chatter. What is the structural fix?

• Have subagents return only structured results and keep their transcripts out of the coordinator
• Compact the coordinator's context after each subagent returns so the accumulated chatter is summarized away
• Disable logging in the subagents so their tool output is not echoed back
• Use fewer subagents so less of their output reaches the coordinator's window