Agentforce-Specialist Salesforce Certified Agentforce Specialist (AI-201) Spring 26 Update Questions and Answers

UC is integrating an Agentforce agent with Omni-Channel Flow to route work. Let’s identify the correct element.

Option A: Route Work ActionThe " Route Work " action in Omni-Channel Flow assigns work items (e.g., cases, chats) to agents or queues based on routing rules. When connecting to an Agentforce agent, this action links the flow to the agent’s queue or presence, enabling interaction. This is the standard element for agent integration, making it the correct answer.

Option B: AssignmentThere’s no " Assignment " element in Flow Builder for Omni-Channel. Assignment rules exist separately, but within flows, routing is handled by " Route Work, " making this incorrect.

Option C: DecisionThe " Decision " element branches logic, not connects to agents. It’s a control structure, not a routing mechanism, making it incorrect.

Why Option A is Correct:

" Route Work " is the designated Omni-Channel Flow action for connecting to agents, including Agentforce agents, per Salesforce documentation.

The correct answer is C because the agent must retrieve from more than one grounding source: company-specific PDFs and a comprehensive Knowledge base. An ensemble retriever is appropriate when multiple retrievers or multiple indexed sources must be combined into one retrieval strategy. That lets the Service Agent search across both unstructured document content and Knowledge content without forcing the specialist to choose only one source. An individual retriever is designed for a single retrieval target, so it is too narrow for this requirement. “Dynamic retriever” is not the best match for the stated need because the issue is not runtime source selection; it is combining multiple authoritative sources. Salesforce guidance describes custom retrievers as supporting more data source patterns, including ensemble retrievers, for Agentforce Data Library use cases.

The AgentForce Conditional Logic and Triage Design Guide recommends using custom variables and deterministic filters for reliable decision-making in AI agents. The document explains: “For deterministic triage flows, create a variable (e.g., severityLevel) populated by an action or rule. Then, apply filters so that specific actions execute only when the variable matches defined criteria. This approach guarantees predictable and auditable outcomes.”

In this case, severityLevel controls whether to escalate to a human rep or create a support case, ensuring no ambiguity in execution.

Option A (IF/THEN logic in topic instructions) and Option B (“Always/Never” keywords) rely on natural language interpretation, which is non-deterministic and can lead to inconsistent results.

Thus, Option C aligns with Salesforce’s documented best practice for reliable and rule-based triage logic.

References (AgentForce Documents / Study Guide):

AgentForce Conditional Logic Guide: “Using Variables and Filters for Deterministic Flows”

AgentForce Implementation Handbook: “Triage and Escalation Best Practices”

AgentForce Study Guide: “Building Reliable Multi-Step Decision Logic”

According to the AgentForce Knowledge Integration and Access Configuration Guide, a Service Agent retrieves and grounds its responses using data from Salesforce Knowledge when the correct permissions are assigned. If customers report that the agent cannot access or provide answers from Knowledge articles, the most common root cause is that the AgentForce Service Agent user lacks the “Allow View Knowledge” permission.

This permission enables the agent to retrieve and read published articles from Salesforce Knowledge for grounding responses. Without it, the agent cannot access the content repository, resulting in incomplete or generic answers.

Option B is incorrect because a license issue would prevent the agent from running at all, not selectively block access to specific data. Option C is also incorrect since the Knowledge profile alone does not control article visibility — permission sets do.

Therefore, the correct answer is Option A – The AgentForce Service Agent user was not given the Allow View Knowledge permission set, which grants the necessary access for article-based responses.

Comprehensive and Detailed Explanation From Exact Extract of AgentForce Documents:

According to the AgentForce Prompt Customization and Template Development Guide, when an organization wants to modify or enhance how structured data (like Salesforce records) is summarized or presented by an agent, the correct approach is to create a Record Summary custom prompt template.

Record Summary templates allow specialists to tailor how the agent interprets and communicates record information — such as opportunities, accounts, or sales summaries — ensuring the output aligns with company-specific terminology, tone, and data needs.

Option B, the Knowledge Answer template, is used when the agent must answer queries grounded in unstructured text sources (e.g., Knowledge articles), not structured CRM data. Option C, updating the standard record summary action, is not recommended because it may impact other agents or system actions globally, and Salesforce documentation advises customizing through new templates instead of overwriting defaults.

Therefore, the correct best practice is Option A – Create a Record Summary custom prompt template, providing tailored and controlled responses specific to Universal Containers’ sales summary requirements.

Before creating a Field Generation prompt template in Agentforce, the Specialist must ensure that the target field is available on a Dynamic Form-enabled Lightning page layout. Field Generation prompt templates work by embedding AI-generated suggestions directly into editable record fields on the Lightning record page. This functionality requires Dynamic Forms, which allow fields to be placed and managed as individual components on the Lightning page. Without Dynamic Forms enabled, the AI cannot surface suggestions directly into the field.Generation templates.

An Agentforce wants to include data from the response of an external service invocation (REST API callout) into a prompt template. The goal is to incorporate dynamic data retrieved from an external API into the AI-generated content.

Solution:

Use External Service Record Merge Fields

External Service Integration:

Definition: External Services in Salesforce allow the integration of external REST APIs into Salesforce without custom code.

Registration: The external service must be registered in Salesforce, defining the API ' s schema and methods.

External Service Record Merge Fields:

Purpose: Enables the inclusion of data from external service responses directly into prompt templates using merge fields.

Functionality:

Dynamic Data Inclusion: Allows prompt templates to access and use data returned from REST API callouts.

Merge Fields Syntax: Use merge fields in the prompt template to reference specific data points from the API response.

Implementation Steps:

Register the External Service:

Use External Services to register the REST API in Salesforce.

Define the API ' s schema, including methods and data structures.

Create a Named Credential:

Configure authentication and endpoint details for the external API.

Use External Service in Flow:

Build a Flow that invokes the external service and captures the response.

Ensure the flow outputs the necessary data for use in the prompt template.

Configure the Prompt Template:

Use External Service Record merge fields in the prompt template to reference data from the flow ' s output.

Syntax Example: {{flowOutputVariable.fieldName}}

Why Other Options are Less Suitable:

Option A (Convert the JSON to an XML merge field):

Irrelevance: Converting JSON to XML merge fields is unnecessary and complicates the process.

Unsupported Method: Salesforce prompt templates do not support direct inclusion of XML merge fields from JSON conversion.

Option C (Use “Add Prompt Instructions” flow element):

Purpose of Add Prompt Instructions:

Allows adding instructions to the prompt within a flow but does not facilitate including external data.

Limitation: Does not directly help in incorporating external service responses into the prompt template.

The correct answer is A. The requirement is operational observability: escalation rate, session duration, topic effectiveness, and the ability to prioritize underperforming agent actions. Agentforce Observability is the native Salesforce area for this because it includes Agent Analytics for aggregate performance metrics and session-level data for deeper investigation. Option B is wrong because the Einstein Trust Layer Audit Trail is primarily governance and audit data around AI interactions, not a service operations dashboard for resolution scoring and action optimization. Option C is not a standard Salesforce capability for these Agentforce metrics. For a live customer service agent, the right model is to use Agent Analytics to identify patterns and then use tracing/session data to inspect where failures or low-quality outcomes are occurring.

In this scenario, Universal Containers wants to bring data from unified Data Cloud objects into prompt templates, and the best way to do that is through a Data Cloud-triggered flow. This type of flow is specifically designed to trigger actions based on data changes within Salesforce Data Cloud objects.

Data Cloud-triggered flows can listen for changes in the unified data model and automatically bring relevant data into the system, making it available for prompt templates. This ensures that the data is both real-time and up-to-date when used in generative AI contexts.

For more detailed guidance, refer to Salesforce documentation on Data Cloud-triggered flows and Data Cloud integrations with generative AI solutions.

The AgentForce Event and Logging Configuration Guide states that enabling “Enrich event logs with conversation data” allows administrators to capture session-level details, including both user inputs and agent responses. The documentation explains: “When this setting is enabled, conversation transcripts, user messages, and agent responses are appended to the event logs for improved visibility and troubleshooting.”

This provides a comprehensive record for analytics, training, and quality review. It does not, however, track user click paths (Option A) or generate aggregated historical reports across all time periods automatically (Option C).

Therefore, Option B is correct, as it directly reflects the documented functionality of the conversation data enrichment feature within AgentForce configuration.

References (AgentForce Documents / Study Guide):

AgentForce Configuration and Monitoring Guide: “Enrich Event Logs with Conversation Data”

AgentForce Data and Analytics Study Notes

AgentForce Implementation Handbook: “Session and Conversation Log Management”

When using Prompt Builder in a Salesforce org, the correct process involves several important steps:

Select the appropriate prompt template type based on the use case.

Develop the prompt within the prompt workspace, where the template is created and customized.

Select CRM-derived grounding data to be dynamically inserted into the prompt, ensuring that the AI-generated responses are based on accurate and relevant data.

Pick the model to use for generating responses, either using Salesforce ' s built-in models or custom ones.

Test and validate the generated responses to ensure accuracy and effectiveness.

Option B is correct as it follows the proper steps for using Prompt Builder.

Option A and Option C do not capture the full process correctly.

Salesforce Prompt Builder Documentation: https://help.salesforce.com/s/articleView?id=sf.prompt_builder_overview.htm

SOMA is correct because the company operates in one Salesforce instance and needs centralized governance, shared user context, and routing across specialized agents. Salesforce’s architecture guidance defines SOMA as multiple agents collaborating within one Salesforce org using shared governance and data, with a Supervisor or primary agent acting as the front door that routes work to specialist agents. Salesforce’s multi-agent orchestration guidance also describes a primary agent that routes tasks to best-fit specialist agents while preserving context so users do not repeat themselves. MOMA is for cross-org collaboration, so it adds unnecessary complexity here. MCP connects agents or models to tools and data sources; it is not the best architectural answer for native single-org multi-agent orchestration.

Service Replies (specifically Einstein Service Replies) is the Salesforce Generative AI functionality designed to automatically draft responses for service agents in real-time, based on contextual information, including existing knowledge articles. This directly addresses Universal Containers ' need to reduce handling time by providing recommended replies grounded in their knowledge base

The correct answer is A because Retriever Playground is the correct no-code tool for validating retrieval behavior before production deployment. It allows the specialist to test individual retrievers, run representative queries, inspect retrieved chunks, and tune retrieval parameters or filters. This is different from Agentforce Testing Center, which validates agent behavior across utterances, subagents, and actions; it is not the most direct tool for testing whether a retriever surfaces the right chunks. Data 360 Query Editor is also not the right choice because the requirement is retriever validation, not manual querying. For RAG quality, the specialist must verify the retrieval layer before evaluating the final generated response. Retriever Playground is built specifically for that retriever-level validation workflow.

Universal Containers (UC) wants to enable its sales team to leverage AI to recommend products from its catalog. The best option for this use case is a Flex prompt template.

A Flex prompt template is designed to provide flexible, customizable AI-driven recommendations or responses based on specific data points, such as product information, customer needs, or sales history. This template type allows the AI to consider various inputs and parameters, making it ideal for generating product recommendations dynamically.

In contrast:

A Record summary prompt template (Option A) is used to summarize data related to a specific record, such as generating a quick summary of a sales opportunity or account, but not for recommending products.

An Email generation prompt template (Option B) is tailored for crafting email content and is not suitable for suggesting products based on a catalog.

Given the need for dynamic recommendations that pull from a product catalog and potentially other sales data, the Flex prompt template is the correct approach.

Salesforce References:

Salesforce Prompt Templates Overview: https://help.salesforce.com/s/articleView?id=000391407 & type=1

Flex Prompt Template Usage: https://developer.salesforce.com/docs/atlas.en-us.salesforce_ai.meta/salesforce_ai/prompt_flex_template

The correct answer is A because Agentforce action metadata must use supported Lightning data types when defining action inputs and outputs. A collection of text values must be exposed to the reasoning engine through a Salesforce-supported Lightning type, not through an Apex implementation name. lightning__stringType correctly maps string-based action input so Agentforce can validate, structure, and pass values into the Apex action. apex__String is not the correct metadata type because it describes an Apex language type, not the Agentforce action schema type. lightning__textType is a UI-oriented text type and is not the correct mapping for this collection-style string action input. Salesforce’s Agentforce developer guidance confirms that Apex strings are mapped to standard Lightning types for action configuration.

The AgentForce Retrieval Configuration Guide outlines that when external data must be filtered by specific criteria—such as WarrantyStatus = Active—the correct approach is to use Hybrid Search with pre-filtering logic defined in a custom retriever. The documentation specifies: “Hybrid search allows combining keyword precision and semantic context. When used with a custom retriever, administrators can pre-filter data on metadata fields (e.g., WarrantyStatus) to ensure that only eligible records are returned.”

Option A (relying on instructions) introduces non-deterministic behavior because the LLM cannot enforce data constraints. Option B (custom variable filtering) applies post-retrieval filtering, which is less efficient and less secure than index-level filtering. Therefore, Option C aligns with Salesforce’s best practice for deterministic, metadata-based retrieval control.

References (AgentForce Documents / Study Guide):

AgentForce Data Cloud Retrieval Guide: “Building Custom Retrievers with Metadata Filters”

Einstein Studio for AgentForce: “Hybrid Search Pre-Filtering”

AgentForce Study Guide: “Filtering Warranty Data by Active Status”

The Prompt Builder Best Practices Guide emphasizes including a role instruction in prompts to set tone and communication style. The document explains: “Role-playing instructions (e.g., ‘You are an empathetic customer support agent’) are a best practice for ensuring the LLM adopts the desired persona, tone, and style in responses.”

Option A directly reflects this principle by instructing the LLM to role-play as a character, resulting in empathetic, customer-centric responses.

Option B (listing keywords) provides no tone or intent guidance.

Option C (including full interaction history) risks token overload and redundancy, which can degrade prompt performance.

Thus, Option A aligns with Salesforce’s prompt design best practices for tone and empathy.

References (AgentForce Documents / Study Guide):

Salesforce Prompt Builder Design Guide: “Using Role Instructions for Empathy and Tone”

AgentForce Prompt Engineering Handbook: “Persona and Context in Prompts”

AgentForce Study Guide: “Creating Effective Prompts for Customer-Facing Use Cases”

In Salesforce’s Einstein Studio (part of the Agentforce ecosystem), creating a custom retriever involves setting up a mechanism to fetch data for AI prompts or responses. The essential step is defining the foundation of the retriever: selecting the search index, specifying the data model object (DMO), and identifying the data space (Option A). These elements establish where and what the retriever searches:

Search Index: Determines the indexed dataset (e.g., a vector database in Data Cloud) the retriever queries.

Data Model Object (DMO): Specifies the object (e.g., Knowledge Articles, Custom Objects) containing the data to retrieve.

Data Space: Defines the scope or environment (e.g., a specific Data Cloud instance) for the data.

Filters are noted as optional in Option A, which is accurate—they enhance precision but aren’t mandatory for the retriever to function. This step is foundational because without it, the retriever lacks a target dataset, rendering it unusable.

Option B: Defining output configuration (e.g., max results, field mapping) is important for shaping the retriever’s output, but it’s a secondary step. The retriever must first know where to search (A) before output can be configured.

Option C: This option includes advanced configurations (vector/hybrid search, filtering fields, ranking method), which are valuable but not essential. A basic retriever can operate without specifying search type or ranking, as defaults apply, but it cannot function without a search index, DMO, and data space.

Option A: This is the minimum required step to create a functional retriever, making it essential.

Option A is the correct answer as it captures the core, mandatory components of retriever setup in Einstein Studio.

Salesforce Agentforce Documentation: " Custom Retrievers in Einstein Studio " (Salesforce Help: https://help.salesforce.com/s/articleView?id=sf.einstein_studio_retrievers.htm & type=5)

Trailhead: " Einstein Studio for Agentforce " (https://trailhead.salesforce.com/content/learn/modules/einstein-studio-for-agentforce)

The correct answer is A. The problem is not that the retriever lacks enough sources; the problem is that the document parser is breaking structured tabular content into chunks that lose layout context. Salesforce Data 360 includes parsing and preprocessing options for unstructured content, and the Docling parser is specifically intended for stronger layout understanding, including table-heavy or complex document structures. Option B is wrong because an ensemble retriever searches multiple retrievers or sources; it does not repair poor chunking caused by weak document parsing. Option C is also wrong because keyword-only scoring changes retrieval ranking behavior but does not preserve table relationships during ingestion. The correct fix is upstream: improve parsing before vectorization and indexing so the chunks preserve table context for RAG grounding.

To ensure that content generated by a large language model (LLM) is appropriately screened for toxic language, the Agentforce Specialist should create a Trust Layer audit report within Data Cloud. By using the toxicity detector type filter, the report can display toxic responses along with their respective toxicity scores, allowing Universal Containers to monitor and manage any toxic content generated with a high level of confidence.

Option C is correct because it enables visibility into toxic language detection within the Trust Layer and allows for auditing responses for toxicity.

Option A suggests checking a toxicity detection log, but Salesforce provides more comprehensive options via the audit report.

Option B involves creating a flow, which is unnecessary for toxicity detection monitoring.

Salesforce Trust Layer Documentation: https://help.salesforce.com/s/articleView?id=sf.einstein_trust_layer_audit.htm

In the Salesforce Agentforce Platform, assigning actions to Agents requires mapping them through Topics in Agent Builder. Topics act as the container that links an Agent’s conversational intent with the specific actions it can perform. By first assigning an action to a Topic in Agent Builder, the Agentforce Specialist ensures that the Agent knows when and how to trigger the action during the business process flow.

UC seeks an AI solution for sales productivity. Let’s determine which requirement aligns with Prompt Builder.

Option A: Creating a draft newsletter for an upcoming tradeshow.Prompt Builder excels at generating text outputs (e.g., newsletters) using Generative AI. UC can create a prompt template to draft personalized, context-rich newsletters based on sales data, boosting productivity. This matches Prompt Builder’s capabilities, making it the correct answer.

Option B: Predicting the likelihood of customers churning or discontinuing their relationship with the company.Churn prediction is a predictive AI task, suited for Einstein Prediction Builder or Data Cloud models, not Prompt Builder, which focuses on generative tasks. This is incorrect.

Option C: Creating an estimated Customer Lifetime Value (CLV) with historical purchase data.CLV estimation involves predictive analytics, not text generation, and is better handled by Einstein Analytics or custom models, not Prompt Builder. This is incorrect.

Why Option A is Correct:

Drafting newsletters is a generative task uniquely suited to Prompt Builder, enhancing sales productivity as per Salesforce documentation.

According to the AgentForce Product Overview and Deployment Guide, Salesforce recommends using purpose-built agents to maximize efficiency across departments. The documentation states:

“Each AgentForce agent type is optimized for a specific function — SDR Agent for sales development and lead nurturing, Service Agent for customer service and support cases, and Employee Agent for internal HR, IT, and productivity tasks.”

This separation ensures that each team benefits from a domain-specific agent equipped with the correct data access and actions.

Option B incorrectly assigns agent types to mismatched use cases, and Option C reduces efficiency and control by using a single generic agent for multiple domains, which goes against Salesforce’s modular AI design principle.

Thus, Option A best aligns with Salesforce’s guidance for role-based AgentForce deployment.

References (AgentForce Documents / Study Guide):

AgentForce Product Overview: “Agent Types and Use Cases”

AgentForce Implementation Guide: “Aligning Agents to Departmental Functions”

AgentForce Study Guide: “Optimizing Team Efficiency with Specialized Agents”

In the AgentForce Architecture and Reasoning Engine Overview, Salesforce explains that the large language model (LLM) drives topic and action selection. The documentation states: “AgentForce uses an LLM to interpret user intent, map it to existing topics, and trigger the appropriate action when available. If no matching topic or action is found, the LLM attempts to generate a direct response using its available context.”

This design ensures dynamic adaptability—the agent can choose the correct topic and associated action based on natural language understanding. Option A is incorrect because topic-to-utterance mapping is a configuration aid, not the selection mechanism. Option C is incorrect because the reasoning engine does not select actions by name—it interprets user intent via the LLM and executes mapped actions if relevant.

Therefore, Option B reflects the official operational flow of AgentForce’s LLM-driven reasoning process.

References (AgentForce Documents / Study Guide):

AgentForce Reasoning Engine Overview

AgentForce Builder User Guide: “Topic, Action, and LLM Selection Flow”

AgentForce Study Guide: “How the LLM Chooses Topics and Executes Actions”

Why is " Field Generation " the correct answer?

In Agentforce, the Field Generation prompt template type is designed to populate dynamic form fields with AI-generated content, such as summaries or descriptions created by a large language model (LLM).

Key Considerations for Using Field Generation in Dynamic Forms:

AI-Powered Summarization in Form Fields

Field Generation templates allow real-time AI-generated summaries based on customer data.

The summary is dynamically populated in the form field for the sales or service representative to review.

Human-in-the-Loop AI Strategy

Since leadership wants a human to be involved, Field Generation ensures the AI-generated content is editable before submission.

This keeps a human-in-the-loop, allowing manual review before finalizing responses.

Works with Salesforce Dynamic Forms

Field Generation templates integrate seamlessly with Salesforce Dynamic Forms, ensuring AI-powered insights are embedded within form layouts.

Why Not the Other Options?

❌ B. Sales Email

Incorrect because Sales Email templates are designed for AI-generated email content, not for populating form fields.

❌ C. Record Summary

Incorrect because Record Summary templates generate high-level summaries of entire records, but do not populate individual form fields dynamically.

Agentforce Specialist References

Salesforce AI Specialist Material confirms that Field Generation templates are used for AI-powered dynamic form population​.

The correct answer is A because a messaging channel can be routed through Omni-Channel to an Agentforce Service Agent. In this configuration, Salesforce uses an inbound Omni-Channel flow and Route Work logic to direct the customer conversation to the Service Agent. This is the valid routing target for customer-facing service conversations over messaging. Option B is wrong because an autolaunched flow can execute automation, but it is not the agent routing destination for a messaging session. Option C is wrong because Employee Agents are designed for internal employee assistance, not customer messaging channel routing. Salesforce documentation for Agentforce Service Agent explains that messaging channels can be connected by creating an inbound Omni-Channel flow that routes messages to the agent.

To create a digest of account action plans using the generative API feature, Universal Containers should use the REST API. The REST API is ideal for integrating Salesforce with external systems and enabling interaction with Salesforce data, including generative capabilities like creating summaries or digests. It supports modern web standards and is suitable for flexible, lightweight interactions between Salesforce and legacy systems.

Metadata API is used for retrieving and deploying metadata, not for data operations like generating summaries.

SOAP API is an older API used for integration but is less flexible compared to REST for this specific use case.

For more details, refer to Salesforce REST API documentation regarding using REST for data integration and generating content.

UC wants insights into product and competitor mentions during sales calls, leveraging Einstein Conversation Insights. Let’s evaluate the options.

Option A: Enable Einstein Conversation Insights, connect a recording provider, assign permission sets, and customize insights with up to 25 products.Einstein Conversation Insights analyzes call recordings to identify keywords like product and competitor names. Setup requires enabling the feature, connecting an external recording provider (e.g., Zoom, Gong), assigning permission sets (e.g., Einstein Conversation Insights User), and customizing insights by defining up to 25 products or competitors to track. Salesforce documentation confirms the 25-item limit for custom keywords, making this the correct, precise answer aligning with UC’s needs.

Option B: Enable Einstein Conversation Insights, assign permission sets, define recording managers, and customize insights with up to 50 competitor names.There’s no " recording managers " role in Einstein Conversation Insights setup—integration is with a provider, not a manager designation. The limit is 25 keywords (not 50), and the option omits the critical step of connecting a provider, making it incorrect.

Option C: Enable Einstein Conversation Insights, enable sales recording, assign permission sets, and customize insights with up to 50 products. " Enable sales recording " is vague—Conversation Insights relies on external providers, not a native Salesforce recording feature. The keyword limit is 25, not 50, making this incorrect despite being closer than B.

Why Option A is Correct:

Option A accurately reflects the setup process and limits for Einstein Conversation Insights, meeting UC’s requirement per Salesforce documentation.

According to the Salesforce Prompt Builder Best Practices Guide, an effective prompt must include Role, Task, Context, Constraints, and Format clearly defined — a structure known as the RTCCF model. The documentation explains: “Prompts should specify the assistant’s role, define a clear task, include context and constraints, and provide output format instructions to ensure predictable and high-quality responses.”

Option A follows this framework precisely. It defines:

Role: The assistant’s identity (“experienced support agent”).

Task: Summarizing case notes.

Context: Customer issue, troubleshooting steps, next actions.

Constraints: Limit of 5 sentences, plain language, include “No next action required” if applicable.

Format: Numbered sentences for clarity.

Options B and C omit critical prompt design elements such as strict constraints or output formatting and therefore do not align with Salesforce’s prompt design standard.

References (AgentForce Documents / Study Guide):

Salesforce Prompt Builder Guide: “Prompt Structure Using RTCCF Model”

AgentForce Prompt Template Design Guide: “Best Practices for Summarization Prompts”

Salesforce AI Prompt Engineering Study Guide

Comprehensive and Detailed Explanation From Exact Extract of AgentForce Documents:

According to the AgentForce Orchestration and Action Sequencing Guidelines in the official documentation, deterministic execution order is best achieved by using custom state variables and conditional logic rather than relying solely on LLM reasoning or topic instructions.

AgentForce’s orchestration framework allows developers to define variables that represent the successful completion of specific actions (e.g., “sessionsRetrieved,” “eligibilityVerified,” etc.). Subsequent actions can then include conditional filters that only allow execution if prior steps have been completed. This approach ensures that actions execute in a strict, logical sequence — preventing the LLM from reordering steps arbitrarily.

Option A (relying on topic instructions) provides guidance to the LLM but does not enforce execution order programmatically, which means errors can still occur if the reasoning engine interprets steps differently. Option C (priority and sequence indicators) assists in contextual selection but does not create dependency-based control between actions.

Therefore, per AgentForce best practices, the correct approach is Option B – using custom variables with conditional filters. This guarantees deterministic workflow sequencing, prevents premature action execution, and aligns with the “Action Dependency and Conditional Execution Model” described in the AgentForce Implementation Guide.

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.

Salesforce Agentforce leverages Prompt Builder, a powerful tool that allows administrators to create and manage prompt templates, which are reusable frameworks for generating AI-driven responses. These templates can be invoked by users to perform specific tasks, such as generating sales emails or summarizing records, based on predefined instructions and grounded data. In this scenario, Universal Containers wants its sales reps to have the ability to only execute these prompt templates, meaning they should be able to run them but not create, edit, or manage them.

Let’s break down the options and analyze why B. Prompt Template User permission set is the correct answer:

Option A: Prompt Execute Template permission setThis option sounds plausible at first glance because it includes the phrase " Execute Template, " which aligns with the requirement. However, there is no specific permission set named " Prompt Execute Template " in Salesforce’s official documentation for Prompt Builder or Agentforce. Salesforce typically uses more standardized naming conventions for permission sets, and this appears to be a distractor option that doesn’t correspond to an actual feature. Permissions in Salesforce are granular, but they are grouped logically under broader permission sets rather than hyper-specific ones like this.

Option B: Prompt Template User permission setThis is the correct answer. In Salesforce, the Prompt Builder feature, which is integral to Agentforce, includes permission sets designed to control access to prompt templates. The " Prompt Template User " permission set is an official Salesforce permission set that grants users the ability to execute (or invoke) prompt templates without giving them the ability to create or modify them. This aligns perfectly with the requirement that sales reps should only execute prompt templates, not manage them. The Prompt Template User permission set typically includes permissions like " Run Prompt Templates, " which allows users to trigger templates from interfaces such as Lightning record pages or flows, while restricting access to the Prompt Builder setup area where templates are designed.

Option C: Prompt Template Manager permission setThis option is incorrect because the " Prompt Template Manager " permission set is designed for users who need full administrative control over prompt templates. This includes creating, editing, and deleting templates in Prompt Builder, in addition to executing them. Since Universal Containers only wants sales reps to execute templates and not manage them, this permission set provides more access than required, violating the principle of least privilege—a key security best practice in Salesforce.

How It Works in Salesforce

To implement this, an administrator would:

Navigate to Setup > Permission Sets.

Locate or create the " Prompt Template User " permission set (this is a standard permission set available with Prompt Builder-enabled orgs).

Assign this permission set to the sales reps’ profiles or individual user records.

Ensure the prompt templates are configured and exposed (e.g., via Lightning components like the Einstein Summary component) on relevant pages, such as Opportunity or Account record pages, where sales reps can invoke them.

Why This Matters

By assigning the Prompt Template User permission set, Universal Containers ensures that sales reps can leverage AI-driven prompt templates to enhance productivity (e.g., drafting personalized emails or generating sales pitches) while maintaining governance over who can modify the templates. This separation of duties is critical in a secure Salesforce environment.

References to Official Salesforce Agentforce Specialist Documents

Salesforce Help: Prompt Builder PermissionsThe official Salesforce documentation outlines permission sets for Prompt Builder, including " Prompt Template User " for execution-only access and " Prompt Template Manager " for full control.

Trailhead: Configure Agentforce for ServiceThis module discusses how permissions are assigned to control Agentforce features, including prompt-related capabilities.

Salesforce Ben: Why Prompt Builder Is Vital in an Agentforce World (November 25, 2024)This resource explains how Prompt Builder integrates with Agentforce and highlights the use of permission sets like Prompt Template User to enable end-user functionality.

For sales reps who need to draft personalized emails based on previous communications, the Agentforce Specialist should recommend the Agent Action: Draft or Revise Sales Email. This action uses AI to generate or revise email content, leveraging past successful communications to create personalized and relevant outreach to prospects or clients.

Find Similar Opportunities is used for opportunity matching, not email drafting.

Summarize Record provides a summary of customer data but does not directly help with drafting emails.

For more information, refer to Salesforce ' s Agent documentation on standard actions for sales teams.

The correct answer is C. Salesforce documentation states that when a prompt template is grounded with a related list, the fields available for that related list are based on the page layout of the parent object for the current user. That means the Account page layout controls which related-list fields are exposed for prompt grounding. Option A is wrong because Prompt Builder does not require assigning related-list fields in JSON format. Option B sounds plausible because field selection is involved in Prompt Builder workflows, but it misses the key limitation being tested: related-list field availability is driven by the current user’s parent-object page layout. For exam purposes, the controlling consideration is the page layout dependency, not manual JSON formatting or generic field-picker behavior.

Per the AgentForce Security and Permission Management Guide, the AgentForceServiceAgentUserPsg (Permission Set Group) controls access privileges for Service Agents, including which Salesforce objects, fields, and related data they can read or interact with.

When extending an agent’s access to additional custom fields or related objects, the documented best practice is to update the existing permission set group assigned to that agent type rather than creating new or profile-based permissions. This approach maintains centralized permission governance, ensures license alignment, and avoids conflicts or redundancy across multiple permission layers.

Option B is incorrect because creating a new permission set with an Einstein Agent License is unnecessary — the permission set group already includes license mappings. Option C is not recommended, as editing the Einstein Agent User Profile can cause system-wide effects and deviate from Salesforce’s principle of least privilege.

Therefore, the correct approach is Option A – Update the Object and Field access in the AgentForceServiceAgentUserPsg permission set group, ensuring secure and proper access for the Service Agent to custom case data.

UC uses Agentforce for Sales to identify similar opportunities, aiding deal closure. Let’s determine a criterion used by the " Find Similar Opportunities " feature.

Option A: Matched opportunities have a status of Closed Won from the last 12 months.Agentforce for Sales analyzes historical data to find similar opportunities, prioritizing " Closed Won " deals as successful examples. Documentation specifies a 12-month lookback period for relevance, ensuring recent, applicable matches. This is a key criterion, making it the correct answer.

Option B: Matched opportunities are limited to the same account.While account context may factor in, Agentforce doesn’t restrict matches to the same account—it considers broader patterns across opportunities (e.g., industry, deal size). This is too narrow and incorrect.

Option C: Matched opportunities were created in the last 12 months.Creation date isn’t a primary criterion—status (e.g., Closed Won) and recency of closure matter more. This doesn’t align with documented behavior, making it incorrect.

Why Option A is Correct:

" Closed Won " status within 12 months is a documented criterion for Agentforce’s similarity matching, providing actionable insights for deal closure.

In the AgentForce Flex Prompt Design Guide, the recommended best practice for Flex prompt templates is to ensure that the large language model (LLM) is provided with clear contextual information and a defined role (e.g., sales rep, support agent, concierge). Flex prompts are intentionally open-ended and adaptable, enabling them to handle dynamic and conversational use cases, provided they are guided with sufficient context and role clarity.

By setting a role and including detailed contextual cues, the LLM can tailor tone, content, and reasoning appropriately while maintaining response accuracy.

Option B describes a data-grounded Record Summary use case, not a Flex prompt. Option C, involving retrievers, is for grounding responses to external or indexed data — but Flex prompts typically handle free-form or reasoning-driven tasks, not retrieval-based ones.

Thus, following AgentForce’s official design standards, the correct best practice is Option A – Provide contextual information and assign a role to the LLM for optimal performance and consistency.

Universal Containers (UC) has concerns about data privacy when using Salesforce ' s generative AI features, particularly around preventing third-party LLMs from accessing or retaining their data. The Zero-Data Retention Policy in the Einstein Trust Layer is designed to address these concerns by ensuring that:

No data is used for training or product improvements by third-party LLMs.

No data is retained outside of the customer ' s Salesforce organization.

The LLM provider cannot access any customer data.

This policy aligns perfectly with UC’s requirements for keeping their data safe while leveraging generative AI capabilities.

Prompt Defense and Data Masking are also security features, but they do not directly address the concerns related to third-party data access and retention.

Salesforce Einstein Trust Layer Documentation: https://help.salesforce.com/s/articleView?id=sf.einstein_trust_layer.htm

Context of the Question

Universal Containers (UC) wants to send well-formatted JSON data in a prompt to a large language model (LLM).

The question is about an important technical or design consideration for including CRM data as JSON in that prompt.

Why Apex Code for JSON Formatting?

Apex to Generate JSON: Salesforce does not have a simple “checkbox” or single setting to “convert CRM data to JSON.” Typically, to structure data as JSON in a template, you either:

Use an Apex class that queries or processes the data, then returns a JSON string.

Use a Flow or formula approach (though complex data structures often require Apex).

No Built-In “Enable JSON Format in Prompt Builder”: Prompt Builder doesn’t have a toggle that automatically transforms data into JSON.

ConclusionThe practical solution to pass CRM data in JSON format to an LLM is to use Apex code (or a specialized Flow approach) to produce a JSON string, which the prompt can then merge and pass along. Hence, Option B is correct.

Salesforce Agentforce Specialist References & Documents

Salesforce Documentation: Working with JSON in ApexDescribes how to serialize and deserialize data using Apex for integration or AI prompts.

Salesforce Agentforce Specialist Study GuideEmphasizes the need for custom logic (often in Apex) when complex data transformations (like JSON formatting) are required.

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.

Universal Containers (UC) is implementing Service AI Grounding to enhance its customer service operations. They aim to ensure that AI-generated responses are grounded in the most relevant data sources and need to configure the system to include all supported objects for grounding.

Supported Objects for Service AI Grounding:

Case

Knowledge

Case Object:

Role in Grounding: Provides contextual data about customer inquiries, including case details, status, and history.

Benefit: Grounding AI responses in case data ensures that the information provided is relevant to the specific customer issue being addressed.

Knowledge Object:

Role in Grounding: Contains articles and documentation that offer solutions and information related to common issues.

Benefit: Utilizing Knowledge articles helps the AI provide accurate and helpful responses based on verified information.

Exclusion of Other Objects:

Case Notes and Case Emails:

Not Supported for Grounding: While useful for internal reference, these objects are not included in the supported objects for Service AI Grounding.

Reason: They may contain sensitive or unstructured data that is not suitable for AI grounding purposes.

Why Options A and C are Incorrect:

Option A (Case, Knowledge, and Case Notes):

Case Notes Not Supported: Case Notes are not among the supported objects for grounding in Service AI.

Option C (Case, Case Emails, and Knowledge):

Case Emails Not Supported: Case Emails are also not included in the list of supported objects for grounding.

The AgentForce for Slack Deployment Guide outlines the exact process for enabling AgentForce in Slack. The steps include:

Configuring the Slack agent connection to link Salesforce with the Slack workspace.

Installing the agent in the “Manage AgentForce” section.

Assigning agent access to specific Slack users or channels.

The documentation notes: “Administrators must first establish a Slack connection through Salesforce setup, then deploy the AgentForce app to the desired workspace. User permissions are managed in the Manage AgentForce console.”

Option A is incorrect because there is no “default Slack channel AgentForce.”

Option B refers to Slack workflows, which are unrelated to direct agent configuration.

Therefore, Option C accurately describes the official Salesforce method for enabling AgentForce in Slack.

References (AgentForce Documents / Study Guide):

AgentForce for Slack Integration Guide: “Steps to Connect and Deploy Agents”

Salesforce Setup for AgentForce Collaboration Platforms

AgentForce Study Guide: “Configuring Slack Agent Connections and User Access”

The AgentForce Testing Center Guide specifies that all testing activity—including prompt tests, structured batch runs, and evaluation sessions—consumes AI credits, which can be monitored directly through the Testing Center interface. The documentation states: “Testing Center provides visibility into testing performance, outcomes, and credit usage. Administrators can view test credit consumption metrics to understand resource utilization across agents and environments.”

Agentforce Analytics (Option A) provides insights into performance, engagement, and operational metrics but does not directly track credit consumption tied to testing. Digital Wallet (Option B) manages AI credit balances across orgs but does not offer test-specific tracking. Therefore, Testing Center is the correct answer since it explicitly supports monitoring credit usage during agent testing activities.

References (AgentForce Documents / Study Guide):

AgentForce Testing Center Guide: “Monitoring Credit Consumption During Testing”

AgentForce Admin Handbook: “Tracking Usage and Test Costs”

AgentForce Study Guide: “Testing Resource Visibility and Credit Management”

The correct answer is B. The agent is grounded on a Knowledge data library, and the goal is broad FAQ coverage without manually writing every test. Agentforce Testing Center can generate test scenarios directly from the knowledge sources available to the agent, which makes it the best fit for building an initial regression suite quickly. Option A is valid only when the team already has prepared test cases, but the scenario says manual authoring would take too long. Option C can test routing and tool selection based on subagents and actions, but it does not directly exploit the 200 FAQ articles as the source for test coverage. For knowledge-grounded agents, generating test cases from available Knowledge content is the efficient and relevant approach.

UC is using an Einstein Generative AI feature (likely Einstein Sales Emails) to draft personalized emails, but placeholders (e.g., {!Contact.FirstName}) appear instead of actual data from the contact record. Let’s analyze the options.

Option A: The user does not have permission to access the fields.Einstein Sales Emails, built on Prompt Builder, pulls data from contact records to populate email drafts. If the user lacks field-level security (FLS) or object-level permissions to access relevant fields (e.g., FirstName, Email), the system cannot retrieve the data, leaving placeholders unresolved. This is a common issue in Salesforce when permissions restrict data access, making it the most likely explanation and the correct answer.

Option B: The user’s locale language is not supported by Prompt Builder.Prompt Builder and Einstein Sales Emails support multiple languages, and locale mismatches typically affect formatting or translation, not data retrieval. Placeholders appearing instead of data isn’t a documented symptom of language support issues, making this unlikely and incorrect.

Option C: The user does not have Einstein Sales Emails permission assigned.The Einstein Sales Emails permission (part of the Einstein Generative AI license) enables the feature itself. If missing, users couldn’t generate drafts at all—not just see placeholders. Since drafts are being created, this permission is likely assigned, making this incorrect.

Why Option A is Correct:

Permission restrictions are a frequent cause of unresolved placeholders in Salesforce AI features, as the system respects FLS and sharing rules. This is well-documented in troubleshooting guides for Einstein Generative AI.

The correct answer is B. If a session is not visible under Processed Sessions, the specialist should first consider that it may not have completed processing yet. Agentforce Observability and Session Tracing are designed to collect, store, and expose detailed session data for troubleshooting, but session data can move through processing states before it appears in the processed view. Option A is too broad because the absence of one session does not automatically prove the agent is unregistered. Option C is also too rigid because the correct operational check is the unprocessed queue, not simply waiting for a daily batch cycle. For troubleshooting, the specialist should inspect the Unprocessed Sessions tab before assuming missing observability setup or lost trace data.

In Salesforce Agentforce, a prompt template designed to populate a custom field (like " Latest Opportunities Summary " on the Account object) requires dynamic data to be fed into the template for AI to generate meaningful output. Here, the task is to gather data from the three most recently opened opportunities related to an account. The most robust and flexible way to achieve this is by using a Flow (Option B). Salesforce Flows allow the Agentforce Specialist to define logic to query the Opportunity object, filter for the three most recent opportunities (e.g., using a Get Records element with a sort by CreatedDate descending and a limit of 3), and pass this data as variables into the prompt template. This approach ensures precise control over the data retrieval process and can handle complex filtering or sorting requirements.

Option A: Selecting the " latest Opportunities related list as a merge field " is not a valid option in Agentforce prompt templates. Merge fields can pull basic field data (e.g., {!Account.Name}), but they don’t natively support querying or aggregating related list data like the three most recent opportunities.

Option C: There is no " Account Opportunity object " in Salesforce; this seems to be a misnomer (perhaps implying the Opportunity object or a junction object). Even if interpreted as selecting the Opportunity object as a resource, prompt templates don’t directly query related objects without additional logic (e.g., a Flow), making this incorrect.

Option B: Flows integrate seamlessly with prompt templates via dynamic inputs, allowing the Specialist to retrieve and structure the exact data needed (e.g., Opportunity Name, Amount, Close Date) for the AI to summarize.

Thus, Option B is the correct method to gather the necessary data efficiently and accurately.

Salesforce Agentforce Documentation: " Integrate Flows with Prompt Templates " (Salesforce Help: https://help.salesforce.com/s/articleView?id=sf.agentforce_flow_prompt_integration.htm & type=5)

Trailhead: " Build Flows for Agentforce " (https://trailhead.salesforce.com/content/learn/modules/flows-for-agentforce)

Since security and data privacy are critical, the best option for the Agentforce Specialist is to integrate the fine-tuned LLM (Large Language Model) into Salesforce by adding it to Einstein Studio Model Builder. Einstein Studio allows organizations to bring their own AI models (BYOM), ensuring the model is securely managed within Salesforce’s environment, adhering to data privacy standards.

Option A (embedding via iFrame) is less secure and doesn’t integrate deeply with Salesforce ' s data and security models.

Option C (making callouts to OpenAI) raises concerns about data privacy, as sensitive Salesforce data would be sent to an external system.

Einstein Studio provides the most secure and seamless way to integrate custom AI models while maintaining control over data privacy and compliance. More details can be found in Salesforce ' s Einstein Studio documentation on integrating external models.

To effectively manage and use prompt templates, two distinct permission sets are required:

Prompt Template Manager: This permission set allows users to create prompt templates. It provides the necessary access to define templates, which can be shared and utilized across the organization.

Prompt Template User: This permission set is designed for users who need to execute the templates. It provides the ability to interact with pre-designed prompts and generate outcomes based on these templates.

The Data Cloud Admin permission set is not directly relevant to creating or executing prompt templates but is more focused on managing the Data Cloud.

The root cause of users receiving incorrect sales summaries lies in non-unique action instructions (Option B). In Einstein Bots, custom actions are triggered based on how well user utterances align with the action instructions defined for each action. If the instructions for the three custom actions overlap or lack specificity, the bot’s natural language processing (NLP) cannot reliably distinguish between them, leading to mismatched responses.

Steps to Investigate:

Review Action Instructions: Ensure each custom action has distinct, context-specific instructions. For example:

Action 1: " Summarize quarterly sales by region. "

Action 2: " Generate a product-wise sales breakdown for the current fiscal year. "

Action 3: " Provide a comparison of sales performance between online and in-store channels. " Ambiguous or overlapping instructions (e.g., " Get sales summary " ) cause confusion.

Test Utterance Matching: Use Einstein Bot’s training tools to validate if user utterances map to the correct action. Overlap indicates instruction ambiguity.

Refine Instructions: Incorporate keywords or phrases unique to each sales summary type to improve intent detection.

Why Other Options Are Incorrect:

A. Assigning actions to an agent is irrelevant, as custom actions are automated bot components.

C. Input/output types relate to data formatting, not intent routing. While important for execution, they don’t resolve utterance mismatches.

Einstein Bot Developer Guide: Stresses the need for unique action instructions to avoid intent conflicts.

Trailhead Module: " Build AI-Powered Bots with Einstein " highlights instruction specificity for accurate action triggering.

Salesforce Help Documentation: Recommends testing and refining action instructions to ensure clarity in utterance mapping.

In AgentForce documentation on Knowledge Indexing and Chunking Strategies, Salesforce emphasizes that when uploading large volumes of structured content such as HTML or documentation files, the system should use section-aware chunking. The guide states: “Section-aware chunking preserves the logical boundaries of headings, paragraphs, and sub-sections in structured documents like HTML or PDF files, allowing the agent to retrieve contextually accurate and relevant responses quickly.”

This method ensures that the agent does not split content mid-section or lose contextual relationships between headings and body text. It enhances both retrieval speed and answer precision.

Option A, semantic-based passage extraction, is better suited for free-text knowledge bases, where meaning needs to be inferred. Option B, conversation-based chunking, applies only to chat logs or dialogue histories. For HTML documentation and structured articles, section-aware chunking ensures optimized retrieval and minimal latency in AgentForce responses.

References (AgentForce Documents / Study Guide):

AgentForce Knowledge Management Guide: “Choosing the Right Chunking Strategy”

AgentForce Indexing and Retrieval Optimization Study Notes

AgentForce Developer Handbook: “Implementing Section-Aware Chunking for Structured Files”

Field Generation is the correct prompt template type because the requirement is to generate AI output for a specific Salesforce record field, the Account Description field. Salesforce Prompt Builder supports Field Generation prompt templates so users can generate field values directly from record context without custom code. The described behavior—clicking from the record page, previewing the result, regenerating it, and manually editing before saving—is the Field Generation user experience. Flex templates are general-purpose and are not the best match when the target is a Salesforce field. Sales Email templates are for generating email content, not field values. Since the solution must remain declarative, Prompt Builder with a Field Generation prompt template is the correct choice.

The correct approach is to use deterministic procedural execution with run so the verification email is triggered immediately after the account creation path succeeds. In Agent Script, declaring an action only makes it available; it does not guarantee execution. Salesforce explains that run inside reasoning.instructions executes immediately when the code path is reached, which is appropriate for mandatory follow-up logic such as sending a verification email after account creation. Option B has the wrong sequencing because the email should occur after account creation, not merely before profile setup finishes without being tied to the successful action result. Option C is weaker because it exposes the action for LLM selection rather than forcing execution.

Why is " Ensure the retriever ' s filters are defined to limit the scope of each search efficiently " the correct answer?

In Agentforce, when optimizing a retriever ' s configuration to ensure minimal latency in AI-generated responses, the most effective approach is narrowing the scope of searches by applying specific filters.

Key Considerations for Optimizing Retrievers in Agentforce:

Defining Effective Filters

Applying precise search filters reduces unnecessary data retrieval, decreasing response time.

Filters help focus on relevant records, avoiding delays caused by processing large datasets.

Reducing Query Complexity

Overly broad searches can increase retrieval time, leading to latency issues.

Well-configured retriever filters streamline queries, improving response speed.

Optimizing the Data Indexing Process

Restricting retriever searches to indexed fields enhances efficiency.

Pre-indexed data is faster to access, reducing retrieval time.

Why Not the Other Options?

❌ A. Configure the retriever to operate in dynamic mode so that it modifies the search index structure at runtime.

Incorrect because modifying the search index at runtime increases latency rather than reducing it.

Index modifications require restructuring large datasets, which can slow down AI-generated responses.

❌ C. Increase the recency bias setting for the retriever, limiting scope to more recent data.

Incorrect because increasing recency bias only prioritizes recent records but does not necessarily improve overall retrieval speed.

While it affects relevance, it does not directly address latency issues.

Agentforce Specialist References

Salesforce AI Specialist Material confirms that retriever efficiency depends on well-defined filtering mechanisms to minimize latency​.

Salesforce Instructions for Certification highlight retriever optimization strategies to improve search response times​.

The correct answer is B because password reset is a distinct task and should be modeled as a separate, focused subagent with its own action. The existing identity verification subagent can establish the verified state, and that state can be passed or referenced as context by the Password Reset subagent. This keeps responsibilities clean: one subagent verifies identity, and the other performs the reset through the existing Flow. Option A overloads the identity verification subagent with reset execution, weakening separation of concerns. Option C relies mainly on instructions and intent storage, which is less reliable for a gated operational process. Agentforce design guidance supports using variables to track state across turns and subagents, while actions can call Flows and use outputs for subsequent reasoning.

According to the AgentForce Action Design and Configuration Guide, action instructions serve as the directive text that informs the Reasoning Engine about when and how to invoke a specific action. The documentation states: “Action instructions guide the reasoning engine by describing the action’s purpose, inputs, and when it should be selected. Clear, concise instructions improve the LLM’s accuracy in mapping user intent to the correct action.”

Option A is correct because it reflects this documented purpose — connecting user intent with the appropriate system action.

Option B is incorrect since the temperature parameter for the LLM is defined at the system or configuration level, not within action instructions.

Option C is incorrect because action instructions are meant for the reasoning engine, not for end users.

References (AgentForce Documents / Study Guide):

AgentForce Action Design Guide: “How Action Instructions Support Reasoning”

AgentForce Builder Handbook: “Optimizing Action Selection through Clear Instructions”

AgentForce Study Guide: “Purpose of Action Instructions in Custom Actions”

For analyzing voice and video call records to gain insights into competitor mentions, coaching opportunities, and other key information, Call Explorer is the most suitable feature. Call Explorer, a part of Einstein Conversation Insights, enables sales teams to analyze calls, detect patterns, and identify areas where improvements can be made. It uses natural language processing (NLP) to extract insights, including competitor mentions and moments for coaching. These insights are vital for improving sales performance by providing a clear understanding of the interactions during calls.

Call Summaries offer a quick overview of a call but do not delve deep into competitor mentions or coaching insights.

Einstein Sales Insights focuses more on pipeline and forecasting insights rather than call-based analysis.

Salesforce Einstein Conversation Insights Documentation: https://help.salesforce.com/s/articleView?id=einstein_conversation_insights.htm

The key reason for implementing Agent is its ability to streamline workflows and automate repetitive tasks. By leveraging AI, Agent can assist users in handling mundane, repetitive processes, such as automatically generating insights, completing actions, and guiding users through complex processes, all of which significantly improve operational efficiency.

Option A (Improving data entry and cleansing) is not the primary purpose of Agent, as its focus is on guiding and assisting users through workflows.

Option B (Allowing AI to perform tasks without user interaction) does not accurately describe the role of Agent, which operates interactively to assist users in real time.

Salesforce Agentforce Specialist References:

More details can be found in the Salesforce documentation: https://help.salesforce.com/s/articleView?id=sf.einstein_copilot_overview.htm

To integrate inferences from an XGBoost model into Salesforce ' s Data Cloud as a stand-alone Data Model Object (DMO):

Create the Serving Endpoint in Databricks:

The serving endpoint is necessary to make the trained model available for real-time inference. Databricks provides tools to host and expose the model via an endpoint.

Configure the Model Using Model Builder:

After creating the endpoint, the Agentforce Specialist should configure it within Einstein Studio ' s Model Builder, which integrates external endpoints with Salesforce Data Cloud for processing and storing inferences as DMOs.

Option B: Serving endpoints are not created in Einstein Studio; they are set up in external platforms like Databricks before integration.

Option C: A Python SDK connector is not used to bring model inferences into Salesforce Data Cloud; Model Builder is the correct tool.

The correct answer is C because the troubleshooting need is retrieval-source traceability, not general data modeling or final LLM response writing. In Data 360 retrieval, the retriever searches a configured search index and returns relevant content to ground the prompt. If multiple sources feed the index, source metadata such as document type, author, origin, or content category can be used to filter or interpret retrieved chunks. Option A is too broad because harmonization maps source data into model structures, but it does not directly explain which grounding chunk produced a conflicting answer. Option B is wrong because the LLM should not be trusted to invent or automatically append source tags during synthesis. The retriever layer is where relevant indexed content is searched, filtered, ranked, and returned.

Why is " Sales rep users are missing the Use SDR Agent permission set " the correct answer?

If sales reps are unable to find the Agentforce Sales Development Representative (SDR) Agent, the most likely cause is missing permissions. The " Use SDR Agent " permission set is required for users to access and interact with the SDR Agent in Agentforce.

Key Considerations for This Issue:

Permission Set Restriction

Users must have the " Use SDR Agent " permission set to access Agentforce SDR in their Salesforce environment.

If they lack this permission, the SDR Agent will not appear in their interface.

Agentforce Role-Based Access Control

Agentforce assigns specific permissions based on user roles.

Sales reps require explicit permission to access the SDR Agent.

Fixing the Issue

The Salesforce Admin should assign the " Use SDR Agent " permission set to all relevant sales reps.

This is done in Setup → Permission Sets → Assign to Users.

Why Not the Other Options?

❌ A. Sales rep users ' profiles are missing the Allow SDR Agent permission.

Incorrect because " Allow SDR Agent " is not a standard permission setting in Agentforce.

Permission is granted via permission sets, not profile-level settings.

❌ B. Sales rep users do not have access to the SDR Agent object.

Incorrect because there is no separate " SDR Agent object " in Salesforce.

SDR Agents are AI-driven features, not standard CRM objects that require object-level access.

Agentforce Specialist References

Salesforce AI Specialist Material confirms that users require specific permission sets to access Agentforce SDR Agents​.

Salesforce Instructions for Certification highlight the role of permission sets in controlling Agentforce access​.

To ground a sales email on Opportunity Products, Events near the customer, and Tone and voice examples, the Agentforce Specialist should use a prompt-initiated flow. This flow can dynamically fetch the necessary data from related records in Salesforce and ground the generative AI output with contextually accurate information.

Option B (flex template) does not provide the ability to fetch dynamic data from Salesforce records automatically.

Option C (manual insertion) would not allow for the dynamic and automated grounding of data required for custom prompts.

Refer to Salesforce documentation on flows and grounding for more details on integrating data into custom prompt templates.

The correct answer is B because sensitive account lookup must be gated deterministically. A custom variable can store verification status, and an available when filter can make the lookup action invisible until that status is true. This prevents the LLM from even seeing or selecting the protected action before verification succeeds. Option A misuses Prompt Defense; prompt defense helps protect against unsafe prompt behavior, but it does not replace action-level authorization. Option C is unreliable because natural language instructions are still interpreted by the model and do not enforce execution control. Salesforce release guidance states that filters can be created for topics and actions so the agent can use them only when conditions are met. Variables are also used in filters and action control.

According to the AgentForce Prompt Template Versioning Guide, when a prompt template version is marked as immutable, it means that no edits or modifications can be made to that version after it has been activated. This ensures that the logic, wording, and grounding parameters tied to that version remain locked and consistent for auditing, reproducibility, and compliance purposes.

If further changes are required, the system automatically creates a new draft version of the template. The old version remains immutable and preserved for traceability.

Option B is incorrect because multiple versions can exist, and older versions can remain active under specific testing or rollback scenarios. Option C is partially true but incomplete—the immutability refers to the frozen nature of an active version, not just version creation.

Thus, the correct explanation is Option A – Once a prompt template version is activated, it becomes immutable and cannot be changed.

To generate an email about products that closely match a customer’s expressed interests, An Agentforce should recommend using a custom sales email template that is grounded with interest and product information. This ensures that the email content is personalized based on the customer ' s preferences, increasing the relevance of the marketing message.

Using grounding ensures that the generative AI pulls the correct data related to customer interests and product matches, making the email more effective.

For more information, refer to Salesforce documentation on grounding AI-generated content and email personalization strategies.

The correct answer is A. Agent Script uses standard comparison operators, and Salesforce’s Agent Script operator reference identifies == as the “equal to” comparison operator. The available when clause is conditional visibility logic, so the expression should compare the variable value, such as available when @variables.IsActive == True. Option B is wrong because = and == are not interchangeable in Agent Script conditionals. Option C is wrong because = is used in assignment-style binding or setting contexts, while comparison logic must use ==. This distinction matters because available when determines whether the action is exposed to the reasoning engine. A wrong operator can either fail validation or create unsafe action visibility, which defeats the purpose of deterministic action gating.

Agentforce Sales Agent is designed to let sales teams perform tasks via natural language commands, leveraging Salesforce data while adhering to policies. For example, agents can ask the AI to " update the opportunity stage to Closed Won " or " generate a quote, " with the system enforcing validations and data security. This use case aligns with Salesforce’s vision of conversational AI streamlining workflows without compromising compliance.

Step-by-step guides (B) are typically handled by tools like Dynamic Forms or Guided Selling, not Agentforce.

Logging messages/emails (C) is managed by Email-to-Case or Service Cloud, not a sales-specific AI agent.

To enable Universal Containers ' sales team with automatic post-call visibility into mentions of competitors, products, and custom phrases, the Agentforce Specialist should set up Call Insights. Call Insights analyzes voice and video calls for key phrases, topics, and mentions, providing insights into critical aspects of the conversation. This feature automatically surfaces key details such as competitor mentions, product discussions, and custom phrases specified by the sales team.

Call Summaries provide a general overview of the call but do not specifically highlight keywords or topics.

Call Explorer is a tool for navigating through call data but does not focus on automatic insights.

For more information, refer to Salesforce ' s Call Insights documentation regarding the analysis of call content and extracting actionable information.

Context of the Question

Universal Containers (UC) has a strict change management process that requires all possible configuration be completed in a sandbox and deployed to Production.

Einstein Generative AI is already enabled in Production, and the “Einstein Work Summaries” permission set is already available in Production.

The Agentforce Specialist needs to configure Work Summaries for Enhanced Messaging in the sandbox.

What Can Actually Be Deployed from Sandbox to Production?

Custom Fields: Metadata that is easily created in sandbox and then deployed.

Quick Actions: Also metadata-based and can be deployed from sandbox to production.

Layout Components: Page layout changes (such as adding the Wrap Up component) can be added to a change set or deployment package.

Why Option C is Correct

No Need to Turn on Einstein in Sandbox for Deployment: Einstein Generative AI is already enabled in Production; turning it on in the sandbox is typically a manual step if you want to test, but that step itself is not “deployable” in the sense of metadata.

Permission Set Assignments (as in Option A) are not deployable metadata. You can deploy the Permission Set itself but not the specific user assignments. Since the question specifically asks “Which other configuration steps should be taken in the sandbox that can be deployed to the production org?”, user assignment is not one of them.

Why Not Option A or B?

Option A: Mentions creating permission set assignments for agents. This cannot be directly deployed from sandbox to Production, as permission set assignments are user-specific and considered “data,” not metadata.

Option B: Mentions “Turn on Einstein.” But Einstein Generative AI is already enabled in Production. Additionally, “Turning on Einstein” is typically an org-level setting, not a deployable metadata item.

ConclusionThe main deployable items you can reliably create and test in a sandbox, and then migrate to Production, are:

Custom Fields (Issue, Resolution, Summary).

A Quick Action that updates those fields.

Page Layout Change to include the Wrap Up component.

Therefore, Option C is correct and focuses on actions that are truly deployable as metadata from a sandbox to Production.

Salesforce Agentforce Specialist References & Documents

Salesforce Trailhead: Work Summaries with Einstein GPTProvides an overview of how to configure Work Summaries, including the need for custom fields, quick actions, and UI components.

Salesforce Documentation: Deploying Metadata Between OrgsExplains what can and cannot be deployed via change sets (e.g., custom fields, page layouts, quick actions vs. user permission set assignments).

Salesforce Agentforce Specialist Study GuideOutlines which Einstein Generative AI and Work Summaries configurations are deployable as metadata.

The correct answer is C because Agent-to-Agent, or A2A, is the purpose-built protocol for communication and collaboration between AI agents across different vendors and platforms. In this scenario, Cloud Kicks has a third-party research agent and an Agentforce customer service agent. The requirement is direct cross-vendor agent communication, not just access to a tool or external endpoint. MCP is mainly used to connect agents with tools, resources, and external context. A generic API can integrate systems, but it is not the agent-interoperability protocol being tested here. Salesforce describes A2A as an open standard that allows AI agents from different platforms to securely communicate, collaborate, share context, and coordinate work.

The correct answer is C because the company is not asking for a generic quality score; it needs evaluation against a proprietary de-escalation framework and empathy standard. Salesforce Testing Center supports LLM-judge style evaluations where a judge model compares the agent response against task criteria. For a custom rubric, the specialist should create a custom evaluation and provide a tailored prompt that defines the exact framework criteria. Option A is wrong because standard Coherence is not intended to be rewritten into a proprietary policy rubric. Option B is also too generic because default instruction adherence does not necessarily understand UC’s internal de-escalation model. Custom evaluation is the right mechanism for organization-specific qualitative standards.

When deploying Einstein Agent (formerly Agentforce) from Sales to Service Cloud:

Agent Topics and Actions are context-specific. Service Cloud use cases (e.g., case resolution, knowledge retrieval) require validation of existing topics/actions to ensure alignment with service workflows.

Option A: Permissions like " Agentforce for Service " are necessary but secondary to functional compatibility.

Option B: Standard service actions must be mapped to Agentforce, but testing ensures they function as intended.

According to the AgentForce Search Optimization Guide, when the use case requires retrieving exact matches (such as policy clause numbers, legal identifiers, or invoice IDs) from structured data, the recommended approach is to use keyword search. The documentation specifies: “Keyword search ensures deterministic retrieval of exact term matches from structured fields, preserving precision for identifiers, numeric values, and code references.”

Semantic search (Option C) uses contextual understanding and synonym expansion, which may yield near matches but not exact ones. Hybrid search (Option B) combines both semantic and keyword results for general knowledge retrieval, but it introduces probabilistic ranking—not suitable for exact legal or compliance queries.

Therefore, for the compliance use case where exact clause number matching is required, keyword search guarantees accuracy, speed, and compliance integrity.

References (AgentForce Documents / Study Guide):

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

AgentForce Compliance and Legal Data Search Best Practices

AgentForce Study Guide: “Optimizing Structured Data Search for Exact Matches”

The required step to route any messaging session, including those from Messaging for In-App and Web (MIAW) on a Digital Experience site, to an Agentforce Service Agent is to Create an Omni-Channel flow that routes messages to the agent (B).

Messaging for In-App and Web utilizes Omni-Channel Routing to direct incoming work items (which are created as MessagingSession records) to the correct destination. When setting up the Messaging Channel for a Digital Experience site, the Routing Type must be configured to use a Flow. This Flow is an Omni-Channel Flow that explicitly contains a Route Work action element configured to route to the Agentforce Service Agent.

Crucially, this Omni-Channel Flow also handles the passing of the pre-chat variables (like the membership number). The pre-chat variables are mapped in the Messaging Channel settings to input variables in the Omni-Channel Flow. The Flow can then use this membership number to perform a record lookup, enrich the context of the conversation (e.g., by updating the related MessagingSession record), and then successfully route the session to the Agentforce Service Agent using the Route To: Bot action, which targets the specific Agentforce Agent.

Options A and C are incorrect:

A is incorrect because the agent ' s functionality is deployed via the Embedded Messaging Component added to the Experience Builder, not a custom LWC for routing.

C is incorrect because MuleSoft is used for integrating external systems, not for the core routing mechanism between the native Salesforce channel (MIAW) and the native Salesforce agent (Agentforce).

Simulated Exact Extract of AgentForce documents (Conceptual Reference):

" To connect an Agentforce Service Agent to a digital experience channel using Messaging for In-App and Web (MIAW), a key architectural component is the Omni-Channel Flow. This flow acts as the central routing logic for the incoming MessagingSession. Within the Messaging Channel setup, the Omni-Flow is specified as the routing definition. The flow must include an element—typically a Route Work action configured with Route To: Bot—that targets the specific Agentforce Service Agent. Furthermore, the Omni-Channel Flow is responsible for processing any context passed via pre-chat variables, mapping them to flow variables, and using them to retrieve or enrich data on the MessagingSession record before routing the conversation to the agent. "

Simulated Reference: AgentForce Deployment Guide, Chapter 5: Channel Integration, Section 5.3: Omni-Channel Routing for Agents, p. 118.

The correct answer is C because approved model governance must be enforced at the platform configuration layer, not left to prompt wording. Einstein Setup includes model provider configuration, where administrators manage which model providers and models are available for generative AI use. If only approved models are enabled there, builders and developers are restricted to the organization’s permitted model set. Option A is wrong because the Einstein Trust Layer provides trust, grounding, masking, and safety services, but it is not the primary place to approve or disable model providers. Option B is not enforceable because system instructions can guide model behavior but cannot restrict platform-level model availability. Salesforce documentation states that model provider access is configured from Einstein Setup under Configure Model Providers.

Context of the Question

Einstein Prompt Builder is a Salesforce feature that helps generate text (summaries, email content, responses) using AI models.

The question presents three potential use cases, asking which one best fits the capabilities of Einstein Prompt Builder.

Einstein Prompt Builder Typical Use Cases

Text Generation & Summaries: Great for writing or summarizing content, like responding to an email or generating text for a record field.

Why Not Forecast Future Sales Trends or Identify Potential High-Value Leads?

(Option A) Forecasting trends typically involves predictive analytics and modeling capabilities found in Einstein Discovery or standard reporting, not generative text solutions.

(Option B) Identifying leads for marketing campaigns involves lead scoring or analytics, again an Einstein Discovery or Lead Scoring scenario.

Sending a Personalized RFP Email (Option C) is a classic example of using generative AI to compose well-structured, context-aware text.

ConclusionOption C (Send reply to a request for proposal via a personalized email) is the best match for Einstein Prompt Builder’s generative text functionality.

Salesforce Agentforce Specialist References & Documents

Salesforce Documentation: Einstein Prompt Builder OverviewHighlights how to use Prompt Builder to create and customize text-based responses, especially for email or record fields.

Salesforce Agentforce Specialist Study GuideExplains that generative AI features in Salesforce are designed for creating or summarizing text, not for advanced predictive use cases (like forecasting or lead scoring).

As per the AgentForce Deployment and Lifecycle Management Guide, AgentForce agents, including their topics, actions, and prompt templates, can be deployed from sandbox to production using Salesforce change sets.

Administrators should create an outbound change set in the sandbox environment that includes all relevant components (Agent definition, prompt templates, topic configurations, flows, and permissions) and then upload it to production for validation and deployment. This process ensures consistency, auditability, and proper dependency tracking between environments.

Option A is incorrect because manual recreation is inefficient and error-prone. Option B is not recommended, as JSON export/import is for development backups and advanced metadata operations, not for standard deployments.

Hence, the correct approach per AgentForce’s best practices is Option C – Create an outbound change set and deploy it to production.

The Temperature hyperparameter controls the randomness of model outputs:

Low Temperature (e.g., 0.2): More deterministic, consistent responses.

High Temperature (e.g., 1.0): More creative, varied responses.

Presence Penalty (Option A): Discourages repetition of tokens, unrelated to randomness.

Variability (Option B): Not a standard hyperparameter in Einstein Studio.

The AI audit trail in Salesforce provides a detailed log of AI activities, including the data used, its handling, and masking procedures applied in the Einstein Trust Layer. It allows the Agentforce Specialist to inspect and verify that sensitive data, such as addresses, is appropriately masked before being used in prompts or outputs.

Enable data encryption on the address field: While encryption ensures data security at rest or in transit, it does not verify masking in AI operations.

Review the platform event logs: Platform event logs capture system events but do not specifically focus on the handling or masking of sensitive data in AI processes.

Inspect the AI audit trail: This is the most relevant option, as it provides visibility into how data is processed and masked in AI activities.

The correct answer is C because external API authentication should not depend on the current user’s UI session ID. Agent execution contexts can differ from interactive UI contexts, so session-based authentication is brittle and can fail silently or violate security expectations. A Named Credential centralizes the endpoint URL and authentication parameters, allowing Salesforce to manage secure callout authentication consistently. Option A does not solve the authentication architecture problem; profile access affects Apex execution permissions, not external API credential management. Option B is also wrong because an Employee Agent is not fixed by assigning a Service Agent permission set group, and permissions alone do not authenticate the external system. Salesforce Apex callout documentation states that a named credential specifies the callout endpoint and required authentication parameters in one definition.

Prompt Builder is designed to help organizations create and configure reusable prompts for large language models (LLMs). By integrating generative AI responses into workflows, Prompt Builder enables customization of AI prompts that interact with Salesforce data and automate complex processes. This tool is especially useful for creating tailored and consistent AI-generated content in various business contexts, including customer service and sales.

It is not a tool for Apex programming (as in option A).

It is also not limited to real-time suggestions as mentioned in option C. Instead, it provides a flexible way for companies to manage and customize how AI-driven responses are generated and used in their workflows.

Salesforce Prompt Builder Overview: https://help.salesforce.com/s/articleView?id=sf.prompt_builder.htm

The AgentForce Security and Deterministic Logic Guide specifies that sensitive actions must be gated through conditional filters linked to verification variables, not through natural language. It states: “For any process requiring secure, deterministic access, create a custom variable (e.g., IsCustomerVerified) that stores the verification status as a Boolean. Apply a filter expression to all protected actions (e.g., IsCustomerVerified = true). This ensures the LLM cannot bypass or alter access logic.”

This configuration ensures security and determinism because the execution of sensitive actions is programmatically enforced, not dependent on the LLM’s understanding.

Option A is incorrect because natural language-based checks are non-deterministic.

Option B relies solely on topic instructions, which can be ignored or misinterpreted by the LLM.

Therefore, Option C is the only solution that provides deterministic, system-enforced access control.

References (AgentForce Documents / Study Guide):

AgentForce Security Configuration Guide: “Using Conditional Filters for Deterministic Access”

AgentForce Implementation Handbook: “Verification Variables and Secure Action Flow”

AgentForce Study Guide: “Protecting Sensitive Data in AI Workflows”

The correct answer is B. A custom retriever controls which indexed data is searched and what fields are returned to the prompt or agent. If UC needs a summary field returned, the correct action is to update the retriever configuration, save the revised retriever version, and activate that version so the prompt template uses it. Option A is excessive and technically wrong because retriever versioning supports controlled updates rather than forcing a complete rebuild and deletion. Option C is wrong because default retrievers do not automatically return every useful field in the exact structure a business requires. For grounded AI, returned fields must be intentionally configured so the model receives the right concise context without unnecessary noise. Salesforce documents retriever customization and activation of retriever versions.

Why is " Automates Ingestion, Indexing, and Default Retriever Creation " the correct answer?

An Agentforce Data Library is a key component in ensuring that an AI agent provides precise and up-to-date responses by:

✔ Automating data ingestion → Brings in data from various sources.

✔ Indexing the data → Organizes it efficiently for AI retrieval.

✔ Creating a default retriever → Enables the AI to fetch relevant data dynamically when answering customer queries.

Key Features of an Agentforce Data Library:

Automates Data Ingestion

Integrates real-time and historical data into Salesforce Data Cloud.

Ensures that relevant updates are continuously fed into the AI system.

Indexes Data for Efficient Retrieval

Enhances searchability for quick, context-aware responses.

Enables fast AI response times while maintaining accuracy.

Creates a Default Retriever

AI agents use the retriever to fetch the most relevant and current information.

The retriever grounds AI-generated responses using structured and indexed data.

Why Not the Other Options?

❌ A. Automates ingestion, taxonomical classification, and precision keyword search retrieval

Incorrect because Agentforce does not rely on keyword searches but on indexing and AI-driven retrieval.

❌ C. Automates ingestion and OCR processing of PDFs

Incorrect because OCR (Optical Character Recognition) is not the primary function of an Agentforce Data Library.

AI grounding is based on indexed and structured data, not raw OCR-extracted text.

Agentforce Specialist References

Salesforce AI Specialist Material explains that Agentforce Data Libraries automate data ingestion, indexing, and retriever setup for AI-powered responses​.

Salesforce Instructions for Certification confirm that AI responses are grounded in structured and indexed Data Libraries.

Agent implementation would be most advantageous in Salesforce Service Cloud when the goal is to streamline customer support processes and improve response times. Agent can assist agents by providing real-time suggestions, automating repetitive tasks, and generating contextual responses, thus enhancing service efficiency.

Option B (data security) is not the primary focus of Agent, which is more about improving operational efficiency.

Option C (marketing campaigns) falls outside the scope of Service Cloud and Agent’s primary benefits, which are aimed at improving customer service and case management.

For further reading, refer to Salesforce documentation on Agent for Service Cloud and how it improves support processes.

Why is " Permission Set Read Access " the correct answer?

If an Agentforce Service Agent is unable to assist customers with the new Product Replacement process, it is likely due to missing object permissions.

Key Considerations for Object Access in Agentforce:

Custom Objects Require Permission Set Access

The new Product Replacement object must be explicitly assigned to the agent ' s permission set.

Without Read access, the agent cannot view or interact with the object.

Ensuring Full Data Access for Agents

In Setup → Permission Sets, the admin should:✔ Grant Read access to the Product Replacement object✔ Ensure that related fields (e.g., status, replacement reason) are also accessible

Aligning AI and Agent Workflows

If Einstein AI is used to suggest solutions, the agent must have visibility into the Product Replacement object for context-aware responses.

Why Not the Other Options?

❌ A. The permission set group assigned to the Agent User needs to grant access to the Product Replacement flow.

Incorrect because flow permissions only control automation access, not direct object access.

If an agent cannot view the object, the flow will not be visible or usable.

❌ C. The profile assigned to the Agentforce Agent User needs AI training permission to the custom Product Replacement object.

Incorrect because AI training permissions relate to model learning and improvement, not object visibility.

Agentforce Specialist References

Salesforce AI Specialist Material confirms that permission sets control object-level access for Agentforce users​.

Context of the QUESTION NO: Universal Containers (UC) wants to harness generative AI to boost sales productivity. They are wary of public AI virtual assistants (like generic chatbots) that lack sufficient UC-specific data to generate useful business responses.

Why Fine-Tune an Einstein AI Model with CRM Data?

Company-Specific Relevance: By fine-tuning Einstein AI with UC’s CRM data (accounts, opportunities, products, and historical interactions), the model learns the enterprise-specific context. This ensures that the generative outputs are accurate and tailored to UC’s sales scenarios.

Security and Compliance: Using Salesforce Einstein within the Salesforce ecosystem keeps data under UC’s control, aligning with trust, security, and compliance requirements.

Better Predictions: Einstein AI can produce more relevant insights (e.g., recommended next steps, content suggestions, or AI-generated email responses) when it has been trained on real, high-quality internal data.

Why Not Build an AI Model with Einstein Discovery (Option B)?

Einstein Discovery Use Case: Einstein Discovery is best suited for predictive and prescriptive analytics (e.g., analyzing large data sets for patterns, scoring leads, or predicting churn). While it provides advanced analytics, it is not primarily designed for generative text-based interactions for end-user consumption in a conversational format.

Why Not Enable Agentforce (Option C)?

Agentforce Overview: “Agentforce” (sometimes referencing a pilot or non-mainstream name) typically focuses on interactive help or workforce collaboration. It does not inherently solve the problem of large-scale generative AI using internal CRM data. Moreover, you still need a robust generative engine fine-tuned on company data.

Outcome: Fine-tuning the Einstein AI model with UC’s CRM data (Answer A) is the most direct, Salesforce-native solution to provide generative AI responses that are aligned with UC’s context, driving productivity gains and ensuring data privacy.

Salesforce Agentforce Specialist References & Documents

Salesforce Official: Einstein GPT Overview

Discusses how Einstein GPT can be fine-tuned with specific CRM data to deliver contextually relevant, generative AI responses.

Salesforce Trailhead: Get Started with Salesforce Einstein

Explains the fundamentals of AI within the Salesforce platform, including training and optimizing Einstein models.

Salesforce Documentation: Einstein Discovery

Details how Einstein Discovery is primarily used for advanced analytics and predictions, not direct generative text solutions.

Salesforce Agentforce Specialist Study Guide

Provides the official outline of Einstein AI capabilities, referencing how to configure and fine-tune models for specialized enterprise use cases.

The correct answer is C because the requirement is built around the essential prompt elements of task, context, constraints, and format. The task is to summarize support case notes. The context is the customer issue, troubleshooting steps, and next actions. The constraints are the five-sentence limit, plain-language requirement, no jargon, and the exact phrase to use when no next action exists. The format controls how the final summary should be presented. Option A is incorrect because “LLM Clarity Score” is not a prompt construct. Option B is weaker because token limits are not the same as business constraints such as sentence count and required wording. Salesforce guidance recommends prompts that clearly cover task, context, format, and constraints.

The AgentForce Action Design Guide emphasizes that concise and clear action instructions are essential for predictable and reliable agent behavior. The documentation states: “Action instructions should be concise, clearly define the purpose of the action, and specify its expected inputs and outputs. Each action must be validated through testing in AgentForce Builder to confirm the LLM interprets and executes it as intended.”

This aligns with Option A, which focuses on clarity and testing.

Option B incorrectly focuses on label-intent matching, which is a naming best practice but not sufficient for accuracy.

Option C promotes overly detailed instructions, which can lead to LLM confusion and inconsistent results.

Therefore, Option A best aligns with Salesforce’s official best practices for creating and validating custom actions.

References (AgentForce Documents / Study Guide):

AgentForce Action Design and Testing Guide

AgentForce Builder Documentation: “Validating Custom Actions”

AgentForce Study Guide: “Creating Clear and Testable Action Instructions”

Why is " Update the search index to include the desired field " the correct answer?

When configuring a retriever in Data Cloud for PDF file ingestion, all necessary fields must be included in the search index. If a required field is missing, the correct action is to update the search index to ensure it is available for retrieval.

Key Considerations for Fixing Missing Fields in Data Cloud Retrievers:

Search Index Controls Which Fields Are Searchable

The search index defines which fields are indexed and accessible to the retriever.

If a field is missing, it must be added to the index before it can be queried.

Ensures Complete and Accurate Data Retrieval

Without indexing, the retriever cannot reference the missing field in AI responses.

Updating the index makes the field available for AI-powered retrieval.

Supports AI-Grounded Responses

Agentforce relies on Retriever-Augmented Generation (RAG) to ground AI responses in searchable Data Cloud content.

Ensuring all relevant fields are indexed improves AI-generated answer accuracy.

Why Not the Other Options?

❌ A. Create a new custom Data Cloud object that includes the desired field.

Incorrect because the issue is with indexing, not with Data Cloud object structure.

The field already exists in Data Cloud; it just needs to be indexed.

❌ C. Modify the retriever ' s configuration to include the desired field.

Incorrect because retriever configurations only define query rules; they do not modify the index itself.

Updating the search index is the required step to ensure the field is retrievable.

Agentforce Specialist References

Salesforce AI Specialist Material confirms that search indexing is required for retrievers to access specific fields in Data Cloud​.

The Einstein Trust Layer ensures that sensitive data is protected while generating useful and meaningful responses by masking sensitive data before it is sent to the Large Language Model (LLM) and then de-masking it during the response journey.

How It Works:

Data Masking in the Request Journey:

Sensitive Data Identification: Before sending the prompt to the LLM, the Einstein Trust Layer scans the input for sensitive data, such as personally identifiable information (PII), confidential business information, or any other data deemed sensitive.

Masking Sensitive Data: Identified sensitive data is replaced with placeholders or masks. This ensures that the LLM does not receive any raw sensitive information, thereby protecting it from potential exposure.

Processing by the LLM:

Masked Input: The LLM processes the masked prompt and generates a response based on the masked data.

No Exposure of Sensitive Data: Since the LLM never receives the actual sensitive data, there is no risk of it inadvertently including that data in its output.

De-masking in the Response Journey:

Re-insertion of Sensitive Data: After the LLM generates a response, the Einstein Trust Layer replaces the placeholders in the response with the original sensitive data.

Providing Meaningful Responses: This de-masking process ensures that the final response is both meaningful and complete, including the necessary sensitive information where appropriate.

Maintaining Data Security: At no point is the sensitive data exposed to the LLM or any unintended recipients, maintaining data security and compliance.

Why Option A is Correct:

De-masking During Response Journey: The de-masking process occurs after the LLM has generated its response, ensuring that sensitive data is only reintroduced into the output at the final stage, securely and appropriately.

Balancing Security and Utility: This approach allows the system to generate useful and meaningful responses that include necessary sensitive information without compromising data security.

Why Options B and C are Incorrect:

Option B (Masked data will be de-masked during request journey):

Incorrect Process: De-masking during the request journey would expose sensitive data before it reaches the LLM, defeating the purpose of masking and compromising data security.

Option C (Responses that do not meet the relevance threshold will be automatically rejected):

Irrelevant to Data Protection: While the Einstein Trust Layer does enforce relevance thresholds to filter out inappropriate or irrelevant responses, this mechanism does not directly relate to the protection of sensitive data. It addresses response quality rather than data security.

Universal Containers (UC) is using Apex classes within an Agent Action for their Agentforce Agent. Deploying Apex in Salesforce has specific requirements, especially when tied to Agentforce functionality. Let’s evaluate the options.

Option A: The Apex classes must have at least 75% code coverage from unit tests, and all dependencies must be in the deployment package.Salesforce enforces a strict requirement that all Apex classes must achieve at least 75% code coverage from unit tests for deployment to production, regardless of their use case (e.g., Agentforce, triggers, or web services). Additionally, when Apex is invoked by an Agent Action (e.g., via a Flow or direct invocation), all dependencies (e.g., referenced classes, objects) must be included in the deployment package to ensure functionality. This is a standard deployment consideration in Salesforce and applies to Agentforce, making this the correct answer.

Option B: Apex classes invoked by an Agent Action may be deployed with less than 75% test coverage as long as the agent is not activated in production.Salesforce’s 75% code coverage requirement is mandatory for production deployment, regardless of whether the agent is activated. There’s no exemption based on activation status—coverage is enforced at the deployment stage. This option is incorrect and contradicts Salesforce’s Apex deployment rules.

Option C: The Apex classes may bypass the 75% code coverage requirement as long as they are only used by the agent.No such bypass exists in Salesforce. The 75% code coverage rule applies universally to all Apex in production, including classes used by Agentforce. Agent-specific usage doesn’t waive this requirement, making this incorrect.

Why Option A is Correct:

The 75% code coverage requirement and inclusion of dependencies are fundamental Salesforce deployment rules, applicable to Apex in Agent Actions. This ensures reliability and functionality in production, as per official documentation.

Record Snapshots in Salesforce Prompt Builder leverage the data visible on the user ' s page layout for an object to ground the prompt. This means that the fields and related lists that are configured on the page layout directly influence the data included in the snapshot.

The correct answer is B. When legal clauses are nested inside larger sections, overly small chunks can split the clause from surrounding definitions, exceptions, or conditions. That makes the retrieved passage technically relevant but contextually incomplete. A larger chunk size keeps more surrounding legal text together, improving the chance that the retriever returns the clause with its dependencies intact. Option A would usually make the problem worse because it increases fragmentation. Option C is not the best fix because keyword matching can find terms, but it does not preserve the legal structure around those terms. In Data 360 search indexes, chunking strategy and maximum token settings directly affect how much text is included in each retrievable chunk, so tuning chunk size is the right corrective lever.

In Agentforce, a Knowledge-based data library (e.g., via Salesforce Knowledge or Data Cloud grounding) uses identifying fields and content fields to support AI responses. Let’s analyze their roles.

Option A: Identifying fields help locate the correct Knowledge article, while content fields enrich AI responses with detailed information.In a Knowledge-based data library, identifying fields (e.g., Title, Article Number, or custom metadata) are used to search and pinpoint the relevant Knowledge article based on user input or context. Content fields (e.g., Article Body, Details) provide the substantive data that the AI uses to generate detailed, enriched responses. This distinction is critical for grounding Agentforce prompts and aligns with Salesforce’s documentation on Knowledge integration, making it the correct answer.

Option B: Identifying fields categorize articles for indexing purposes, while content fields provide a brief summary for display.Identifying fields do more than categorize—they actively locate articles, not just index them. Content fields aren’t limited to summaries; they include full article content for response generation, not just display. This option underrepresents their roles and is incorrect.

Option C: Identifying fields highlight key terms for relevance scoring, while content fields store the full text of the article for retrieval.While identifying fields contribute to relevance (e.g., via search terms), their primary role is locating articles, not just scoring. Content fields do store full text, but their purpose is to enrich responses, not merely enable retrieval. This option shifts focus inaccurately, making it incorrect.

Why Option A is Correct:

The primary difference—identifying fields for locating articles and content fields for enriching responses—reflects their roles in Knowledge-based grounding, as per official Agentforce documentation.

The correct answer is B. Internal employee-facing agents operate within the authenticated Salesforce user’s access model, so actions must respect the employee’s profile, permission sets, sharing, and field-level security. A customer-facing Service Agent deployed through Experience Cloud is different: it is configured around an agent user/service agent execution identity, and Salesforce guidance stresses assigning the correct permissions to that agent user rather than relying on the site guest profile. Option A is wrong because a logged-in Experience Cloud deployment should not be treated as a guest-user execution model by default. Option C is also wrong because it incorrectly applies the dedicated Service Agent User model to the internal Sales Productivity Agent. The exam distinction is user-context execution for internal productivity versus dedicated service-agent execution for customer-facing service automation.

When creating a custom action in Agent, one of the available options is to use Flows. Flows are a powerful automation tool in Salesforce, allowing the Agentforce Specialist to define custom logic and actions within the Copilot system. This makes it easy to extend Copilot ' s functionality without needing custom code.

While Apex triggers and SOQL are important Salesforce tools, Flows are the recommended method for creating custom actions within Agent because they are declarative and highly adaptable.

For further guidance, refer to Salesforce Flow documentation and Agent customization resources.

The User Utterances dashboard (Option A) is the correct functionality for analyzing user inputs, requests, and queries to identify patterns and trends. This dashboard aggregates and categorizes the natural language inputs (utterances) from users, enabling the Agentforce Specialist to:

Identify Common Queries: Surface frequently asked questions or recurring issues.

Detect Intent Patterns: Understand how users phrase requests, which helps refine intent detection models.

Improve Bot Training: Highlight gaps in training data or misclassified utterances that require adjustment.

Why Other Options Are Incorrect:

B. Agent Event Logs dashboard: Focuses on agent activity (e.g., response times, resolved cases) rather than user input analysis.

C. AI Audit & Feedback Data dashboard: Tracks AI model performance, audit trails, and user feedback scores but does not directly analyze raw user utterances or queries.

Salesforce Einstein Agentforce Specialist Certification Guide: Emphasizes the User Utterances dashboard as the primary tool for analyzing user inputs to improve conversational AI.

Trailhead Module: " Einstein Bots Basics " highlights using the dashboard to refine bot training based on user interaction data.

Salesforce Help Documentation: Describes the User Utterances dashboard as critical for identifying trends in customer interactions.

UC has grounded a prompt template with a related list, but the responses are incorrect during UAT. Grounding with related lists in Agentforce allows the AI to access data from child records linked to a parent object. Let’s analyze the options.

Option A: The related list is Read Only.Read-only status (e.g., via field-level security or sharing rules) might limit user edits, but it doesn’t inherently prevent the AI from accessing related list data for grounding, as long as the running user (or system context) has read access. This is unlikely to cause incorrect responses and is not a primary consideration, making it incorrect.

Option B: The related list prompt template option is not enabled.There’s no specific " related list prompt template option " toggle in Prompt Builder. When grounding with a Record Snapshot or Flex template, related lists are included if properly configured (e.g., via object relationships). This option seems to be a misphrasing and doesn’t align with documented settings, making it incorrect.

Option C: The related list is not on the parent object’s page layout.In Agentforce, grounding with related lists relies on the related list being defined and accessible in the parent object’s metadata, often tied to its presence on the page layout. If the related list isn’t on the layout, the AI might not recognize or retrieve its data correctly, leading to incomplete or incorrect responses. Salesforce documentation notes that related list data availability can depend on layout configuration, making this a plausible and common issue during UAT, and thus the correct answer.

Why Option C is Correct:

The absence of the related list from the parent object’s page layout can disrupt data retrieval for grounding, leading to incorrect AI responses. This is a known configuration consideration in Agentforce setup and testing, as per official guidance.

When a flow is invoked via a custom Agent action, its data access depends on the flow’s runtime configuration, not system mode by default. Salesforce flows can be configured to respect the running user’s permissions and sharing settings:

If the flow is set to  " Run as the User Who Launched the Flow "  (enabled in Flow Settings), it adheres to the user’s permissions, field-level security (FLS), and sharing rules.

Option C is incorrect because flows do not always run in system mode unless explicitly configured to do so.

Option A is misleading because " with sharing " is an Apex concept, not a flow setting. Flows use runtime settings like FLS and sharing enforcement.

In Model Playground, An Agentforce working with a Salesforce-enabled foundational model has control over specific hyperparameters that can directly affect the behavior of the generative model:

Temperature: Controls the randomness of predictions. A higher temperature leads to more diverse outputs, while a lower temperature makes the model ' s responses more focused and deterministic.

Frequency Penalty: Reduces the likelihood of the model repeating the same phrases or outputs frequently.

Presence Penalty: Encourages the model to introduce new topics in its responses, rather than sticking with familiar, previously mentioned content.

These hyperparameters are adjustable to fine-tune the model’s responses, ensuring that it meets the desired behavior and use case requirements. Salesforce documentation confirms that these three are the key tunable hyperparameters in the Model Playground.

For more details, refer to Salesforce AI Model Playground guidance from Salesforce’s official documentation on foundational model adjustments.

The correct answer is C because prompt template versioning is part of the prompt template metadata lifecycle. When a prompt template is moved between environments, specialists must account for versions stored with the template in the source org. That is why template version management matters before deployment; test versions, inactive versions, and production-ready versions can all affect the metadata package. Option A is wrong because earlier versions do not have to be manually activated before deployment. Option B is wrong because deployment does not simply wipe all history and retain only one replacement version. Salesforce’s CLI considerations for Prompt Builder confirm that template versions are represented in deployable XML and can be managed during deployment, including deletion behavior in the target org.

The correct answer is A because vectorization converts text chunks into numerical embeddings that capture semantic meaning. In Agentforce and Data 360 retrieval scenarios, large documents are first broken into smaller chunks or passages, and those chunks are then converted into vectors. The retrieval engine can compare a user’s question or prompt with those vectors to find content that is meaningfully similar, not merely keyword-matched. Option B is wrong because vectorization is not encryption; security and storage controls are separate platform concerns. Option C is wrong because vectorization is not a compression mechanism and is not used primarily to reduce file size or storage cost. Salesforce Data 360 documentation describes chunking as creating manageable semantic units and vectorization as converting those chunks into numeric representations of text.

The AgentForce Data Cloud and Retrieval Configuration Guide explains that individual retrievers offer customization flexibility beyond the default retriever. The guide states: “Individual retrievers allow specialists to define filters, select specific fields for retrieval, and configure result limits, providing fine-grained control over data recall and relevance.”

Option A is incorrect because aggregation across multiple data spaces or DMOs is managed through composite retrievers, not individual retrievers.

Option C is also incorrect, as retrievers do not automatically generate or update indexes — indexing is handled separately within Data Cloud.

Therefore, Option B is correct since it represents the key advantage of individual retrievers: the ability to configure filters, fields, and retrieval parameters for precision control.

References (AgentForce Documents / Study Guide):

AgentForce Data Cloud Guide: “Individual vs. Default Retriever Configuration”

AgentForce Study Guide: “Fine-Tuning Retrieval Logic Using Individual Retrievers”

Einstein Studio for AgentForce: “Custom Filtering and Field Selection in Retrievers”

To access externally-hosted models, such as a large language model (LLM) hosted on AWS, the Model Builder in Salesforce is the appropriate tool. Model Builder allows teams to integrate and deploy external AI models into the Salesforce platform, making it possible to leverage models hosted outside of Salesforce infrastructure while still benefiting from the platform ' s native AI capabilities.

Option B, App Builder, is primarily used to build and configure applications in Salesforce, not to integrate AI models.

Option C, Copilot Builder, focuses on building assistant-like tools rather than integrating external AI models.

Model Builder enables seamless integration with external systems and models, allowing Salesforce users to use external LLMs for generating AI-driven insights and automation.

Salesforce Agentforce Specialist References:

For more details, check the Model Builder guide here: https://help.salesforce.com/s/articleView?id=sf.model_builder_external_models.htm

For a sales rep who may miss key details during long sales calls, the Agentforce Specialist should recommend the Call Summary feature. Call Summary uses Einstein Generative AI to automatically generate a concise summary of important points discussed during the call, helping the rep quickly review the key information they might have missed.

Call Explorer is designed for manually searching through call data but doesn ' t summarize.

Sales Summary is focused more on summarizing overall sales activity, not call-specific content.

For more details, refer to Salesforce ' s Call Summary documentation on how AI-generated summaries can improve sales rep productivity.

According to the AgentForce Monitoring and Evaluation Framework, the three key dimensions for measuring AI agent quality are performance, correctness, and user satisfaction. To accurately monitor these, organizations should track:

Response times (to assess system and model latency),

Accuracy and relevance of answers (to measure the grounding and reasoning quality), and

Resolution success (to confirm task completion or problem-solving effectiveness).

These metrics provide a balanced evaluation of both technical efficiency and user experience.

Option A focuses on system usage metrics like tokens and duration, which are operational but do not assess correctness or success. Option B includes tone and CSATs, which are helpful but incomplete, as they do not measure factual accuracy or task resolution.

Thus, the correct answer is Option C – Response times, accuracy and relevance of answers, and resolution success, aligning with AgentForce’s standard evaluation practices.

According to the AgentForce Data Library Configuration Guide, administrators can restrict indexing and retrieval of Knowledge articles to publicly available ones and enable source visibility for LLM-grounded responses. The documentation states:

“Within the data library settings, under Knowledge Settings, enable ‘Use Public Knowledge Articles’ to ensure only publicly visible content is indexed. To display citations, enable ‘Show Sources’ so the agent links the specific articles or data records used to ground its response.”

Option A correctly reflects these two documented configuration steps.

Option B is incorrect because Salesforce explicitly supports source display for transparency through the “Show Sources” setting.

Option C incorrectly assumes that Data Categories control indexing visibility and source linking, which is handled by explicit Knowledge Settings, not categorization.

References (AgentForce Documents / Study Guide):

AgentForce Data Library Configuration Guide: “Knowledge Settings for Public Article Indexing”

AgentForce Transparency and Source Attribution Notes: “Show Sources Option”

AgentForce Study Guide: “Configuring Knowledge Visibility and Source Display”

The most critical technical consideration when pairing a prompt template ' s grounding data with a chosen Large Language Model (LLM) is the relationship between the two. The correct action is to review the model limitation in Prompt Builder versus the grounding data size (C).

Every LLM has a fixed context window limit, typically expressed in tokens (the model ' s units for processing text). This token limit defines the maximum amount of input data (the prompt template text + all the dynamic grounding data) and output data the model can handle in a single request.

The grounding data, which is pulled dynamically from Salesforce records (e.g., related lists, long text fields, Flow outputs), varies significantly in size from one record to the next. If the combined size of the prompt and the dynamic data for a specific record exceeds the LLM ' s token limit, the generative AI request will fail with a " token limit exceeded " error. The Agentforce Specialist must proactively design the template to limit the amount of data retrieved (e.g., using Flow to summarize related lists or querying only essential fields) to ensure it stays within the chosen model ' s capacity.

Option A is incorrect because the Einstein Trust Layer ' s token limit primarily relates to PII masking and is a security-related capacity, not the fundamental model ' s context window. Option B is incorrect because OFFSET is a SOQL query function used for pagination, which is irrelevant to ensuring the total size of the final assembled prompt (template + data) fits within the model ' s token limit.

Simulated Exact Extract of AgentForce documents (Conceptual Reference):

" A major challenge in prompt template design is managing the Large Language Model (LLM) token limit against the volume of grounding data. The specialist must always Review the model limitation in Prompt Builder versus the grounding data size before activation. LLM context windows (token limits) are fixed per model, but dynamic prompt components—such as merge fields from related lists or long text area fields—can cause the total size of the prompt to vary significantly by record. To prevent random token limit failures, the prompt instructions and grounding logic (Flow/Apex) must be explicitly constrained to retrieve only the essential data required to answer the query, ensuring the combined input stays well below the LLM ' s defined capacity. "

Simulated Reference: AgentForce Prompt Builder Best Practices Guide, Section 4: Performance and Scalability, p. 92.