Explanation:

Why B is correct:

Zero Copy is a Salesforce Data Cloud concept that allows you to access and query data residing in external systems (e.g., Snowflake, Databricks, Amazon S3, or other external databases) without physically ingesting or duplicating that data into Salesforce Data Cloud (which includes Data 360).

This perfectly matches the requirement: "ground a new Agentforce agent with structured data stored in an external system without duplicating it" and "ensure real-time data accuracy and minimize storage costs."

Zero Copy creates a virtual connection to the external data, treating it as if it were native to Data Cloud. When the Agentforce agent grounds a response, it queries the external system in real time via this virtual layer, ensuring the data is always current and avoiding the storage costs and latency associated with duplication or batch ingestion.

Why A is incorrect:

A semantic index is used within Data Cloud to enable vector-based semantic search and retrieval-augmented generation (RAG) on data that has already been ingested into Data Cloud.

Establishing a semantic index on external content would first require that the content be brought into Data Cloud, which violates the requirement of "without duplicating it."

Why C is incorrect:

A data stream is explicitly designed to import or ingest data into Data Cloud from external sources (via batch or streaming).

Configuring a data stream would physically copy the external data into Data Cloud, which directly contradicts the requirement to not duplicate it and would incur additional storage costs.

References:

• Salesforce Official Documentation: Data Cloud Zero Copy Data Access – defines Zero Copy as the capability to access external data virtually without ingestion, enabling real-time querying from external data lakes and warehouses.

• Trailhead Module: Get Started with Data Cloud > Unit: Connect External Data with Zero Copy – highlights that Zero Copy is the recommended approach for grounding agents with external data when real-time accuracy and cost minimization are priorities.

Explanation:

Agent Script provides a set of built-in @utils functions that can be used directly, out of the box, with no custom backend code (no Apex, no Flow required) to accomplish exactly the three capabilities described:

@utils.setVariables — Tells the agent to define or update a conversational state variable based on a natural language description of how it should be set (for example, from something the customer said). This is a native, declarative way to manage conversational state.

@utils.transition to — Tells the agent to move or navigate to a different subagent (formerly "topic"). This can be used deterministically (via conditional logic) or exposed as a tool the LLM can invoke, and it works natively without any external orchestration logic.

@utils.escalate — Tells the agent to escalate or hand off the conversation to a human service representative. This only requires an active Omni-Channel connection configured declaratively in a connection block (with outbound_route_type and outbound_route_name), not a custom Apex class or custom backend code.

All three are native Agent Script utility functions designed to be used directly, which is exactly why they minimize technical debt — no custom Apex and no custom Flow logic required.

Why not B:

@utils.escalate does not require a custom Apex class. It only requires a properly configured Omni-Channel connection (declarative setup via a connection block specifying the routing type and name). This is configuration, not custom code.

Why not C:

@utils.transition to does not require a Flow to define the target subagent at runtime. The target subagent is referenced directly in Agent Script (e.g., @utils.transition to @subagent.subagent_name), either deterministically via conditional logic or as an LLM-callable tool. No Flow is needed to resolve the target.

Reference:

Agent Script Utils reference (Salesforce Developer Guide): @utils.setVariables, @utils.transition to, @utils.escalate — all native, declarative utility functions usable directly in Agent Script without custom backend code.

@utils.escalate requires only an Omni-Channel connection block configuration, not Apex.

Explanation:

Chunking is a foundational step in Retrieval-Augmented Generation (RAG) pipelines, including those used by Agentforce's Data Libraries/retrievers. Because large language models have limited context windows and semantic search works best on focused, coherent units of text, large source documents are broken down into smaller, manageable units — often called passages or chunks. Each chunk is then individually indexed (typically as a vector embedding) so that when a partner asks a question, the retriever can find and return only the most relevant passages, rather than the entire document. This significantly improves both retrieval accuracy and response relevance, since the LLM is grounded on focused, on-topic content rather than being overwhelmed with irrelevant surrounding text.

Why not B:

The whole point of chunking is to avoid sending entire documents to the LLM. Returning full documents would be inefficient, could exceed context window limits, and would reduce retrieval precision because irrelevant sections would dilute the grounding context. RAG retrieves only the most relevant chunks or passages, not full documents.

Why not C:

Chunking strategies are not interchangeable — they directly impact retrieval quality. Factors like chunk size, overlap, and splitting method (by paragraph, fixed token count, semantic boundaries, etc.) significantly affect whether relevant information is captured coherently or awkwardly split across chunks, which in turn affects how accurately the retriever can match a query to the right content. Choosing the right chunking strategy is a key configuration decision when setting up a Data Library or retriever.

Reference:

RAG (Retrieval-Augmented Generation) fundamentals: chunking → embedding → indexing → semantic retrieval → grounding.

Agentforce Data Libraries and retrievers rely on well-tuned chunking to ensure large documents (like inventory catalogs, partner agreements, or policy manuals) are retrievable at the passage level for accurate, relevant grounding.

Explanation:

Option C (Correct):

Salesforce supports Bring Your Own LLM (BYOLLM) in Einstein Studio. By registering the Amazon Bedrock model as a BYOLLM, the Specialist can explicitly bind the prompt template to that model. This ensures deterministic routing and compliance with the requirement to avoid default OpenAI models.

Option A:

Restricting metadata access via permission sets does not control runtime model routing. Even if the Agent User cannot read OpenAI metadata records, the system could still attempt to route prompts to the default model. This does not guarantee compliance.

Option B:

Configuring a Data 360 Private Connect endpoint reroutes traffic at a network level, but it applies globally, not at the prompt template level. The requirement is specific to one customer service prompt, so this approach is too broad and lacks precision.

Reference:

Salesforce documentation on BYOLLM in Einstein Studio explains how external models (like Amazon Bedrock) can be registered and explicitly selected for prompt templates, ensuring compliance and deterministic routing.

Explanation:

Agentforce Observability and session tracing parse complex, multi-turn AI logs from Data Cloud in real-time or near-real-time to map out the reasoning paths, executed actions, and classification details of human-to-agent conversations.

Why B is correct:

When an end-user session finishes or goes idle, its logs enter a telemetry queue. Before Data Cloud completely ingests, transforms, and runs analytics workflows on the interaction data, the session stays in an "unprocessed" state. If a specialist jumps into the troubleshooting panel right away and finds nothing under the Processed Sessions tab, the best next operational check is the Unprocessed Sessions tab to see if it is simply queued in the pipeline.

Why A is incorrect:

The absence of a single session does not mean the agent itself isn't registered with the Observability application. If the agent weren't registered, you wouldn't track any history at all, rather than missing just the most recent user interaction.

Why C is incorrect:

A 24-hour batch processing model would make active real-time troubleshooting and debugging impossible. Agentforce session logs do not rely on daily batch windows; they flow continuously through ingestion pipelines.

Reference

Salesforce Agentforce Management & Monitoring: Troubleshooting with Agentforce Observability. The Observability workspace splits session tracking data into processing states. Real-time traces first clear the ingestion and parsing pipeline (visible under Unprocessed/Pending states) before moving completely into the fully parsed Processed Sessions log dashboard.