Your Claude application has been running for several conversation turns, and you notice the model occasionally references information that was discussed many turns ago but is no longer relevant. You suspect context drift is causing the model to weight stale content too heavily.
How would you address the drift?

• A. Truncate the conversation so the model sees only the most recent turn during each subsequent response.
• B. Apply compaction to summarize older portions of the conversation so the gist remains while the specifics carry less weight.
• C. Reset the conversation after every turn so the model loses all prior turns when generating a response.
• D. Increase the context window size so all turns of the conversation remain visible to the model in full detail.

Your application uses the Messages API to handle multi-turn conversations. Each new turn resends the entire conversation history, and your token costs are growing as conversations get longer. You suspect there is a more efficient approach.
How would you address this?

• A. Use prompt caching to reuse the static portions of the conversation context across turns instead of paying for them at the normal input-token rate on every request the application sends.
• B. Summarize each conversation after every turn and replace the full history with the summary on the next request, reducing token count at the cost of fidelity.
• C. Truncate every conversation to the last two messages so that token usage stays low and costs remain predictable across the application's normal operation.
• D. Switch to the Batch API for every turn so the per-call cost is reduced, treating the batch as the team's primary cost-control mechanism for multi-turn work.

You are choosing between using STDIO-based communication and HTTP-based communication for an MCP server. The server will be invoked by a Claude Code session running locally.
Which communication pattern would you use?

• A. HTTP polling against the MCP server, treating HTTP as a substitute for the standard MCP communication patterns.
• B. STDIO because STDIO is well-suited to local process communication and avoids unnecessary network setup.
• C. HTTP on the grounds that HTTP is preferable to STDIO in any context the application might encounter during normal operation.
• D. STDIO and HTTP simultaneously for redundancy, with the team running two communication patterns at the same time across Claude Code sessions.

Your Claude application makes high-volume API calls during business hours and very few calls overnight.
The team is concerned about staying within rate limits during peak hours and wants to understand how the Claude API enforces those limits.
How would you proceed?

• A. Identify the rate limits, design the application to stay within them during peak hours, and use exponential backoff when limits are reached.
• B. Examine the peak-hour request patterns in your application logs and smooth traffic by distributing requests more evenly across the business-hours window.
• C. Review the API documentation for streaming endpoints and evaluate whether migrating peak-hour calls to streaming reduces exposure to rate limit enforcement.
• D. Assess the average payload size of current API calls and consolidate requests where possible to reduce the total number of calls made during peak hours.

Your agent makes 10 to 15 tool calls per task, and you have noticed it sometimes loses track of earlier results by the time it reaches later steps. The agent's context window is large enough to hold all the messages, but the relevant information appears to get buried as the conversation grows.
How would you address this?

• A. Reduce the number of tool calls per task by combining several existing tools into larger, multi-purpose tools.
• B. Apply a context-management pattern that summarizes or prunes older tool outputs while preserving the active task state.
• C. Increase the context window further so all tool outputs from every prior step remain in full detail throughout the task.
• D. Switch to a different agentic framework that advertises automatic context-window management as a built-in feature.