Free Agentforce-Specialist Practice Test Questions (2026)

Explanation:

When configuring a Data Library that uses Salesforce Knowledge as a source, Identifying Fields are used to help Agentforce quickly recognize and label what a piece of content is about—essentially acting as a concise descriptor or title-like reference for the article, rather than the full content itself. Since Knowledge articles can be long and detailed, Salesforce recommends using short, concise summary fields (such as a "Summary," "Title," or similar text/text area field) as Identifying Fields. This allows Agentforce to efficiently reference and surface the correct article without needing to process the entire lengthy body of content just to identify it.

Identifying Fields are meant to be lightweight, metadata-like markers—not the full grounding content—which makes retrieval and matching more efficient and accurate.

Why the Other Options Are Incorrect:
A. The main contents of the article
The full article body is used for grounding and retrieval content (i.e., what gets chunked, vectorized, and retrieved to answer questions), not for identifying the article. Using the entire article body as an Identifying Field defeats the purpose of having a concise identifier and can reduce matching efficiency and accuracy.

C. A formula field with a concatenated key
While a formula field could technically contain a system-generated key, it does not serve the purpose of an Identifying Field. Identifying Fields are intended to be human-readable, concise, and meaningful summaries that help Agentforce—and users or administrators reviewing results—understand what the article is about, rather than acting as synthetic keys for internal deduplication or matching logic.

Reference:
Salesforce Agentforce documentation — "Configure a Data Library with Salesforce Knowledge" (guidance on selecting concise summary or text fields as Identifying Fields for article-based data sources).

Explanation:

In Agentforce Agent Script, procedural instructions (denoted by run @actions... and ordered sequentially) enforce deterministic execution order. This ensures that critical business logic—such as fraud checks—always runs before subsequent actions like issuing refunds.

Option A is incorrect:
Adding run does not merely "suggest" execution; it enforces it.

Option B is incorrect:
Procedural instructions do not affect conversational tone; they strictly control action execution order.

Option C is correct:
Procedural instructions guarantee that the fraud check will always execute before the refund action, eliminating inconsistency.

Reference:
Salesforce Documentation: Agentforce Procedural Instructions

Trailhead Module: Agentforce Script Basics

Salesforce Developer Guide: Action Execution Order in Agentforce

Explanation:

Summary:
Einstein Agent components, including the agent configuration, topics, and actions, are fully supported by Salesforce's standard deployment tools. The most straightforward and recommended method for moving metadata from a sandbox to production is by using Change Sets, which provide a user-friendly interface for selecting and deploying components without needing code.

Correct Option:

C) 📤 Create an outbound change set with all the necessary agent components, then upload to production.
🔹 Change Sets are the standard, no-code deployment tool for moving customizations between Salesforce environments.
🔹 Einstein Agent components are packaged as metadata and can be added to a Change Set just like any other customizable feature (e.g., custom objects, fields).
🔹 This method is administered directly within the Salesforce Setup menu, making it the most accessible option for administrators.

Incorrect Option:

A) 🔄 Manually recreate the agent... because change sets cannot be used.
This is incorrect. Agent components are deployable metadata. Manually recreating them is time-consuming, error-prone, and unnecessary.

B) 💾 Export agent components as JSON files and manually import them... using the Metadata API.
While technically possible, this is a complex, developer-oriented approach. Using the Metadata API directly is not the standard administrative path when Change Sets are available and fully supported.

Reference
Salesforce Help: Components Available in Change Sets

Explanation:

Agentforce Observability is the native Salesforce capability specifically designed to give admins, specialists, and business stakeholders visibility into how deployed agents are performing over time. It provides:

* Aggregated performance metrics, such as escalation rate to human agents, average session duration, resolution rates by topic, and other conversation-level KPIs — exactly what the support manager needs.
* Agent Analytics dashboards that surface these metrics in a consumable, visual format for reporting and trend analysis.
* The underlying Session Tracing Data Model, which captures detailed session-level and interaction-level data, allowing the specialist to drill down from aggregate trends into specific underperforming conversations/topics to diagnose root causes (e.g., which topics or actions are causing low resolution scores).

This combination—dashboards for the aggregate view plus session-level tracing for drill-down troubleshooting—is precisely what's needed to guide an optimization strategy (e.g., deciding which agent actions or topics need refinement).

Why the Other Options Are Incorrect:
B. Einstein Trust Layer Audit Trail
The Trust Layer audit trail is focused on trust, safety, and compliance logging (e.g., toxicity detection, data masking, prompt/response logging for governance purposes), not on business performance analytics like escalation rates or resolution scores. Token usage and temperature settings are technical or operational details, not the business performance insights the support manager is requesting.

C. Salesforce Optimization Report
The Salesforce Optimization Report is a general org health tool that identifies items such as unused fields, page layouts, automation, and technical debt. It is unrelated to Agentforce conversational performance metrics and does not provide agent-specific analytics such as escalation rates, session duration, or topic-level resolution scoring.

Reference:
Salesforce Agentforce documentation — "Agentforce Observability and Analytics" (Agent Analytics dashboards and the Conversation/Session Tracing Data Model for performance monitoring and optimization).

Explanation:

The requirement highlights the architectural impact of security and user verification models on record changes within Agentforce.

The correct behavior is described as follows:

When an autonomous agent operates under Credential-Based User Verification, the conversation session runs under the context of the logged-in, authenticated community user. Because the agent is acting on behalf of that specific customer, any Data Manipulation Language (DML) operations (such as record creation or modification) capture the authenticated Community User as the running user, updating the system audit fields (like Last Modified By) accordingly.

This verification method ensures that all standard Salesforce sharing rules, object permissions, and field-level security constraints of the authenticated user are strictly respected by the agent during the interaction.

Why the Other Options Are Incorrect

B. ❌ The Flow execution mode for the agent is set to System Context Without Sharing.
If an action or Flow were running in System Context Without Sharing, it would bypass user-level sharing rules and execute under the automated system user context rather than capturing the individual Community User's identity in standard audit trail fields.

C. ❌ Token-Based User Verification has been enabled, which in turn respects all sharing and field-level security.
While Token-Based User Verification confirms the user's identity via encrypted keys, it traditionally limits the agent's ability to seamlessly execute database actions and transactions natively inside the running user's context across Experience Cloud sites compared to the newer Credential-Based framework.

Reference
Salesforce Agentforce Service Cloud Release Notes: User Verification and Security Context.
Salesforce Help: Set Up Credential-Based User Verification for Enhanced Web Chat.

Exam Tip
When troubleshooting who modified a record during an Agentforce session:
Credential-Based User Verification = Actions run directly in the context of the logged-in user, respecting sharing rules and marking audit fields with the Community User's ID.
System Context (Without Sharing) = Runs with elevated system permissions, masking individual user context in favor of system-level audit updates.

Explanation:

Universal Containers (UC) wants to:

1. Use Generative AI with public LLMs
2. Avoid requiring sales and service reps to manually type prompts
3. Ensure consistency and efficiency in how prompts are structured and executed

The best Salesforce feature to address these needs is:

✅ Einstein Prompt Builder and Prompt Templates

These allow UC to:
1. Create reusable, standardized prompt templates for both sales and service use cases
2. Incorporate Salesforce data directly into the prompt via merge fields and grounding
3. Ensure that users don't have to manually craft prompts — they just trigger the AI via a button, flow, or automation

📘 Salesforce Reference:

“Use Einstein Prompt Builder to create prompt templates that automate the process of crafting and sending prompts to large language models. Templates ensure consistency and context in responses.”
— Salesforce Help: Prompt Builder Overview

❌ Why the other options are incorrect:

A. Agent Builder and Action: Query Records
❌ Incorrect – This is used for retrieving Salesforce data using agents, not for generating consistent AI-powered messaging or content.

C. Einstein Recommendation Builder
❌ Incorrect – This is used for generating product or content recommendations, not for automating or standardizing the use of prompts with generative AI.

✅ Summary:

To reduce manual prompt entry and ensure consistency when using Generative AI, UC should use Einstein Prompt Builder and Prompt Templates.

Explanation:

Salesforce Knowledge articles provide built-in versioning and publishing controls. When integrated into an Agentforce Data Library (ADL), the agent automatically retrieves the current published version of the article. This ensures customers always receive the most up-to-date information without requiring manual index rebuilds or custom version management.

Option A is incorrect:
File-based ADLs do not have native versioning; they rely on manual updates and index rebuilds.

Option B is correct:
Knowledge-based ADLs leverage Salesforce Knowledge’s native versioning, guaranteeing that only the latest published content is surfaced.

Option C is incorrect:
File-based ADLs do not automatically serve the latest content — they require manual intervention.

Reference:
Salesforce Documentation: Agentforce Data Library Types
Salesforce Help: Knowledge Article Versioning

Explanation:

Summary
This scenario requires a no-code solution to synthesize data from multiple sources (Sales, Marketing, Service) to create a pre-call summary for a sales team. The goal is to leverage Salesforce's out-of-the-box AI capabilities without the overhead of custom model development, which is complex and unnecessary for this straightforward data summarization task.

Correct Option

C. 🚀 Use a prompt template grounded on CRM and Data Cloud data using standard foundation models.
This is the ideal no-code approach. Prompt Templates in Einstein allow you to instruct a standard, pre-built foundation model to generate summaries based on specific, grounded data from your CRM and Data Cloud.
It directly meets the requirement to summarize past purchases, show product interests, and recap conversations without any custom coding or model training, maximizing the sales team's efficiency as requested.

Incorrect Options

A. 🛠️ Deploy UC's own custom foundational model on this data first.
Building and deploying a custom foundational model is a massive, resource-intensive project requiring deep AI expertise and significant data volume. It is completely unsuitable for a no-code requirement and is massive overkill for the task of generating simple call summaries.

B. ⚙️ Fine-tune the standard foundational model due to the complexity of the data.
Fine-tuning is a process to specialize a model for a unique domain or task, which is not the case here. The data described (purchases, interests, transcripts) is standard business data that Einstein's standard models are already designed to handle for summarization. Fine-tuning adds unnecessary complexity and violates the "no-code" constraint.

Reference
Salesforce Help: "Prompt Templates" - This resource explains how Prompt Templates work with standard Einstein models to generate dynamic content grounded in your Salesforce data, perfectly aligning with the use case of creating a pre-call summary.

Explanation:

Why C is correct:
To implement a proper guard condition, the team must complete the full state management lifecycle. They have already completed two steps:

Declaring the variable (is_verified).
Configuring the verification action.

The missing piece is the runtime update of the variable. When the verification action successfully executes (e.g., the dealer's credentials are validated), the team must use @utils.setVariables within the agent's logic (typically in a follow-up action, within the verification action's output, or in the agent's response handling) to set @variables.is_verified = true.

This update ensures that:

The guard condition (available_when: @variables.is_verified == true) on the order details subagent evaluates to true at runtime.
The order details subagent becomes dynamically available to the Atlas Reasoning Engine only after successful verification.
The agent cannot attempt to access order details before verification completes.

Why A is incorrect:
This is only half the solution. Adding the available_when condition is necessary, but if the variable is never updated to true, the condition will never evaluate to true, and the subagent will remain permanently unavailable. The team must also implement the runtime variable update (Option C). Option A alone is insufficient.

Why B is incorrect:
Declaring is_verified as immutable (without the mutable keyword) would actually prevent the variable from being updated at runtime. Since the verification status starts as false and must change to true after verification, the variable must be mutable to support this state change. Making it immutable would break the intended workflow entirely.

References:
Salesforce Official Documentation: "Agent Script Guard Conditions and State Management" – explains that guard conditions evaluate runtime variables, and those variables must be explicitly updated using @utils.setVariables (or actions) to reflect state changes.

Trailhead Module: "Build Agentforce Agents with Agent Builder" > Unit: "Control Access with Guard Conditions" – demonstrates the full pattern: declare a mutable variable → set it via action/utility → evaluate it in an available_when condition.

Agentforce Exam Guide (AI-201): Under "Agent Configuration and Logic" – emphasizes that declaring a variable and adding a guard condition is insufficient without the corresponding runtime update logic to change the variable's value.

Explanation:

This scenario involves implementing an AI agent within an Experience Cloud partner portal that requires authentication. The agent needs to handle knowledge base queries about product specifications and capture lead submissions from partners. Since the agent operates within a secure portal environment answering support-related questions and managing business processes, the appropriate agent type must support authenticated access and service-oriented functions.

✅ Correct Option: C. Service Agent

🎯 Why This Is Correct:
Service Agent is the ideal choice for this authenticated portal scenario because it's specifically designed to operate within Experience Cloud sites with user authentication requirements. Service Agents can seamlessly access knowledge articles to answer product specification questions, integrate with standard Salesforce objects like Leads for data capture, and maintain security boundaries by restricting access to authenticated partner users only. This agent type excels at handling support inquiries and business process automation within secure, branded customer or partner portals.

❌ Incorrect Options:

Option A: Sales Agent
Sales Agents are primarily focused on sales-specific workflows like opportunity management, quote generation, and deal progression. While they can interact with Leads, they aren't optimized for knowledge base queries or partner portal deployment scenarios. Sales Agents typically serve internal sales teams rather than external authenticated portal users, making them unsuitable for this partner-facing, support-oriented use case requiring knowledge article access and secure portal integration.

Option B: Commerce Agent
Commerce Agents specialize in e-commerce transactions, shopping experiences, product catalog browsing, order management, and cart functionality. Although they work within Experience Cloud, their core purpose is facilitating buying journeys rather than answering knowledge-based product questions or capturing lead information. This agent type doesn't align with the requirement to query knowledge articles and submit leads, as it's designed for transactional commerce operations instead.

🔗 Reference:
Official Salesforce Agentforce Documentation