Explanation:

When configuring an Omni-Channel Flow (often referred to as an Omni-Flow) to manage conversations, cases, or transfers between humans and agents, Salesforce uses a unified workflow core action.

Why B is correct:

Route Work is the official standard core action element in Omni-Channel flows used to direct incoming records (like a Messaging Session or Voice Call) to its final destination. Within the configuration settings of the Route Work action, you specify the routing target by setting the Route To parameter.

For human agents, you can set it to a specific Queue, Skills, or an individual Agent. For AI escalations, you select Agentforce Service Agent within this exact same action block.

Why A and C are incorrect:

Neither "Route Conversation" nor "Route to Agent" are valid structural element names inside the Salesforce Flow Builder palette. They are descriptive terms for what the routing engine accomplishes, but they do not exist as standalone components.

Reference
Salesforce Service Cloud & Agentforce Help: Route to an Agentforce Service Agent / Create an Omni-Channel Flow. To route interactions dynamically within an Omni-Channel flow, administrators must drag the Route Work action onto the Flow Builder canvas and set the input parameters to define the target destination.

Explanation:

A Flex Prompt Template is designed to be extensible. If a business later decides that the prompt should accept an additional input—such as a PDF document—you do not need to recreate the template or reindex it. Instead, you can update the existing template by adding another resource.

Why B is correct

Agentforce allows you to modify an existing Flex prompt template by:

• Opening the template.
• Navigating to the Resources section.
• Adding and configuring the new resource (in this case, a PDF input).
• Updating the prompt logic to reference the new resource as needed.

This preserves the existing template while extending it to support additional inputs.

Why the other options are incorrect

A. Reindex in order to add a new resource to an existing template

Reindexing is associated with refreshing indexed data for search or retrieval scenarios. It is not the mechanism for adding a new input resource to a Flex prompt template.

❌ Incorrect.

C. Discard the current Flex template and create a new one with a resource

Recreating the template is unnecessary. Flex prompt templates are intended to be editable and support adding resources over time.

❌ This adds unnecessary work and loses continuity with the existing template.

Key Exam Concept

Flex Prompt Templates are editable after creation. If requirements evolve, you can:

• Add new resources.
• Configure additional inputs.
• Update prompt instructions.

There is generally no need to rebuild the template simply because new inputs are required.

References
Relevant Salesforce resources include:
• Prompt Builder documentation on Flex Prompt Templates and Resources.
• Trailhead: Get Started with Prompt Builder – Managing prompt template resources and inputs.
• Salesforce Agentforce documentation covering prompt template configuration.

Explanation

The recommended tool is the Model Playground.

Why Model Playground?

• It allows you to test prompts, actions, and agent behavior against multiple simulated or real-world user utterances in a controlled environment.

• You can iterate quickly on how the reasoning engine (Atlas) selects and invokes custom Agent actions based on different phrasings, without fully activating or deploying the action to a live agent.

• This is ideal for validating action relevance, grounding, and selection logic before going live.

Why Not the Others?

A. Agentforce:
This refers to the overall platform or agents in production/runtime — not a dedicated testing tool for pre-activation utterance testing.

B. Agent Builder:
Used for building and configuring agents, topics, and actions (including Agent Script). It is not the primary tool for rapid, multi-utterance testing of action invocation.

Explanation:

Why A is correct:

The question provides two critical diagnostic clues:

• Score reason: "ambiguous subagent match"
• Session Trace: "reasoning engine is consistently selecting the wrong subagent on most turns"

These clues point directly to a semantic overlap problem between subagent configurations. The Atlas Reasoning Engine selects subagents by evaluating their Description (natural language classification) and Entry Conditions against the user's input. When two or more subagents have overlapping, vague, or poorly scoped descriptions, the engine becomes "confused" and picks the wrong one.

The most viable solution is to refine the classification descriptions of the competing subagents. This means:

• Making each subagent's Description distinct, specific, and mutually exclusive (e.g., instead of "handles all billing questions," using "handles payment method changes and invoice disputes").

• Tightening the scope so that each subagent has a clear, non-overlapping domain.

This directly addresses the root cause identified by Agent Optimization and confirmed by Session Trace, without adding unnecessary complexity.

Why B is incorrect:

Adding new subagents for frequently misrouted intents is the opposite of what is needed. The problem is already that there are too many overlapping subagents causing confusion. Adding more subagents would introduce additional semantic overlap and worsen the routing problem instead of improving it. The correct solution is to refine existing subagents, not create new ones.

Why C is incorrect:

Extending the Data Library with more Knowledge articles addresses the grounding layer—what information the agent uses after a subagent has been selected.

However, the issue here is routing/selection (choosing the wrong subagent), not lack of knowledge. Adding Knowledge articles will not fix the reasoning engine’s inability to distinguish between subagent descriptions. The agent would still route incorrectly and simply answer with more information from the wrong path.

References:

• Salesforce Official Documentation: "Agentforce Observability and Agent Optimization" – states that "ambiguous subagent match" score reasons are resolved by refining subagent descriptions and entry conditions to reduce semantic overlap.

• Trailhead Module: "Monitor and Optimize Agentforce Agents" > Unit: "Using Agent Optimization" – emphasizes using Session Trace and quality scores to identify routing issues, then adjusting topic/subagent definitions as the primary remediation step.

Explanation:

The core problem is that employees do not know (and should not have to know) which specialized agent handles which type of request. The correct architectural fix is to remove that decision from the employee entirely by providing a single, unified entry point that intelligently routes the request behind the scenes.

Why SOMA is correct:

A Single Org Multi-Agent (SOMA) architecture does exactly this:

• Employees interact with one central/orchestrator agent.

• That central agent uses natural language understanding (intent classification) to determine what the employee actually needs (e.g., "reset my network password" → IT Support intent).

• It then routes the request to the appropriate specialized agent, topic, or action (IT Support, HR Assistant, Procurement, etc.) as a subagent — without the employee needing to select or even know about the underlying specialized agents.

• This provides centralized control and governance (permissions, monitoring, guardrails) over how requests are routed and handled.

• It also scales cleanly as new specialized agents are added, since new subagents can be plugged into the central router without changing the employee-facing experience.

This satisfies all three requirements: improved UX (no guessing), scalability (easy expansion), and centralized control (single governed entry point).

Why not A:

Adding a validation rule on the Agent Session object to block mismatched prompts is a reactive and brittle workaround, not an architectural solution. It still requires the employee to select an agent first, and validation rules cannot reliably interpret natural language intent. This approach would also require constant maintenance and does not scale as new agents are added.

Why not C:

A standalone multi-agent setup (separate, disconnected agents) does not solve the root problem. Employees would still need to choose the correct agent upfront. Adding prompts like "verify your department or role" only adds friction and still relies on the user to determine routing, rather than allowing the system to intelligently interpret intent.

Reference concepts:

Single Org Multi-Agent (SOMA) pattern in Agentforce: a primary/orchestrator agent with specialized subagents, using intent-based routing so end users have a single consistent entry point regardless of how many specialized capabilities exist behind it. This is Salesforce’s recommended pattern for scaling multiple internal-use agents while maintaining a simple, centralized user experience.