Chapter: Navigating the Copilot Studio

Interface like a Pro

1. Chapter Title & Objective
Chapter Name: Navigating the Copilot Studio Interface like a Pro Objective: By the end of this
chapter, you will be able to efficiently navigate the Microsoft Copilot Studio software-as-a-
service (SaaS) environment. You will master the primary navigation areas, understand the
purpose of specialized design canvases, and learn how to use integrated debugging tools to
streamline the agent development lifecycle.

2. Core Concepts & Theory

To build effectively, you must understand the geography of the Studio. The interface is designed
to support the "Build-Test-Publish" workflow through four primary regions.

A. The Home and Navigation Pane

The left-hand sidebar is your command center. It is categorized by function:

 Home: Overview of your agent’s status, recent activity, and quick-start templates.
 Topics: The heart of the logic. Here you define Custom Topics (user-defined) and
System Topics (pre-built logic like Greeting or Goodbye).
 Plugins: Where you manage AI actions and connectors that allow the agent to "do"
things (e.g., querying a database).
 Knowledge: The section for uploading documents or linking websites for Generative
Answers.
 Analytics: A suite of dashboards to track performance (CSAT, Deflection, and
Resolution rates).

B. The Authoring Canvas

This is a visual, low-code interface where you drag and drop "Nodes."

 Trigger Nodes: Define what starts the conversation.

 Action Nodes: Trigger Power Automate flows or AI plugins.
 Question Nodes: Collect information from the user and store it in Variables.

C. The Test Copilot Pane

[Link]
Always visible or easily togglable, this pane allows for real-time debugging. A critical feature
here is "Track between topics," which highlights the active node in the authoring canvas as you
chat with the bot, allowing you to see exactly where logic may be breaking.

D. The Publishing and Channels Menu

 Publishing: Converts your draft logic into a live version.

 Channels: Manages where your agent lives (Teams, Websites, Mobile Apps, or Demo
Websites).

3. Practical Case Study: "Rapid Prototyping for Retail"

Scenario: "TrendSetters Retail" wants to deploy a seasonal gift-guide agent in under 48 hours.
The developer needs to quickly ingest a PDF catalog and create a custom greeting.

Application of Interface Mastery:

1. Knowledge Tab: Instead of building 50 topics for 50 products, the developer navigates
to the Knowledge section and uploads the product PDF.
2. System Topics: They navigate to the Greeting system topic to customize the welcome
message to include "Welcome to the TrendSetters Holiday Guide!"
3. Test Pane: They use the Variable Watcher in the test pane to ensure that when a user
mentions a budget, the value is correctly captured in a {[Link]} variable.
4. Publishing: Within 4 hours, the developer uses the Channels menu to grab the code
snippet for the retail website's homepage.

4. Step-by-Step Example: Customizing the Authoring

Experience
In this example, we will navigate the interface to create a simple "Variable Capture" flow, a
fundamental skill for the AB-620 exam.

1. Create a New Topic: Navigate to the Topics tab on the left. Click + New Topic >
Create from description.
2. Define Trigger: In the Trigger node, enter "Check Order Status."
3. Add a Question Node: Click the + icon below the trigger. Select Ask a question.
o Question text: "What is your 5-digit Order ID?"
o Identify: Select Number.

[Link]
 o Save response as: Click the variable name and rename it to OrderNumber.
4. Open the Test Pane: Ensure the Test Copilot pane is open (bottom left).
5. Enable Tracking: Click the Track between topics icon (a small refresh/map icon) at the
top of the test pane.
6. Simulate: Type "Check Order Status" in the test chat.
o Observe the Authoring Canvas: The node you are currently on will be highlighted
in purple.
o Enter "12345": Watch the Variables tab in the test pane to see OrderNumber
update to 12345.

5. Multiple-Choice Questions (MCQs)

Q1. You are building an agent and want to see the real-time value of variables as you
interact with the bot. Which interface element should you use? A) The Analytics Dashboard
B) The Test Copilot Pane with Variable Watcher enabled C) The Knowledge Tab D) The
Settings > Security Menu

Answer: B Explanation: The Test Copilot pane is the only area providing real-time debugging.
The Variable Watcher (part of the test experience) allows developers to see how data is stored
and manipulated during a live conversation trace.

Q2. Where in the Copilot Studio interface would you go to modify the "Fallback" logic (the
message shown when the bot doesn't understand the user)? A) Home > Templates B) Topics
> System Tab C) Plugins > Custom Actions D) Channels > Mobile App

Answer: B Explanation: "Fallback" is a System Topic. System topics handle core

conversational behaviors that aren't specific to business logic but are necessary for a functional
agent.

Q3. A developer wants to connect their agent to a SharePoint folder to enable Generative
Answers. Which primary navigation section should they select? A) Topics B) Analytics C)
Knowledge D) Publish

Answer: C Explanation: The Knowledge section is the dedicated area for managing data
sources (SharePoint, Web URLs, Uploaded Files) that power the Generative AI capabilities of
the agent.

[Link]
Chapter: Designing High-Retention Topics
and Trigger Phrases
1. Chapter Title & Objective
Chapter Name: Designing High-Retention Topics and Trigger Phrases Objective: In this
chapter, you will master the art of conversation triggering and topic architecture. You will learn
how to craft robust trigger phrases that minimize "no-match" errors and design topic flows that
keep users engaged, ensuring high retention and successful task completion within Copilot
Studio.

2. Core Concepts & Theory

A. The Anatomy of a Trigger

A Trigger is the entry point to a conversation. In Copilot Studio, triggers are powered by Natural
Language Understanding (NLU). Unlike old-school keyword bots, Copilot Studio uses intent
recognition to map a user's utterance to a specific topic.

 Trigger Phrases: These are the example sentences you provide to train the agent.
 Precision vs. Recall: If phrases are too similar across different topics, the agent will
suffer from Topic Overlap, leading to the "Did you mean...?" disambiguation prompt.

B. Best Practices for Trigger Phrases

To ensure high accuracy, follow the 10-to-20 Rule:

 Aim for 10 to 20 diverse phrases per topic.

 Vary the length: Use short (e.g., "Refund status") and long (e.g., "I want to check where
my money is for the return I made") phrases.
 Avoid "Keyword Stuffing": Don't just list words; use natural language.
 Avoid Overlap: Ensure "Reset Password" and "Change Password" are distinct enough or
combined if the resolution path is the same.

[Link]
C. Designing for High Retention

Retention in an AI Agent context means the user completes their goal without abandoning the
chat. This is achieved through:

 Progressive Disclosure: Don't overwhelm the user with a wall of text. Break information
into bite-sized nodes.
 Variable Persistence: Use variables to remember user data (like their name or order ID)
throughout the session so they don't have to repeat themselves.
 Slot Filling: If a user says "I want to check my order #12345," the agent should be smart
enough to extract the ID immediately and skip the question "What is your order ID?".

3. Practical Case Study: "The Overlapping Intent Dilemma"

Scenario: "TechStore Inc." launched an agent with two topics: "Hardware Repair" and
"Hardware Replacement."

The Problem: Analytics showed that 40% of users were being asked "Did you mean Repair or
Replacement?" because the trigger phrases were too similar (e.g., "My laptop is broken" was
assigned to both). This friction led to a 15% drop-off rate (Low Retention).

The Solution: The team consolidated both into a single "Hardware Support" topic. Within the
topic, they used a "Multiple Choice" question node to ask the user if they were interested in
repair or replacement.

 Result: The disambiguation prompts disappeared, and topic completion (retention)

increased by 25%.

4. Step-by-Step Example: Advanced Triggering & Slot

Filling
This example demonstrates how to create a "Smart Trigger" that captures a variable immediately
using Python-style logic concepts within the Studio.

Phase 1: Setup the Topic

1. Navigate to Topics > + New Topic.

2. Name the topic: Store_Locator.

[Link]
 3. Add Trigger Phrases:
o "Where is the nearest shop?"
o "Find a store in London"
o "Are there any branches in New York?"

Phase 2: Implement Slot Filling

1. The NLU automatically identifies "London" and "New York" if you use Entities.
2. Add a Question Node: "Which city are you looking for?"
3. Set Identify to City (Prebuilt Entity).
4. Set the Selection Skip behavior: In the node properties, ensure "Ask every time" is
unchecked.
o Result: If the user says "Find a store in London," the bot skips the question and
moves straight to the search logic.

Phase 3: Logic Flow (Python Representation)

If we were to represent this logic in a technical backend, it would look like this:

Python
def store_locator_topic(user_input):
# Simulated NLU Entity Extraction
city = extract_entity(user_input, "City")

if not city:
city = input("Which city are you looking for?")

# Proceed with the business logic

find_store_in_database(city)
return f"I found three locations in {city}!"

5. Multiple-Choice Questions (MCQs)

Q1. You are reviewing an agent that frequently triggers the "Did you mean?" system
prompt. What is the most likely architectural flaw? A) The agent has too many System
Topics enabled. B) There is significant Topic Overlap between two or more Custom Topics. C)
The agent is using Generative Answers instead of Manual Topics. D) The user is typing in a
language not supported by the agent.

Answer: B Explanation: The "Did you mean?" prompt (Disambiguation) occurs when the NLU
engine finds a high confidence score for multiple topics simultaneously. This usually happens
because the trigger phrases are too similar across those topics.

[Link]
Q2. Which of the following is a key strategy for increasing "Retention" within a Copilot
Studio conversation? A) Forcing the user to restart the conversation if they make a typo. B)
Using "Slot Filling" to avoid asking for information the user has already provided. C) Using only
one trigger phrase per topic to keep logic simple. D) Disabling the "Back" button in the chat
interface.

Answer: B Explanation: Slot filling increases retention by making the conversation feel natural
and efficient. If an agent asks for information the user already provided in the initial trigger, it
creates frustration and leads to abandonment.

Q3. When designing trigger phrases for a "Flight Status" topic, which set of phrases
follows the recommended best practices? A) "Flight", "Status", "Plane", "Check" B) "I want to
check my flight", "What is the status of flight UA123?", "Is my plane on time?" C) Create 100
identical phrases to ensure the bot learns. D) Use only technical flight codes like "FL-STAT-01".

Answer: B Explanation: Option B provides a mix of natural language, varying lengths, and
specific intents. Option A is just a list of keywords (bad for NLU), and Option C leads to
"overfitting" which can break other topics.

[Link]
Chapter: The Power of Global vs. Local
Variables
1. Chapter Title & Objective
Chapter Name: The Power of Global vs. Local Variables Objective: In this chapter, you will
learn the critical differences between Variable Scopes in Microsoft Copilot Studio. You will
master how to store, retrieve, and manage data using Topic (Local) and Global (Bot) variables
to create personalized, context-aware AI agents that can carry information across complex
conversational boundaries.

2. Core Concepts & Theory

Variables are the "memory" of your AI agent. In Copilot Studio, managing this memory
efficiently is the difference between a disjointed experience and a seamless one.

A. Topic Variables (Local Scope)

Topic Variables are ephemeral. They are designed to live and die within a single conversation
thread or "Topic."

 Persistence: They are cleared as soon as the conversation moves to a different topic
(unless passed as a parameter).
 Best Use Case: Temporary data like a "Yes/No" confirmation for a specific question or a
temporary calculation.

[Link]
  Benefit: Keeps the bot’s memory clean and prevents "Variable Pollution" where old data
interferes with new logic.

B. Global Variables (Bot Scope)

Global Variables (prefixed with Global.) are the persistent memory of the agent.

 Persistence: Once set, the value remains accessible across all topics for the duration of
the user's session.
 Best Use Case: User profile data (e.g., [Link]), authentication tokens, or a
unique [Link] that might be referenced in multiple support scenarios.
 Persistence across Sessions: Some global variables can be marked for "External Source"
or "Start of conversation" to pre-populate data from the hosting environment (like a
logged-in SharePoint user).

C. System Variables

These are read-only variables provided by Microsoft.

 [Link]: The name of the user (if authenticated).

 [Link]: A unique identifier for the user session.
 [Link]: The name of your copilot.

3. Practical Case Study: "The Multi-Department Concierge"

Scenario: "FinEdge Banking" uses a single Copilot for both Loan Services and Account
Settings.

The Challenge: When a user identifies themselves in the "Loan Inquiry" topic, the bank wants
that identity to remain known if the user later switches to "Account Settings." If they use Local
variables, the user is forced to re-identify, leading to a high "Interaction Friction" score.

The Solution: FinEdge implements a Global Variable strategy.

1. When the user first provides their Account Number, it is saved as

[Link].
2. The user explores loans.
3. The user then says, "I want to change the address on this account."
4. The "Account Settings" topic triggers. Because [Link] is persistent, the
bot immediately greets them: "I see we are working with account XXXXX. Would you
like to update the address for this specific account?"

[Link]
Result: A 35% improvement in user satisfaction (CSAT) due to the reduced need for repetitive
data entry.

4. Step-by-Step Example: Managing Scope in the Canvas

This example demonstrates how to convert a local variable to a global one to ensure persistence.

Phase 1: Capturing the Data

1. In Copilot Studio, create a new topic: "User Onboarding".

2. Add a Question Node: "What is your preferred language?"
3. Identify: Language (Prebuilt Entity).
4. By default, the variable is created as [Link].

Phase 2: Elevating to Global Scope

1. Click on the variable [Link] within the Question node.

2. In the Variable Properties pane on the right, look for Variable Scope.
3. Select Global (any topic can access).
4. Notice the name changes to [Link].

Phase 3: Utilizing the Memory

1. Create a second topic: "Technical Support".

2. Add a Message Node.
3. Instead of typing a generic message, use the variable icon to insert {[Link]}.
4. Message: "I see your preference is set to {[Link]}. I will look for support
documents in that language."

5. Multiple-Choice Questions (MCQs)

Q1. A developer is building a bot where the user provides an "Invoice Number" in Topic
A. When the bot redirects to Topic B, the "Invoice Number" is blank. What is the most
likely cause? A) The variable was accidentally marked as "Sensitive." B) The variable was
scoped as a Topic variable rather than a Global variable. C) Topic B does not have the "Invoice"
entity enabled. D) The variable name contained a space.

[Link]
Answer: B Explanation: Topic variables only exist within the specific topic where they were
created. Once the conversation moves to Topic B, all Topic-level variables from Topic A are
flushed from memory. Global variables must be used for cross-topic persistence.

Q2. Which of the following is a potential risk of using Global Variables for every piece of
data collected? A) The bot will run out of storage space in the cloud. B) The LLM will become
slower at generating text. C) "Variable Pollution," where old data from a previous part of the
chat might lead to incorrect logic in a new topic. D) Global variables cannot be used in Power
Automate flows.

Answer: C Explanation: If every variable is global, the bot's memory becomes cluttered. If a
user starts a second task within the same session, the bot might incorrectly assume the "Old"
global value still applies to the "New" task, causing logic errors.

Q3. You want to pass the user's name from a website's login cookie directly into the Copilot
without the user typing it. What feature should you configure? A) A local variable with a
default value. B) A Global Variable with "Always fill this variable" and "External sources can
set values" (URL parameters/Context) enabled. C) A System Fallback topic. D) A Power
Automate flow that scrapes the browser's history.

Answer: B Explanation: Global variables can be configured to accept inputs from external
sources (like JavaScript on a webpage or a Teams context). This allows the agent to be "Context
Aware" before the first message is even sent.

Chapter: Mastering Entities for Intelligent

Information Extraction
1. Chapter Title & Objective
Chapter Name: Mastering Entities for Intelligent Information Extraction Objective: In this
chapter, you will learn how to transform raw user input into structured data. You will master the
use of Prebuilt Entities for common data types and the creation of Custom Entities using
Closed Lists and Regular Expressions (Regex). By the end of this chapter, you will be able to
build agents that "understand" specific business vocabulary and extract information with high
precision.

2. Core Concepts & Theory

[Link]
In the context of Microsoft Copilot Studio, Entities are the specialized tools used by the Natural
Language Understanding (NLU) engine to identify and categorize specific types of information
within a user's sentence.

A. What is an Entity?

If a Variable is a bucket that holds information, an Entity is the filter that ensures only the right
kind of information gets into that bucket. For example, if a user says, "I want to book a flight for
3 people on Friday," the agent uses entities to extract:

 3 (Number Entity)
 Friday (Date and Time Entity)

B. Prebuilt Entities

Microsoft provides a library of pre-trained entities that recognize common concepts out of the
box. Using these saves development time and increases accuracy.

 Age, City, Color, Date/Time, Email, Money, Number, Person Name, and Phone
Number.
 Advantage: These handle variations automatically (e.g., the Date entity recognizes
"tomorrow," "Jan 1st," and "next Monday").

C. Custom Entities

When your business uses specific terminology (like SKU numbers or service tiers), you must
build Custom Entities.

1. Closed List Entities: Use these when there is a set list of options. You can provide
Synonyms to help the bot understand that "Gold Tier," "Premium," and "Level 1" all
refer to the same value.
2. Regular Expression (Regex) Entities: Use these for highly structured data that follows a
pattern, such as Employee IDs (e.g., EMP-12345) or Tracking Numbers.

3. Practical Case Study: "Eco-Stream Utility Services"

Scenario: Eco-Stream Utility Services provides solar panel maintenance. To book a service,
customers must provide their Meter Serial Number, which always follows the format: two
letters, a hyphen, and four digits (e.g., SN-9042).

[Link]
The Problem: Initially, Eco-Stream used a generic "User's Entire Response" variable. However,
users often typed extra words (e.g., "My number is SN-9042, I think"). This caused the backend
database query to fail because it was searching for the whole sentence instead of just the ID.

The Solution: The developer implemented a Regex Custom Entity in Copilot Studio using the
pattern ^[A-Z]{2}-\d{4}$.

The Result: The agent now ignores the "fluff" in the sentence and extracts only the SN-9042
string. This increased successful database lookups from 45% to 98%, significantly reducing the
need for human intervention.

4. Step-by-Step Example: Creating a Custom Regex Entity

This example demonstrates how to implement the logic described in the case study.

Phase 1: Define the Entity

1. In Copilot Studio, navigate to the Entities tab on the left menu.

2. Click + New Entity and select Regular expression (Regex).
3. Entity Name: MeterID
4. Pattern: [A-Za-z]{2}-\d{4} (This looks for two letters, a dash, and four numbers).
5. Click Save.

Phase 2: Apply the Entity in a Topic

1. Go to Topics and create a "Check Meter" topic.

2. Add a Question Node: "Please enter your Meter Serial Number."
3. In the Identify dropdown, scroll down and select your custom MeterID entity.
4. Rename the variable to [Link].

Phase 3: Technical Validation (Python-style logic)

When you use a Regex entity, Copilot Studio essentially runs a match function similar to the
following:

Python
import re

def extract_meter_id(user_input):
# The Regex pattern defined in the Studio
pattern = r"[A-Za-z]{2}-\d{4}"

[Link]
 match = [Link](pattern, user_input)

if match:
extracted_id = [Link](0)
return f"Successfully extracted: {extracted_id}"
else:
return "Extraction failed. Pattern not found."

# Example usage
print(extract_meter_id("It's on the sticker, it says SN-9042"))
# Output: Successfully extracted: SN-9042

5. Multiple-Choice Questions (MCQs)

Q1. A user says: "I'd like to buy a crimson sweater." The agent is configured with a
Custom Entity called "ProductColor" which contains the value "Red" with the synonym
"Crimson." What value will be stored in the variable? A) crimson B) Crimson C) Red D)
Sweater

Answer: C Explanation: When using a Closed List entity with synonyms, Copilot Studio
performs "Normalization." It maps the detected synonym (crimson) back to the "Reference
Value" (Red), ensuring that backend systems receive consistent data regardless of how the user
phrased it.

Q2. Which Entity type is most appropriate for capturing a UK Postal Code (e.g., SW1A
1AA)? A) Prebuilt City Entity B) Closed List Entity C) Regular Expression (Regex) Entity D)
Boolean Entity

Answer: C Explanation: Postal codes follow a specific alphanumeric pattern but have too many
variations to list in a Closed List. A Regex entity is designed specifically to identify these types
of structured patterns.

Q3. What is the primary benefit of using the "Smart Matching" feature in a Closed List
Entity? A) It allows the bot to search the internet for missing values. B) It allows the NLU to
recognize values even if the user makes minor spelling mistakes or uses morphological
variations. C) It automatically translates the list into 40 different languages. D) It encrypts the
data so it can be stored in a Global Variable.

Answer: B Explanation: Smart Matching leverages the power of the NLU to bridge the gap
between a user's "fuzzy" input (e.g., "lapotop") and the intended list value ("Laptop"). This
significantly reduces the need for "Did you mean?" prompts.

[Link]
Chapter: Logic Gates: Using Conditions and
Loops Effectively
1. Chapter Title & Objective

[Link]
Chapter Name: Logic Gates: Using Conditions and Loops Effectively Objective: In this
chapter, you will learn how to transition from linear conversations to dynamic, intelligent
dialogues. You will master the use of Condition Nodes to branch logic based on user data and
understand the implementation of Loops and Lists to handle repetitive tasks and multiple data
points within Microsoft Copilot Studio.

2. Core Concepts & Theory

In Copilot Studio, logic gates act as the "brain" of the agent, allowing it to make decisions in
real-time based on variables, entities, or external data.

A. Condition Nodes (Branching Logic)

A Condition node allows the agent to evaluate a statement as True or False. You can build
branches based on:

 Variable Values: (e.g., If [Link] is greater than 18)

 Entity Recognition: (e.g., If [Link] is "Gold")
 Boolean Logic: Combining multiple conditions using And/Or operators.

B. Understanding Loops and Lists

While Copilot Studio is primarily a low-code environment, handling "Lists" of items (like a list
of recent orders or available appointment slots) requires structured iteration.

 The List Variable: A collection of data records.

 The 'For Each' Loop: This node allows the agent to cycle through every item in a list.
For example, if a database returns three open tickets, the agent can loop through them to
display each ticket's status to the user.

C. Adaptive Cards and Looping

Loops are frequently paired with Adaptive Cards. Instead of sending five separate messages,
you can loop through a list to build a single, formatted response that presents all options to the
user simultaneously.

3. Practical Case Study: "The Smart Fleet Manager"

[Link]
Scenario: "Velocity Logistics" uses an AI Agent to help drivers report vehicle issues. The agent
needs to determine the urgency of a repair.

The Logic Blueprint:

1. Condition 1: The agent asks, "Is the vehicle safe to drive?"

2. Branch A (True): The agent proceeds to a standard scheduling loop.
3. Branch B (False): The agent triggers an "Emergency" branch, immediately calling a
Power Automate flow to dispatch a tow truck.
4. The Loop: If the driver has multiple vehicles assigned, the agent retrieves a List of their
trucks and loops through them, asking, "Which vehicle is experiencing the issue: [Truck
A, Truck B, Truck C]?"

The Result: By using logical branching, the company reduced "Critical Failure" response times
by 80% because the agent no longer treated every repair request with the same priority.

4. Step-by-Step Example: Building a Tiered Discount

Branch
This example demonstrates how to use multiple condition branches to calculate a discount based
on a global loyalty variable.

Phase 1: Setup the Variable

1. Assume [Link] is already populated from a database.

2. Create a new topic: "Claim Discount".

Phase 2: Add the Condition Node

1. Click the + icon and select Add a condition.

2. Branch 1: Set to [Link] is greater than or equal to 1000.
o Action: Send message: "You qualify for our Platinum 20% discount!"
3. Branch 2: Click the + New Condition on the same node. Set to [Link] is
between 500 and 999.
o Action: Send message: "You qualify for our Gold 10% discount!"
4. All Other Conditions (Else):
o Action: Send message: "Spend more than $500 to unlock future rewards!"

Phase 3: Logical Representation (Python-style)

[Link]
Python
def calculate_discount(total_spend):
# This reflects the branching logic inside a Condition Node
if total_spend >= 1000:
discount = "20% (Platinum)"
elif 500 <= total_spend < 1000:
discount = "10% (Gold)"
else:
discount = "0% (Standard)"

return f"Your current discount level is: {discount}"

# Example Check
print(calculate_discount(1200)) # Output: Platinum

5. Multiple-Choice Questions (MCQs)

Q1. You want your agent to check if a user is from "Texas" AND has a "Premium"
subscription before offering a specific promotion. Which node configuration is required?
A) Two separate Question nodes. B) A single Condition node using the "All of (And)" logical
operator. C) A Loop node that iterates through the user's location history. D) A Message node
with a "Fast Forward" trigger.

Answer: B Explanation: To evaluate two separate criteria simultaneously, you use a Condition
node with an "And" operator. This ensures the branch is only taken if both requirements are met.

Q2. When an agent receives a "List" of items from a Power Automate flow, which node is
used to process each item in that list individually? A) Condition Node B) Variable Set Node
C) For Each Node D) Redirect Node

Answer: C Explanation: The "For Each" node is the specific looping mechanism in Copilot
Studio designed to iterate through a collection (List) of data.

Q3. What happens to the conversation if a user's input does not match any of the defined
branches in a Condition node? A) The agent crashes and restarts. B) The agent follows the "All
other conditions" (Else) path. C) The agent automatically redirects to the Home topic. D) The
agent asks the user to repeat the question 3 times.

Answer: B Explanation: Every Condition node includes a default "All other conditions"
branch. If no specific logic matches the user's data, the agent follows this path to ensure the
conversation doesn't hit a dead end.

[Link]
Chapter: Handling Conversation
Interruptions and Topic Switching
1. Chapter Title & Objective
Chapter Name: Handling Conversation Interruptions and Topic Switching Objective: In this
chapter, you will master the "Contextual Intelligence" of Copilot Studio. You will learn how to
configure agents that can gracefully handle user interruptions, understand the mechanics of
Topic Switching, and manage Global Interruptions to ensure a natural, human-like
conversational flow without losing the user's original intent.

2. Core Concepts & Theory

In a perfect world, users follow a linear path. In reality, users change their minds mid-
conversation. An agent that cannot handle interruptions feels robotic and rigid.

A. What is an Interruption?

An interruption occurs when a user provides input that does not relate to the current question but
matches a different Trigger Phrase in another topic.

B. Topic Switching Mechanics

Copilot Studio uses a "Mental Stack" to manage these switches.

 The Switch: If a user is in a "Book Flight" topic and suddenly asks "What's the weather
in London?", the bot identifies the "Weather" intent.
 Contextual Switching: The bot pauses the current topic, moves to the new topic, and—if
configured correctly—returns to the original topic.

C. Configuration Options

You can control how the agent reacts to interruptions at two levels:

1. Topic Level: You can enable or disable "Allow status transitions" to prevent users from
leaving critical flows (like a payment process).
2. Global Level: Using System Topics, you can define how the bot asks for confirmation
before switching (e.g., "I see you want to talk about X, should we leave our current
conversation about Y?").

[Link]
D. The "Backfill" and Variables

When a switch occurs, Global Variables persist, but Topic Variables are stored in the stack. If
the user returns to the original topic, the bot remembers where it left off and which questions
were already answered.

3. Practical Case Study: "The Indecisive Customer"

Organization: Alpine Ascents Retail Scenario: A customer is halfway through a "Warranty
Claim" topic, which requires a Serial Number and a Description. The Interruption: After
providing the Serial Number, the user suddenly asks, "Wait, what is your holiday return policy?"
The Old Way: The bot would either ignore the question or cancel the warranty claim entirely,
forcing the user to start over. The "Mastery" Way:

1. The agent identifies the Return Policy intent.

2. It pauses the Warranty topic.
3. It answers the policy question using Generative Answers.
4. It automatically resumes: "Now, back to your warranty claim. You already gave me the
Serial Number; can you now describe the defect?"

Result: A 40% reduction in "Abandonment Rate" during long-form data collection topics.

4. Step-by-Step Example: Configuring Interruption

Behavior
This example demonstrates how to set a topic to "Uninterruptible" for sensitive operations.

Phase 1: Identify a Critical Topic

1. Open Copilot Studio and navigate to your Topics list.

2. Select a topic where data integrity is vital, such as "Process Refund".

Phase 2: Adjust Interruption Settings

1. On the Authoring Canvas, click on the Topic Settings (the "..." or Details icon in the top
right).
2. Look for Interruption Policy.

[Link]
 3. Toggle the setting to "Off" if you want to force the user to finish the current flow before
the bot will recognize other intents.

Phase 3: Handling the Resume (Python-style logic)

While the Studio handles this visually, the underlying logic follows a "stack" pattern:

Python
conversation_stack = ["Topic_Warranty_Claim"]

def handle_user_input(input_text):
current_topic = conversation_stack[-1]

# Check for intent switch

new_intent = detect_intent(input_text)

if new_intent and new_intent != current_topic:

print(f"Pausing {current_topic}. Switching to {new_intent}.")
conversation_stack.append(new_intent)
execute_topic(new_intent)

# After completion of new_intent

conversation_stack.pop()
print(f"Resuming {conversation_stack[-1]} where we left off.")

5. Multiple-Choice Questions (MCQs)

Q1. A user is in the middle of a "Change Address" topic and asks "How do I cancel my
account?" instead of providing their street name. The bot switches to the Cancellation
topic. What is this behavior called? A) Fallback Triggering B) Topic Switching C) Slot Filling
D) Entity Extraction

Answer: B Explanation: Topic Switching is the specific capability of Copilot Studio to

recognize a change in user intent mid-flow and navigate to a more relevant topic without the user
having to restart the session.

Q2. You want to ensure that once a user starts the "Submit Payment" topic, they cannot
switch to any other topic until the transaction is complete. How should you configure this?
A) Delete all other topics from the bot. B) Set the Interruption Policy for the "Submit Payment"
topic to "Off" or "Disabled". C) Use a Global Variable to lock the keyboard. D) Set the "Submit
Payment" trigger phrases to "None".

Answer: B Explanation: By disabling interruptions at the topic level, you ensure the agent
ignores other intents until the current logic branch is finished. This is standard practice for secure
or transactional flows.

[Link]
Q3. What happens to the values stored in Topic Variables when a user switches to a
different topic and then returns? A) They are permanently deleted. B) They are reset to their
default values. C) They are maintained in the stack and are available when the topic resumes. D)
They are automatically converted into Global Variables.

Answer: C Explanation: Copilot Studio maintains the state of the conversation. When a topic is
interrupted and later resumed, the values collected during that specific session of the topic are
preserved, preventing the user from having to answer the same questions twice.

[Link]
Chapter: Advanced Slot Filling Techniques
1. Chapter Title & Objective
Chapter Name: Advanced Slot Filling Techniques Objective: In this chapter, you will learn
how to optimize conversational efficiency using advanced slot filling. You will master the
configuration of "Proactive Extraction," learn how to manage multi-slot inputs in a single
utterance, and understand how to use entity mapping to skip redundant questions, resulting in a
more fluid, human-like user experience.

2. Core Concepts & Theory

A. What is Slot Filling?

Slot filling is the process where the AI agent identifies and extracts specific pieces of
information (entities) from a user’s initial statement to fill required variables. Instead of the agent
asking five separate questions, it "fills the slots" it already has the answers for.

B. Proactive Extraction vs. Reactive Prompting

 Reactive Prompting: The bot asks, "What is your city?" -> User answers "Seattle." ->
Bot asks, "What is your travel date?"
 Proactive Extraction: User says, "I want to go to Seattle this Friday." The bot extracts
both City and Date immediately and skips those questions.

C. The "Skip Question" Logic

In Copilot Studio, every Question Node has a property for Question Behavior. To master
advanced slot filling, you must configure the "Selection Skip" logic.

 Ask Every Time: The bot will ask the question even if it already knows the answer.

[Link]
  Skip if Value Exists: (The Default/Advanced setting) The bot checks if the variable is
already populated via a trigger phrase or a global variable. If it is, the bot moves to the
next node silently.

D. Multi-Entity Disambiguation

Advanced slot filling also involves handling complex sentences where a user might provide two
similar entities (e.g., "Move money from Savings to Checking"). You will learn to map these to
specific slots like SourceAccount and DestinationAccount.

3. Practical Case Study: "Direct-to-Consumer Pharmacy"

Organization: HealthFast Rx Scenario: Customers use the AI agent to refill prescriptions. A
standard refill requires a Drug Name, a Pharmacy Location, and a Pickup Time.

The Problem: The initial bot design was too "chatty." Even if a user said, "I need a refill for
Amoxicillin at the Downtown branch," the bot would still ask, "Which medication do you need?"
This caused high user frustration and a 20% abandonment rate.

The Solution: The developer implemented Advanced Slot Filling.

1. They defined Medication and BranchLocation as Custom Entities.

2. They enabled "Skip if value exists" on all extraction nodes.
3. They added diverse trigger phrases including multi-slot examples.

The Result: Experienced users could complete a refill in a single sentence ("Refill my
Amoxicillin at Downtown"). The "Turn-Count" (number of messages sent) dropped from 8 to 2,
and user satisfaction scores increased by 45%.

4. Step-by-Step Example: Implementing Multi-Slot

Extraction
This example demonstrates how to configure a topic to handle multiple data points from one
sentence.

Phase 1: Create the Topic and Entities

[Link]
 1. In Copilot Studio, ensure you have a Custom Entity for CarModel (e.g., SUV, Sedan,
Coupe).
2. Create a new topic: "Book Test Drive".
3. Add Trigger Phrases:
o "I want to test drive a Sedan in London."
o "Book a test drive."

Phase 2: Configure the Nodes

1. Node 1 (Question): "Which car model are you interested in?"

o Identify: CarModel
o Save response as: [Link]
2. Node 2 (Question): "In which city would you like to drive?"
o Identify: City (Prebuilt Entity)
o Save response as: [Link]

Phase 3: Setting the Behavior

1. Click the Question Node 1. In the properties pane, click Question behavior.
2. Ensure Skip question is enabled (set to "If variable has a value").
3. Repeat for Question Node 2.

Logic Flow (Python Representation)

If we were to represent this advanced extraction in code, it would look like this:

Python
def test_drive_booking(user_utterance):
# Slots to be filled
slots = {"SelectedModel": None, "TargetCity": None}

# Advanced extraction (NLU Layer)

slots["SelectedModel"] = extract_entity(user_utterance, "CarModel")
slots["TargetCity"] = extract_entity(user_utterance, "City")

# Logic Gate: Skip question if slot is already filled

if not slots["SelectedModel"]:
slots["SelectedModel"] = input("Which car model are you interested
in?")

if not slots["TargetCity"]:
slots["TargetCity"] = input("In which city would you like to drive?")

return f"Booking a {slots['SelectedModel']} in {slots['TargetCity']}..."

[Link]
5. Multiple-Choice Questions (MCQs)
Q1. A user says "Book a room for 2 people in Paris." If the agent is configured with proper
slot filling, what happens to the Question Node that asks "How many guests?" A) The node
is deleted from the topic. B) The node is executed, but the user's previous answer is ignored. C)
The node is skipped because the 'Number' entity was proactively extracted. D) The agent asks for
confirmation: "Did you mean 2 people?"

Answer: C Explanation: When slot filling is active and the "Skip if value exists" behavior is
set, the agent identifies the '2' as a Number entity and 'Paris' as a City entity. It populates the
variables and bypasses those specific Question Nodes.

Q2. Which property must be checked to ensure an agent doesn't ask a question for a
variable that has already been provided via a URL parameter or a previous topic? A) Ask
every time B) Skip if value exists C) Always prompt D) Secure variable

Answer: B Explanation: "Skip if value exists" is the engine behind slot filling. It tells the agent
to check the current memory (Global or Topic variables) before interrupting the user with a
question.

Q3. What is the main benefit of Slot Filling for Business Value ROI? A) It reduces the cost
of Azure hosting. B) It reduces "Turn-Count," making the bot more efficient and increasing task
completion rates. C) It allows the bot to speak more languages. D) It prevents the bot from
needing an internet connection.

Answer: B Explanation: Efficiency is a key metric in AI ROI. By reducing the number of steps
a user must take to reach their goal, you improve the user experience and reduce the likelihood of
the user abandoning the conversation out of frustration.

[Link]
Chapter: Designing the Fallback Strategy:
When the Agent is Stuck
1. Chapter Title & Objective
Chapter Name: Designing the Fallback Strategy: When the Agent is Stuck Objective: In this
chapter, you will learn how to manage conversational failures gracefully. You will master the
configuration of the System Fallback Topic, understand how to implement "Escalation" logic to
human agents, and learn best practices for using Generative AI to minimize dead-ends, ensuring
your agent remains helpful even when it doesn't have a direct answer.

2. Core Concepts & Theory

In AI development, a "No-Match" event occurs when the user's input does not meet the
confidence threshold for any existing trigger phrase. Without a solid fallback strategy, the agent
simply stops or repeats itself, leading to a "Bot Loop" that destroys user trust.

[Link]
A. The System Fallback Topic

The Fallback is a built-in system topic that triggers when the Natural Language Understanding
(NLU) engine is "stuck."

 The Intent Threshold: Every input is assigned a confidence score. If no topic score
exceeds the threshold (usually 0.1 - 0.2), the Fallback is activated.
 Default Behavior: By default, the bot may say, "I'm sorry, I didn't understand that. Can
you rephrase?"
 Customization: Pro developers customize this topic to offer alternative paths, such as
searching a knowledge base or offering a menu of popular topics.

B. Escalation Path

When an agent fails repeatedly (usually after 2 or 3 attempts), the blueprint should dictate an
Escalation.

 Handoff to Live Agent: Transfers the transcript and context to a human via Dynamics
365 Omnichannel or a third-party service.
 Asynchronous Handoff: Creating a ticket in a system like Jira or ServiceNow via Power
Automate if a live agent is unavailable.

C. Generative Answers as a "Safety Net"

Before hitting a hard fallback, you can use Generative Answers. This allows the agent to search
unstructured data (SharePoint, Websites) to find an answer that wasn't manually programmed.

3. Practical Case Study: "The Frustrated Policy Holder"

Organization: SecureShield Insurance Scenario: A customer is trying to ask about "Pet
Insurance for Exotic Birds," a niche product not explicitly covered by the agent's manual topics.

The Failure: Originally, the agent used a standard fallback: "I don't understand. Please try
again." The user tried three times and eventually closed the chat, resulting in a lost lead.

The Strategy Implementation:

1. Level 1 (NLU): Attempt to match manual topics. (No match found).

2. Level 2 (Generative AI): The Fallback topic was customized to trigger a "Generative
Answers" node pointing to the company's internal product Wiki.

[Link]
 3. Level 3 (Human Handoff): If the user still clicked "This didn't help," the bot triggered a
Power Automate flow to create an urgent callback task for the sales team.

Result: Lead abandonment dropped by 55%, and "Unresolved Queries" decreased as the
Generative AI found the exotic bird policy in a buried PDF.

4. Step-by-Step Example: Customizing the Fallback Topic

This example demonstrates how to turn a "dead-end" into a "knowledge search."

Phase 1: Enable the System Fallback

1. In Copilot Studio, go to the Topics tab.

2. Select the System tab at the top.
3. Click on Fallback. (If it is not there, you may need to go to Settings > System Fallback
and click Add).

Phase 2: Insert Generative Search

1. On the Fallback authoring canvas, delete the default "I'm sorry" message.
2. Click the + icon and select Create generative answers.
3. In the Input field, use the variable [Link].
4. In the Data Sources, ensure your company website or SharePoint is linked.

Phase 3: Add the "Final" Escalation

1. Below the Generative Answers node, add a Condition node.

2. Check if the search was successful. If not (or if the user indicates it wasn't helpful):
3. Add a node: Topic Management > Transfer to Agent.
4. Include a private message for the human: "User is stuck on a niche query. Last input:
{[Link]}."

Logic Representation (Python-style)

Python
def fallback_logic(user_input, retry_count):
if retry_count < 2:
# Attempt Generative Search
answer = search_knowledge_base(user_input)
if answer:
return answer
else:

[Link]
 return "I couldn't find a direct match. Can you rephrase?"
else:
# Escalate to human
return trigger_human_handoff(user_input)

5. Multiple-Choice Questions (MCQs)

Q1. What variable does the Fallback topic use to access the user's most recent
unrecognized utterance? A) [Link] B) [Link] C)
[Link] D) [Link]

Answer: B Explanation: [Link] is the pre-built variable that stores the exact
text the user typed which failed to trigger a topic. It is essential for passing context to Generative
Answers or a human agent.

Q2. When designing a fallback strategy, what is the primary purpose of "Escalation"? A)
To restart the bot's server. B) To increase the price of the subscription. C) To transition the user
to a human agent or a ticketing system when the bot cannot resolve the issue. D) To delete the
user's conversation history for privacy.

Answer: C Explanation: Escalation ensures that the user's journey doesn't end in frustration. It
moves the "stuck" conversation to a human resource, maintaining the business value of the
interaction.

Q3. If an agent is constantly triggering the Fallback topic for common phrases like "Check
my status," what is the most likely technical fix? A) Increase the number of Fallback topics.
B) Add "Check my status" as a trigger phrase to the relevant Custom Topic. C) Disable the
Fallback topic entirely. D) Change the bot's name.

Answer: B Explanation: If a specific phrase is hitting the fallback, it means the NLU does not
recognize it as a trigger. Adding it (or variations of it) to a manual topic improves the agent's
"Recall" and prevents unnecessary fallbacks.

[Link]
Chapter: Building Multilingual Agents for
Global Markets
1. Chapter Title & Objective
Chapter Name: Building Multilingual Agents for Global Markets Objective: In this chapter,
you will learn how to design, configure, and manage AI agents that support multiple languages
within a single interface. You will master the selection of primary and secondary languages,

[Link]
understand the mechanics of automatic language detection, and learn how to provide localized
content to ensure your agent resonates with a global audience.

2. Core Concepts & Theory

Expanding an agent's reach to global markets involves more than just literal translation; it
requires an architectural understanding of how Microsoft Copilot Studio handles linguistic
diversity.

A. Primary vs. Secondary Languages

When you create a copilot, you define a Primary Language. This sets the baseline for the NLU
(Natural Language Understanding) model. To support global markets, you add Secondary
Languages.

 The Model: Copilot Studio uses a multilingual NLU model that allows the agent to
understand intents across different languages while maintaining the same logic flow.
 Localization: You must provide localized versions of trigger phrases, messages, and
question prompts for each secondary language added.

B. Automatic Language Detection

Copilot Studio can automatically detect the language a user is typing in.

 The Switch: If a user begins a conversation in French, the agent can switch its responses
to the French localized strings defined in the "Localization" table.
 Manual Override: You can use system variables to force a specific language if the user's
preference is already known (e.g., from a website setting).

C. Translation Methods

1. Manual Localization: Exporting the localization file (JSON or ResX), translating it via
professional services, and re-importing it. This ensures the highest "Warm Storytelling"
quality.
2. Generative Answers Translation: When using Generative AI, the agent can often
translate knowledge base content on the fly, though this is less controlled than manual
localization for core topics.

D. The Localization File

[Link]
The localization file contains "Keys" (the original English string) and "Values" (the translated
string). At runtime, the agent looks up the value based on the current [Link] setting.

3. Practical Case Study: "EuroTravel Concierge"

Organization: EuroTravel Solutions The Challenge: EuroTravel provides booking support for
travelers across England, France, and Germany. Maintaining three separate bots was causing
high maintenance costs and inconsistent data logging.

The Solution:

1. Consolidation: They created one "Master Agent" with English as the Primary language
and added French and German as Secondary languages.
2. Logic Sharing: The complex "Refund Policy" logic, which involves multiple Power
Automate calls to banking APIs, was built once.
3. Localization: They exported the localization spreadsheet. While the logic remained the
same, the user saw "How can I help?" in London, "Comment puis-je vous aider ?" in
Paris, and "Wie kann ich Ihnen helfen?" in Berlin.

The Result: Maintenance time was reduced by 60% because API updates only needed to be
performed in one topic, while the agent remained natively accessible to all three markets.

4. Step-by-Step Example: Adding a Secondary Language

This example demonstrates the workflow for enabling a multilingual experience.

Phase 1: Enable Secondary Languages

1. Open your agent in Copilot Studio.

2. Navigate to Settings > Languages.
3. Click Add languages and select Spanish (Spain).
4. Click Add.

Phase 2: Localize a Topic

1. Go to the Languages page again and click Download localization data.

2. Open the downloaded file. Locate a string from your "Greeting" topic.
3. Original (EN): "Hello! I am your assistant."
4. Translation (ES): "¡Hola! Soy su asistente."

[Link]
 5. Save the file and click Upload localization data in the Studio.

Phase 3: Testing the Detection

1. Open the Test Copilot pane.

2. Type "Hola".
3. Observe the agent's response. Because "Hola" is recognized as Spanish, the agent will
automatically trigger the Spanish version of the Greeting topic you just uploaded.

Technical Script (Python Conceptualization)

If you were handling this via an API or custom code, the logic follows a dictionary lookup:

Python
# Conceptual Localization Dictionary
translations = {
"es": {"greet": "¡Hola!", "help": "¿Cómo puedo ayudar?"},
"fr": {"greet": "Bonjour !", "help": "Comment puis-je vous aider ?"},
"en": {"greet": "Hello!", "help": "How can I help?"}
}

def get_localized_response(user_input):
# Detect language (simplified)
lang = detect_language(user_input) # e.g., returns 'es'

# Logic remains the same, only the 'string' changes

message = [Link](lang, translations['en'])['greet']
return message

print(get_localized_response("Hola")) # Output: ¡Hola!

5. Multiple-Choice Questions (MCQs)

Q1. When building a multilingual agent, why is it better to use Secondary Languages in one
bot rather than creating separate bots for each country? A) Separate bots cannot use Power
Automate. B) Secondary languages allow you to maintain a single set of logic and variables,
reducing administrative overhead. C) One bot is cheaper to host than multiple bots. D)
Secondary languages automatically translate your SharePoint documents into 100 languages.

Answer: B Explanation: The primary benefit of the multilingual feature in Copilot Studio is
"Logic Reuse." You build the complex flows (variables, conditions, actions) once, and only
translate the user-facing text.

Q2. Which file format is commonly used when exporting/importing localization data in
Copilot Studio? A) .EXE B) .MP4 C) .JSON or .ResX D) .PDF

[Link]
Answer: C Explanation: Localization data is structured as key-value pairs. JSON and ResX are
standard developer formats for storing strings that allow for easy editing by translation teams or
AI translation tools.

Q3. If a user starts a conversation in English but then switches to Italian, what is the best
way for the agent to adapt? A) The agent will crash and needs a restart. B) The agent relies on
Automatic Language Detection to identify the shift and switch to the Italian localization strings.
C) The agent will continue in English but use a "Translator" plugin for every word. D) The user
must manually select "Italian" from a settings menu.

Answer: B Explanation: Copilot Studio features built-in language detection. When the NLU
identifies a high-confidence language switch, it seamlessly begins using the localized values for
that language, provided they have been uploaded by the author.

Chapter: Prototyping: From "Sketch" to

"Agent Flow"
[Link]
1. Chapter Title & Objective
Chapter Name: Prototyping: From "Sketch" to "Agent Flow" Objective: In this chapter, you
will learn the transition from conceptualizing an agent to building a functional prototype. You
will master the "Copilot Studio Design Lifecycle," learn how to use the Description-to-Topic
feature for rapid drafting, and understand how to refine a rough "sketch" into a logical, high-
performance conversational flow that meets exam AB-620 standards.

2. Core Concepts & Theory

Prototyping is the bridge between a business requirement and a technical solution. In Copilot
Studio, prototyping is unique because it allows for "Conversation-First" development.

A. The Sketch-to-Flow Methodology

Before touching the canvas, a pro builder "sketches" the conversation. This involves identifying:

 The Happy Path: The shortest route from the user's question to a successful resolution.
 The Edge Cases: Where the user might provide invalid data or change the subject.
 The Integration Points: Where the agent needs to stop talking and start "doing" (calling
an API or Power Automate).

B. "Create from Description" (AI-Assisted Prototyping)

Microsoft Copilot Studio allows you to prototype using natural language. Instead of manually
dragging nodes, you describe the topic.

 How it works: You provide a prompt like, "Create a topic that asks for a user's loyalty
ID, checks the status in a database, and offers a discount if they are a Gold member."
 The Output: The Studio generates a functional "sketch" with trigger phrases, question
nodes, and condition branches automatically.

C. The Iterative Refinement Loop

A prototype is never perfect. The lifecycle follows these steps:

1. Draft: Use "Create from Description" to get the base logic.

2. Verify: Check the Variable Types (ensure the AI didn't use a 'String' where a 'Number'
is needed).
3. Stress Test: Use the Test Copilot pane to try phrases that the AI didn't include in the
initial trigger set.

[Link]
 4. Harden: Replace placeholder text with brand-aligned "Warm Storytelling" language.

3. Practical Case Study: "The 24-Hour Event Assistant"

Organization: Summit Tech Conferences The Challenge: The organizers realized 24 hours
before the event that they needed an agent to handle "Session Room Locations" for 200 different
speakers.

The Prototyping Strategy:

1. The Sketch: The team identified that the user needs to provide a "Speaker Name" to get
a "Room Number."
2. The AI Draft: They used the "Create from Description" tool with the prompt: "Build a
flow that asks for a speaker's name, searches a SharePoint list, and tells the user which
room the speaker is in."
3. The Refinement: The generated prototype worked but was too robotic. The trainer
refined the flow by adding a Generative Answers node as a backup in case the speaker's
name was misspelled.

The Result: A functional agent was prototyped and deployed to the event website in under 3
hours, handling 1,500 queries on day one with a 92% accuracy rate.

4. Step-by-Step Example: Rapid Prototyping with AI

This example demonstrates how to go from a text description to a working flow.

Phase 1: Using the Copilot Studio Copilot

1. Open your agent and go to Topics.

2. Click + New topic > Create from description.
3. In the "Name your topic" box, type: Order_Cancellation.
4. In the "Create a topic to..." box, type:

"Ask the user for their Order ID. If the order starts with 'RE', tell them it's a retail
order and cannot be canceled here. Otherwise, ask for a reason and send a
confirmation message."

5. Click Create.

[Link]
Phase 2: Refining the AI Sketch

1. Observe the Canvas: Notice that the AI created a Condition Node to check for the 'RE'
prefix.
2. Fix Variables: Check the OrderID variable. If the AI identified it as a 'Number', but your
IDs are 'RE-123', change the Identity to String.
3. Add Logic: Add a Message Node at the end to provide a "Ticket Number" for the
cancellation.

Technical Concept (Logic Mapping)

In the background, the prototyping engine maps your description to a JSON-based flow
structure:

JSON
{
"Trigger": ["cancel my order", "stop shipment"],
"Nodes": [
{ "Type": "Question", "Variable": "OrderID", "Entity": "String" },
{ "Type": "Condition", "Expression": "StartsWith([Link], 'RE')",
"Branch": "Retail_Flow" },
{ "Type": "Message", "Text": "Your cancellation is being processed." }
]
}

5. Multiple-Choice Questions (MCQs)

Q1. When using the "Create from Description" feature, what is the best way to ensure the
generated prototype includes the correct logic branches? A) Use a single-word prompt like
"Refunds." B) Provide a detailed prompt that includes the "If/Then" logic and specific data
points needed. C) Upload a 50-page PDF manual to the prompt box. D) Draw the flow on paper
and hold it up to the webcam.

Answer: B Explanation: The "Create from Description" tool is a Generative AI feature. The
more specific you are about the conversational requirements (e.g., "If the user is a guest, redirect
to login"), the more accurate the initial "sketch" will be.

Q2. You have used AI to prototype a topic. During testing, you notice the agent incorrectly
accepts "Twelve" as a response to a question intended only for numeric digits. What
should you refine in the prototype? A) The Trigger Phrases. B) The Entity type assigned to the
variable in the Question Node. C) The Fallback Topic. D) The Bot's display name.

[Link]
Answer: B Explanation: If the agent is accepting the wrong format of data, the issue lies with
the Entity (the filter). Changing the entity from "String" or "Text" to "Number" will force the
agent to validate that the input is a digit.

Q3. What is the primary benefit of the "Sketch-to-Flow" prototyping approach for a
Project Manager? A) It allows them to write the final code in Python immediately. B) It allows
for rapid stakeholder feedback on the "Happy Path" before complex backend integrations are
built. C) It automatically publishes the bot to the Apple App Store. D) It eliminates the need for
any testing or analytics.

Answer: B Explanation: Prototyping is about validation. By "sketching" the flow first,

stakeholders can see the user experience and approve the logic before developers spend time on
deep technical integrations like Power Automate or SQL connections.

[Link]