Explanation:

When previewing a prompt template in Agentforce, the specialist sees two outputs: Resolution and Response. These represent different stages of the prompt execution process.

What Resolution Means:
Resolution is the actual output generated by the LLM, based on the sample input data provided (such as a sample record or grounding data).
It lets you preview what the LLM will say or generate when the prompt runs in production.
It’s useful for testing how the LLM interprets and responds to the prompt structure and inputs.

A. It shows the full text that is sent to the Trust Layer
❌ Incorrect – The Trust Layer is involved in security, grounding, and policy enforcement, but the Resolution text does not show the raw prompt or inputs sent to the Trust Layer.

C. It shows which sensitive data is masked before it is sent to the LLM
❌ Incorrect – Data masking and redaction (handled by the Trust Layer) is not shown in the Resolution view. That process occurs earlier, before the prompt is sent to the LLM.

✅ The Resolution output in prompt preview is the LLM's response based on sample data, helping specialists understand and refine prompt behavior before deployment.

Explanation:

Summary:
Cloud Kicks needs to connect its custom-built website chat interface directly to an Einstein Agent. This is a classic custom integration scenario where an external application (the website) must be able to send messages to and receive responses from the agent's backend services. A secure, programmatic interface is required for this real-time communication.

✅ Correct Option: C

C. Agent API:
This is the correct framework for this task. The Agent API provides a set of REST endpoints that allow any external custom application (like a website, mobile app, or third-party system) to initiate and manage conversations with an Einstein Agent. It is the standard way to build a custom chat interface.

❌ Incorrect Options:

A. Agent-to-Agent (A2A):
This protocol is used for communication between two different Einstein Agents, allowing them to collaborate or transfer conversations. It is not designed for connecting a custom customer-facing website to a single agent.

B. Model Context Protocol (MCP):
MCP is a standard for connecting LLMs to external data sources and tools (like APIs and databases). It is used to enhance an agent's capabilities with real-time data, not as the primary communication channel between a website and the agent service itself.

Reference:
Salesforce Help: Agent API

Explanation:

Why C is correct:
In Agent Script, variable declarations have specific keywords that control mutability. The syntax is:
text
variable_name: type = value

By default, when you declare a variable without the mutable keyword, it is treated as read-only (immutable). This means:

* The variable can be initialized with a value (e.g., order_id: string = "").
* However, it cannot be updated or reassigned at runtime, including by actions or utilities like @utils.setVariables.
* Attempting to update an immutable variable via @utils.setVariables will fail silently or produce an error, and the variable will retain its original value ("") in this case.

For a variable to be updatable at runtime, it must be explicitly declared with the mutable keyword:
text
mutable order_id: string = ""

This design ensures that specialists can intentionally protect certain variables from being overwritten during the conversation, providing better control and security.

Why A is incorrect:
The mutable keyword is not optional if you intend to update the variable. It has a critical effect: its presence determines whether the variable can be changed at runtime. Without it, the variable is read-only. The statement that "the mutable keyword is optional and has no effect" is factually incorrect in Agent Script.

Why B is incorrect:
Omitting the mutable keyword is not a syntax error. The declaration order_id: string = "" is perfectly valid Agent Script syntax. It simply creates a read-only variable. The agent will deploy and run successfully, but the variable will not update when @utils.setVariables is called. The failure is a runtime behavior issue, not a deployment syntax error.

References:
Salesforce Official Documentation: "Agent Script Variables and Mutability" – explicitly defines that variables declared without the mutable keyword are immutable and cannot be modified by actions or utilities after initialization.

Trailhead Module: "Build Agentforce Agents with Agent Builder" > Unit: "Manage State with Agent Script Variables" – demonstrates declaring variables with and without mutable, showing that mutable is required for runtime updates.

Agentforce Exam Guide (AI-201): Under "Agent Script and State Management" – emphasizes understanding variable mutability rules, including the use of the mutable keyword, and the behavior of @utils.setVariables with immutable variables.

Explanation

Why is "Messaging Session" the correct answer?

In Agentforce, the Messaging Session object stores the conversation transcript between the customer and the agent.

Key Features of the Messaging Session Object:

Stores the Entire Customer-Agent Conversation
The Messaging Session object maintains a record of the full chat history, including timestamps, messages, and interactions. This ensures that past interactions can be referenced during follow-ups.

Supports AI-Powered Work Summaries
Einstein AI uses Messaging Sessions to generate summaries of chat interactions for agents. These summaries are stored and accessible for later reference.

Links with Service Cloud for Case Resolution
If a conversation escalates into a case, the Messaging Session object can be linked to it. This allows support teams to review the conversation history without switching contexts.

Why Not the Other Options?

# A. Messaging End User
Incorrect because this object stores details about the customer (e.g., name, contact details) but not the conversation transcript.

# C. Case
Incorrect because Cases store structured service requests but do not contain raw conversation transcripts. Instead, cases may reference the Messaging Session object.

Agentforce Specialist References
Salesforce AI Specialist Material confirms that Messaging Sessions store chat conversations and support Einstein Work Summaries.

Explanation:

The most efficient approach is to create an Agentforce Data Library connected to the Salesforce Knowledge base, filtered to published articles only.

This approach is correct because:

• Agentforce Data Libraries are purpose-built to ground agent responses using Retrieval-Augmented Generation (RAG), which performs semantic search using vector embeddings rather than simple keyword matching. This satisfies the requirement for semantic understanding of customer questions.

• When a Data Library is connected to Salesforce Knowledge with a filter for published articles, it automatically indexes only current, published content. As subject matter experts update, publish, or archive articles, the Data Library reflects those changes without requiring updates to the agent, topics, or actions.

• This ensures outdated articles are never surfaced while minimizing ongoing administration and maintenance.

• It is a native, low-code capability designed specifically for grounding Agentforce responses, making it the most efficient solution.

Why A is incorrect

A. Use a Flow-based subagent action that queries the Knowledge object directly.

Although this approach retrieves current Knowledge data, it is not the best solution for this scenario.

Its limitations include:

• Requires custom Flow or SOQL logic to filter published articles and other conditions.
• Increases implementation and maintenance effort.
• Does not provide semantic or vector-based retrieval.
• Performs structured or exact queries rather than natural-language semantic matching.

Because it lacks semantic retrieval, it does not fully satisfy the business requirement.

Why C is incorrect

C. Use Data Cloud (Data 360) with a custom retriever in Einstein Studio.

This is a valid grounding architecture but is intended for more advanced scenarios.

Its drawbacks for this use case include:

• Primarily designed for external or harmonized data stored in Data Cloud.
• Requires additional configuration such as data mapping, indexing, and custom retriever setup.
• Introduces unnecessary complexity when the content already resides in Salesforce Knowledge.
• Results in more implementation and maintenance effort than a native Data Library.

While technically capable, it is less efficient than using an Agentforce Data Library for Salesforce Knowledge content.

Key Exam Concept

When Salesforce Knowledge is the primary grounding source, the preferred solution is an Agentforce Data Library.

This provides:

• Native Retrieval-Augmented Generation (RAG).
• Semantic search using vector embeddings.
• Automatic synchronization with published Knowledge articles.
• Low-code implementation with minimal maintenance.
• Protection against retrieving outdated or unpublished content through metadata filtering.

Custom retrievers in Data Cloud and Einstein Studio are generally reserved for scenarios involving external data sources, multiple repositories, or advanced retrieval customization rather than standard Salesforce Knowledge grounding.

Salesforce Reference
Salesforce documentation describes Agentforce Data Libraries as the native RAG-based grounding solution for Salesforce Knowledge and other supported content sources. Custom retrievers through Data Cloud and Einstein Studio are intended for advanced or external data grounding scenarios that require customized retrieval behavior beyond the standard Data Library capabilities.