Nail the AI-201: Agentforce Prep That’s Built for Real-World Implementation

The Agentforce Specialist is defining a custom action for an Agentforce agent in Agent Builder. Actions determine what the agent does (e.g., retrieve data, update records). Let’s evaluate the options.

Option A: Apex TriggerApex Triggers are event-driven scripts, not selectable actions in Agent Builder. While Apex can be invoked via other means (e.g., Flows), it’s not a direct option for custom agent actions, making this incorrect.

Option B: SOQLSOQL (Salesforce Object Query Language) is a query language, not an executable action type in Agent Builder. While actions can use queries internally, SOQL isn’t a standalone option, making this incorrect.

Option C: FlowsIn Agentforce Studio’s Agent Builder, custom actions can be created using Salesforce Flows. Flows allow complex logic (e.g., data retrieval, updates, or integrations) and are explicitly supported as a custom action type. The specialist can select an existing Flow or create one, making this the correct answer.

Option D: JavaScriptJavaScript isn’t an option for defining agent actions in Agent Builder. It’s used in Lightning Web Components, not agent configuration, making this incorrect.

Why Option C is Correct:

Flows are a native, flexible option for custom actions in Agentforce, enabling tailored functionality for agents, as per official documentation.

When creating a custom action for Einstein Bots in Salesforce (including Agentforce), Action Instructions are critical for defining how the bot processes and executes the action. These instructions guide the bot on the logic to follow, such as API calls, data transformations, or conditional steps. Testing and iterating on the instructions ensures the bot understands how to handle dynamic inputs, external integrations, and decision-making.

Salesforce documentation emphasizes that Action Instructions directly impact the bot’s ability to execute workflows accurately. For example, poorly defined instructions may lead to incorrect API payloads or failure to parse responses. The Einstein Bot Developer Guide highlights that refining instructions is essential for aligning the bot’s behavior with business requirements.

In contrast:

Action Name (A) is a static identifier and does not affect functionality.

Action Input (B) defines parameters passed to the action but does not dictate execution logic.

Thus, iterating on Action Instructions (C) ensures the action performs as expected.

According to the AgentForce Retrieval Optimization Guide, when users ask both structured (exact) and unstructured (natural language) questions, the best practice is to use hybrid search. The documentation states:

“Hybrid search combines the precision of keyword retrieval for structured terms, such as IDs or model numbers, with the semantic flexibility of vector search for natural language queries. This approach ensures both deterministic accuracy and contextual understanding.”

Option A (keyword search only) fails for natural language queries, which require semantic understanding.

Option B (semantic search only) may misinterpret or overlook structured identifiers like product or model numbers.

Therefore, Option C—hybrid search—provides the ideal balance between exact match precision and contextual recall.

References (AgentForce Documents / Study Guide):

AgentForce Retrieval and Indexing Guide: “Choosing Between Keyword, Semantic, and Hybrid Search”

AgentForce Data Cloud Handbook: “Optimizing Multi-Modal Retrieval Strategies”

AgentForce Study Guide: “Hybrid Search for Structured and Unstructured Queries”

When a prompt template version is immutable, it means that once the version is activated, it cannot be edited or modified. This ensures consistency in production environments where changes could disrupt workflows.

Option A is incorrect: Any version (not just the latest) can be activated, depending on the use case.

Option D is incorrect: Modifications require manually creating a new version; automatic versioning is not enforced.

Option C is correct: Activation locks the version, enforcing immutability.

The AgentForce Inter-Agent Communication and Security Configuration Guide specifies that when sensitive identity data (like a verified customer ID) must be shared between agents, the correct approach is to use the Agent API to initiate the downstream agent’s session. The verified data should be passed as a read-only context variable, ensuring persistence across sessions while preventing modification by the large language model (LLM).

This setup maintains data integrity and security compliance by isolating sensitive variables from the LLM’s reasoning layer. Context variables passed via the Agent API are immutable during runtime, ensuring they cannot be altered or exposed in agent-generated responses.

Option A adds unnecessary data persistence and complexity. Option B is insecure because conversation variables are exposed to the LLM context, risking unintended modification or leakage.

Therefore, the most secure and compliant configuration is Option C – Use the Agent API to pass verified IDs as read-only context variables between agents.

Agent Inspection is the best fit because the requirement is to examine complete end-to-end agent interactions, not merely view aggregate performance trends or optimize unresolved sessions. The question specifically mentions tracing the interaction from the first user request through final resolution, which requires inspection-level visibility into what the agent interpreted, which subagent or action path it followed, and what response quality was produced. Agent Insights would imply summarized analytics, while Agent Optimization is more focused on identifying improvement opportunities after sessions are analyzed. Salesforce’s Agentforce Session Tracing guidance explains that detailed interaction data is captured to provide a full view of agent behavior, which is exactly what this scenario requires.

Universal Containers (UC) uses a custom object for Leads and plans to implement the Agentforce Sales Development Representative (SDR) Agent. The SDR Agent is a prebuilt, configurable AI agent designed to assist sales teams by qualifying leads and scheduling meetings. Let’s evaluate the options based on its functionality and limitations.

Option A: Agentforce SDR only works with the standard Lead object.Per Salesforce documentation, the Agentforce SDR Agent is specifically designed to interact with the standard Lead object in Salesforce. It includes preconfigured logic to qualify leads, update lead statuses, and schedule meetings, all of which rely on standard Lead fields (e.g., Lead Status, Email, Phone). Since UC tracks leads in a custom object, this is a critical consideration—they would need to migrate data to the standard Lead object or create a workaround (e.g., mapping custom object data to Leads) to leverage the SDR Agent effectively. This limitation is accurate and aligns with the SDR Agent’s out-of-the-box capabilities.

Option B: Agentforce SDR only works on Opportunities.The SDR Agent’s primary focus is lead qualification and initial engagement, not opportunity management. Opportunities are handled by other roles (e.g., Account Executives) and potentially other Agentforce agents (e.g., Sales Agent), not the SDR Agent. This option is incorrect, as it misaligns with the SDR Agent’s purpose.

Option C: Agentforce SDR only supports custom objects associated with Accounts.There’s no evidence in Salesforce documentation that the SDR Agent supports custom objects, even those related to Accounts. The SDR Agent is tightly coupled with the standard Lead object and does not natively extend to custom objects, regardless of their relationships. This option is incorrect.

Why Option A is Correct:

The Agentforce SDR Agent’s reliance on the standard Lead object is a documented constraint. UC must consider this when planning implementation, potentially requiring data migration or process adjustments to align their custom object with the SDR Agent’s capabilities. This ensures the agent can perform its intended functions, such as lead qualification and meeting scheduling.

The correct answer is C. In Agent Script, reasoning.instructions is processed before the final assembled prompt is sent to the LLM. Salesforce explains that procedural logic inside reasoning instructions executes top-to-bottom, prompt text is accumulated, and then the assembled prompt is sent to the LLM. Therefore, if the first instruction deterministically runs the account-tier and open-case lookup actions, those values can be collected before the LLM decides how to respond. Option A is wrong because the config block defines agent-level metadata, not guaranteed action execution. Option B is incorrectly worded and reverses the sequencing issue. For deterministic pre-response data gathering, procedural instructions at the start of reasoning.instructions are the correct pattern.

UC needs to incorporate data from multiple unrelated objects (standard and custom) into a prompt template for a sales proposal. Let’s evaluate the options based on Agentforce capabilities.

Option A: Create a prompt template passing in a special custom object that connects the records temporarily.While a custom object could theoretically act as a junction to link unrelated records, this approach requires additional setup (e.g., creating the object, populating it with data via automation), and there’s no direct mechanism in Prompt Builder to " pass in " such an object to a prompt template without grounding or flow support. This is inefficient and not a native feature, making it incorrect.

Option B: Create a prompt template-triggered flow to access the data from standard and custom objects.There’s no such thing as a " prompt template-triggered flow " in Salesforce. Flows can invoke prompt templates (e.g., via the " Prompt Template " action), but the reverse—triggering a flow from a prompt template—is not a standard construct. While a flow could gather data from unrelated objects and pass it to a prompt, this option’s terminology is inaccurate, and it’s not the most direct solution, making it incorrect.

Option C: Create a Flex template to add resources with standard and custom objects as inputs.In Agentforce’s Prompt Builder, a Flex template (short for Flexible Prompt Template) allows users to define dynamic inputs, including data from multiple Salesforce objects (standard or custom), even if they’re unrelated. Resources can be added to the template (e.g., via merge fields or Data Cloud queries), enabling the prompt to pull data directly from specified objects without requiring a junction object or complex flows. This is ideal for generating a sales proposal using disparate data sources and aligns with Salesforce’s documentation on Flex templates, making it the correct answer.

Why Option C is Correct:

Flex templates are designed for scenarios requiring flexible data inputs, allowing UC to directly reference multiple unrelated objects in the prompt template. This simplifies the process and leverages Prompt Builder’s native capabilities, as outlined in Salesforce documentation.

UC needs an AI solution to suggest products from a catalog for its sales team. Let’s assess the prompt template types in Prompt Builder.

Option A: Record summary prompt templateRecord summary templates generate concise summaries of records (e.g., Case, Opportunity). They’re not designed for product recommendations, which require dynamic logic beyond summarization, making this incorrect.

Option B: Email generation prompt templateEmail generation templates craft emails (e.g., customer outreach). While they could mention products, they’re not optimized for standalone recommendations, making this incorrect.

Option C: Flex prompt templateFlex prompt templates are versatile, allowing custom inputs (e.g., catalog data from objects or Data Cloud) and instructions (e.g., “Suggest products based on customer preferences”). This flexibility suits UC’s need to recommend products dynamically, making it the correct answer.

Why Option C is Correct:

Flex templates offer the customization needed to suggest products from a catalog, aligning with Salesforce’s guidance for tailored AI outputs.