Free Agentforce Specialist Practice Test Questions

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:

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:

When the data you want to ground into a prompt is stored in an external system (like an ERP), and you want to call that external service in real-time to get data, the correct grounding technique in Salesforce Agentforce is: External Services Merge Fields

A. Eternal Object Record Merge Fields
❌ Incorrect – There's a typo here (likely meant to be "External Object Record Merge Fields"). Even so, External Objects are used for Salesforce Connect, which virtually maps external data but does not call the external service in real-time during prompt execution. It also doesn't support dynamic fetch during prompt generation.

B. External Services Merge Fields
✅ Correct – This feature allows prompt templates to invoke an API call to an external system (like ERP) and use that data directly in the prompt context. It's real-time, secure, and the proper way to get dynamic external data into LLM prompts.

C. Apex Merge Fields
❌ Incorrect – Apex Merge Fields are useful for custom logic and custom data manipulation within Salesforce, but they don’t inherently connect to external systems unless you write custom callouts in Apex (which would then be abstracted behind an Apex class, not recommended for direct grounding unless needed).

Explanation

Copilot Actions Page
Primary interface for managing all Copilot actions
"Use the Copilot Actions page to view, create, and manage actions for your copilot."

Record Page for Copilot Action
Edit specific action details and grounding
"Each action has its own record page where you can configure instructions, inputs, and outputs."

Copilot Action Library Tab
Browse and select from pre-built actions
"The Action Library provides reusable actions that can be assigned to your copilot."

Why Other Options Are Incorrect:

B. Global Actions
Global Actions are for page-level quick actions, not Copilot integration
"Global Actions appear across all pages in the global publisher layout."

C. Copilot Detail Page
Used for high-level settings, not action management
"The Copilot detail page shows basic information and activation status."

Implementation Note:
Always test actions in Sandbox first before deployment to production, as recommended in the Copilot Best Practices Guide.

Explanation:

To safely integrate a custom LLM into Salesforce while addressing security and privacy concerns, the AgentForce Specialist should:

Use Einstein Studio Model Builder

Why? Einstein Studio provides:
Secure, native integration with Salesforce data (no external callouts).
Compliance with the Einstein Trust Layer (data masking, audit trails).
Direct grounding in CRM data (e.g., {{Account.Name}}).

Steps:
Import the fine-tuned LLM into Einstein Studio.
Configure data access permissions.
Deploy as a Prompt Template in Salesforce.

Why Not the Other Options?

A. "iFrame embedding":

Security risk: Exposes Salesforce data to external systems.
Poor UX: iFrames are clunky and lack native integration.

C. "OpenAI callouts":
Violates data privacy: Raw customer data leaves Salesforce.
No Trust Layer protection: Masking/auditing isn’t automatic.

Reference:
Salesforce Help - Einstein Studio

Explanation

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.

Explanation:

To generate account action plans using Salesforce’s generative AI features, Universal Containers (UC) should use:

REST API

Why? The Einstein Generative API (part of Salesforce’s AI services) is REST-based and allows:

. Programmatic access to prompt templates and LLM-generated content.
. Integration with legacy systems via HTTP requests.
. Example: Call the API to generate an action plan from a prompt template grounded in Account data.

Why Not the Other Options?

B. "Metadata API":
Used for configuration management (e.g., deploying objects), not generative AI.

C. "SOAP API":
While functional, it’s less efficient for AI integrations compared to REST.

Implementation Steps:

Enable Einstein Generative API in Setup.

Use REST endpoints like:
POST /services/data/vXX.X/einstein/generativeai/prompts

Pass Account data as grounding inputs.

Reference:

Salesforce Help - Einstein Generative API