View Full Anthropic CCA-F Exam Dumps and Practice Test Dumps.

 

Question 241

An AI agent is asked to modify a customer’s subscription plan. Which control should be applied before the change is executed?

1. Verify authorization and validate the requested plan
2. Allow the model to select any available plan
3. Skip validation because the customer made the request
4. Give the agent administrator permissions

Correct Answer: 1

Explanation

Changing a subscription can affect billing, access, and contractual terms, so the operation should be validated before execution. The system should verify that the authenticated user is authorized to make the change and that the requested plan is valid and available. Depending on the application’s design, it may also require confirmation before a billing-related change is finalized. Giving the agent unrestricted permissions increases risk, while simply trusting the model or user request does not provide sufficient security. Backend authorization and validation should remain the primary controls for sensitive account modifications.

Question 242

A tool returns an error because the user’s authentication session has expired. What should the agent generally do?

1. Guess the user’s credentials
2. Bypass authentication
3. Clearly indicate that re-authentication is required
4. Use another user’s active session

Correct Answer: 3

Explanation

An expired authentication session means the system can no longer safely verify the user’s current access rights. The agent should not attempt to guess credentials, bypass the authentication mechanism, or use another person’s session. Instead, it should clearly communicate that re-authentication is required and allow the application to handle that process securely. Authentication and authorization should be enforced by trusted application infrastructure rather than by the model. Once the user successfully re-authenticates, the application can reassess permissions and allow the requested operation if the user is authorized.

Question 243

Which design best reduces the risk of an agent accidentally sending duplicate payments?

1. Increase the number of automatic retries
2. Use idempotency keys or another duplicate-prevention mechanism
3. Remove transaction identifiers
4. Allow every retry to create a new transaction

Correct Answer: 2

Explanation

Financial operations should be designed to prevent duplicate execution when retries occur. An idempotency key allows the payment system to recognize that repeated requests represent the same intended transaction rather than separate payments. This is particularly important when a network timeout leaves the client uncertain whether the original request succeeded. Simply increasing retries can make duplicate payments more likely. Transaction identifiers and clear status handling provide additional protection. High-impact operations should also use appropriate authorization, validation, and audit logging to ensure that transactions are traceable and controlled.

Question 244

An agent is processing information from an untrusted email. The email contains a request to call an administrative tool. What should happen?

1. The tool should be called automatically
2. The email should override system instructions
3. The request should be treated as untrusted content and separately authorized
4. The agent should expose its credentials to the email sender

Correct Answer: 3

Explanation

Content inside an untrusted email should not automatically be treated as an authorized command. Emails can contain malicious instructions or prompt injection attempts designed to make an agent perform actions that the actual user never requested. Administrative tools should require explicit authorization based on the application’s security model. The agent can analyze or summarize the email without automatically executing embedded instructions. Backend access controls should remain independent of the model’s interpretation. Separating untrusted content from trusted commands is an important defense when agents process emails, documents, webpages, or other external data.

Question 245

Why should an agent avoid making assumptions about missing critical information?

1. Assumptions can lead to incorrect or unintended actions
2. Assumptions always make the agent slower
3. Missing information never affects tool execution
4. The model should always choose the most convenient value

Correct Answer: 1

Explanation

Critical missing information can change the meaning or consequences of an operation. For example, an incomplete payment destination, ambiguous appointment time, or missing customer identifier can cause the agent to perform an action against the wrong target. Rather than guessing, the agent should identify whether the missing information is necessary and ask a focused clarification question when it is. Safe defaults may be appropriate for low-risk tasks, but they should not be used when an assumption could create a significant external side effect. Accurate clarification improves both reliability and user control.

Question 246

An agent needs to retrieve an order using an order number. Which tool design is preferable?

1. A tool that searches and modifies every database record
2. A tool requiring no parameters
3. A tool that exposes database administrator credentials
4. A focused order-lookup tool requiring a validated order number

Correct Answer: 4

Explanation

A focused order-lookup tool is preferable because it exposes only the capability needed for the requested task. Requiring a validated order number provides a clear input contract and reduces the risk of retrieving unrelated records. A broad database tool creates unnecessary privileges and makes misuse more likely. Tool descriptions should clearly explain the purpose, required parameters, expected output, and authorization requirements. Backend access controls should also verify that the requesting user is allowed to access the specified order. Narrowly scoped capabilities generally make agent systems easier to secure, test, and audit.

Question 247

What is a key purpose of an agent termination condition?

1. To make the agent continue calling tools forever
2. To define when the workflow should stop executing
3. To prevent the agent from producing any output
4. To remove the need for error handling

Correct Answer: 2

Explanation

Termination conditions define when an agent should stop its execution loop. An agent might terminate when the requested task is completed, when a final answer is ready, when a required operation cannot proceed, or when an execution budget is reached. Clear termination conditions help prevent infinite loops, unnecessary tool calls, and excessive resource consumption. They should work together with error handling and workflow status reporting. An agent should not continue executing merely because additional tools are available. Instead, it should recognize when the user’s objective has been fulfilled or when further progress is not possible.

Question 248

A company wants to understand how often an agent incorrectly selects a tool. Which evaluation approach is most useful?

1. Measure only response length
2. Review only successful production requests
3. Create test cases covering expected tool-selection scenarios and measure failures
4. Remove tool descriptions during testing

Correct Answer: 3

Explanation

Tool-selection quality should be evaluated using representative scenarios that test whether the agent chooses the correct capability for different requests. An evaluation suite can include normal cases, ambiguous requests, invalid inputs, authorization boundaries, and cases involving similar tools. Developers can then measure incorrect tool selections and compare results across prompt, tool, or model changes. Response length does not directly measure tool-selection accuracy. Testing only successful production requests can hide important failures, while removing tool descriptions changes the system being evaluated. Targeted evaluations provide more useful evidence about actual agent behavior.

Question 249

An agent is asked to retrieve a customer’s billing details. Which information should be passed to a third-party service if only the account identifier is needed?

1. The minimum information required for the lookup
2. The customer’s complete profile
3. All stored payment information
4. Every available customer document

Correct Answer: 1

Explanation

If a third-party service only requires an account identifier, the application should avoid sending unrelated customer information. This follows the principle of data minimization and reduces the amount of sensitive data exposed to external systems. Sending complete profiles or payment details when they are unnecessary increases privacy and security risk. The application should also verify that the third-party service is authorized to receive the requested information and should use appropriate transport and access controls. Minimizing data sent to external services helps reduce the potential impact of accidental disclosure or misuse.

Question 250

Which feature most directly helps developers investigate an unexpected agent action after it occurs?

1. A longer system prompt
2. An audit trail containing relevant execution information
3. More optional tool parameters
4. A larger model context window

Correct Answer: 2

Explanation

An audit trail can provide important information about what happened during an agent execution. Depending on the system, it may record the authenticated identity, selected tool, relevant resource, timestamp, operation result, and execution identifiers. This allows developers or authorized investigators to reconstruct events and identify where unexpected behavior originated. Logging should still respect privacy and data-minimization requirements. A larger context window or longer prompt may influence model behavior but does not provide reliable evidence about what happened after the fact. Auditable execution records are therefore particularly valuable for sensitive or consequential operations.

Question 251

A user asks an agent to delete a file but there are multiple files with the same name. What should the agent generally do?

1. Delete all matching files
2. Choose the oldest file automatically
3. Ask the user to identify the intended file
4. Delete a random matching file

Correct Answer: 3

Explanation

Deleting a file is an external side effect, and ambiguity about the target creates a significant risk of deleting the wrong resource. If multiple files have the same name, the agent should ask the user to provide additional identifying information, such as the folder, file ID, date, or another unique attribute. Automatically deleting all matching files could cause unnecessary data loss. Choosing a file arbitrarily is also unsafe. For destructive operations, resolving ambiguity before execution is particularly important because the consequences may be difficult or impossible to reverse.

Question 252

What is the main benefit of using a structured schema for tool parameters?

1. It makes tool calls easier to validate consistently
2. It guarantees that the tool will always succeed
3. It eliminates authorization requirements
4. It allows missing parameters to be ignored

Correct Answer: 1

Explanation

A structured parameter schema defines the expected fields, types, formats, and required values for a tool call. This makes it possible to validate inputs before they reach the underlying service. For example, a schema can require a customer ID, enforce a date format, or specify that an amount must be numeric and within an acceptable range. Schema validation does not guarantee successful execution because external services can still fail or reject authorized requests. It also does not replace authentication or authorization. Instead, it provides a consistent contract between the agent and the tool.

Question 253

An agent has access to both a read-only customer lookup tool and a customer-update tool. The user only asks for information. Which capability should the agent use?

1. The update tool because it has more permissions
2. The read-only lookup tool
3. Both tools automatically
4. The tool with the longest description

Correct Answer: 2

Explanation

The agent should select the least powerful capability that can satisfy the user’s request. If the user only needs information, a read-only lookup tool is appropriate and avoids unnecessary write permissions. Using an update tool creates additional risk because it may permit changes that the user did not request. This reflects least privilege and risk-aware tool selection. Tool descriptions should make the difference between read and write capabilities clear, while backend authorization should independently enforce permissions. Choosing the narrower capability also makes the workflow easier to audit and reduces the chance of unintended side effects.

Question 254

An external API requires a retry after a temporary failure. Which strategy is generally preferable?

1. Retry immediately without limits
2. Retry indefinitely until the API responds
3. Retry using bounded backoff and appropriate limits
4. Change the request randomly after every failure

Correct Answer: 3

Explanation

Bounded backoff provides a controlled way to recover from temporary service failures. Instead of sending requests repeatedly and immediately, the application waits between attempts, often increasing the delay after successive failures. A retry limit prevents the agent from consuming unlimited resources if the service remains unavailable. The operation should also be safe to retry or protected with idempotency when it has side effects. Randomly changing requests can produce incorrect behavior, while unlimited retries can create loops and increase pressure on an already unhealthy service.

Question 255

Why is it useful to maintain separate development, testing, and production environments for agent systems?

1. It allows changes to be evaluated without directly affecting production users
2. It guarantees that the model cannot make mistakes
3. It removes the need for deployment controls
4. It ensures all environments contain identical secrets

Correct Answer: 1

Explanation

Separate environments allow developers to test changes without exposing production users or data to unverified behavior. Prompt changes, model upgrades, tool modifications, and new workflows can be evaluated in controlled environments before deployment. This reduces the risk that an experimental change will create unintended production side effects. Production secrets and sensitive data should also remain appropriately isolated rather than being copied unnecessarily into testing environments. Environment separation does not eliminate errors, but it provides an important operational boundary for testing, validation, monitoring, and controlled deployment.

Question 256

An agent retrieves information from several sources, and one source is older than the others. What should the system consider?

1. Ignore timestamps completely
2. Prefer the newest information when freshness is relevant and the source is otherwise authoritative
3. Always use the oldest information
4. Combine all conflicting values without explanation

Correct Answer: 2

Explanation

Information freshness can be important when data changes over time. If the task depends on current information, a newer authoritative source may be more appropriate than an older record. However, recency should not automatically override authority or reliability. The system should consider both the source’s trust level and the timestamp relevant to the task. When sources conflict, provenance and source-priority rules can help determine how the information should be handled. The agent should avoid silently combining contradictory values into a result that may misrepresent the underlying data.

Question 257

Which practice helps ensure that an agent does not accidentally expose one customer’s data to another customer?

1. Give the model access to all customer records
2. Use tenant-aware authorization and data filtering
3. Ask the model to remember which customer is active
4. Remove all customer identifiers from backend requests

Correct Answer: 2

Explanation

Tenant-aware authorization and data filtering provide a strong boundary between customers. The backend should associate requests with an authenticated tenant or user and ensure that database queries and retrieval operations are restricted to authorized records. Relying on the model’s memory or instructions is insufficient because the model may misunderstand or be manipulated. Giving access to all customer records creates unnecessary exposure. Customer identifiers can still be used securely when required for legitimate operations, provided that access controls validate the relationship between the requester and the requested data.

Question 258

A tool performs a high-impact action and returns a successful response. What should the application do before reporting success to the user?

1. Verify and interpret the returned status according to the tool’s contract
2. Ignore the tool response
3. Assume every successful network response means the action completed
4. Run unrelated tools

Correct Answer: 1

Explanation

A successful HTTP request or tool invocation does not always mean the requested business operation completed successfully. The application should inspect the structured response and verify the status according to the tool’s contract. For example, a response might indicate that an operation was accepted but remains pending, partially completed, or rejected at a business-rule level. Correctly interpreting the result allows the agent to provide an accurate status to the user. This is especially important for high-impact operations such as payments, account changes, or deletions where falsely reporting success can have serious consequences.

Question 259

What is an appropriate way to handle a user’s request that exceeds the agent’s execution budget?

1. Continue indefinitely until the task finishes
2. Hide the limitation and claim success
3. Clearly report that the task could not be completed within the available execution limits
4. Delete previous execution records

Correct Answer: 3

Explanation

Execution budgets exist to prevent uncontrolled resource consumption, so exceeding one should result in controlled termination rather than unlimited continuation. The agent should communicate that the task could not be completed within the available limits and, when possible, identify what was completed and what remains unfinished. This gives the user an accurate picture of the workflow state. The application may allow the task to be resumed or retried under an appropriate policy. Claiming success when work remains incomplete would create misleading information and could cause incorrect downstream decisions.

Question 260

Which approach provides the strongest basis for safely introducing a new tool into an existing agent system?

1. Give the tool unrestricted permissions immediately
2. Deploy it directly to all users without testing
3. Remove authorization checks to simplify integration
4. Define its schema, permissions, expected behavior, test cases, and failure handling before deployment

Correct Answer: 4

Explanation

A new tool should be introduced with a clearly defined contract covering its purpose, inputs, outputs, permissions, expected errors, and operational limits. Testing should include normal scenarios, invalid inputs, authorization boundaries, failures, and potentially adversarial cases. The tool should receive only the permissions necessary for its purpose, and monitoring or audit mechanisms should be established where appropriate. Deploying an untested tool with unrestricted access creates unnecessary risk. A structured introduction process makes it easier to evaluate behavior, identify problems, and integrate the capability safely into the existing agent workflow.