If you build a chatbot without teaching it to recognise specific pieces of information like dates, names, or product codes, your chatbot will fail to understand what people actually want. It will give generic, useless answers or, worse, do nothing at all. That's why the PL-900 exam expects you to understand 'entities' and 'actions' in Copilot Studio — they are the two core ingredients that turn a simple question-and-answer bot into a truly useful digital assistant that can complete tasks.
Jump to a section
A simple way to picture Working with Entities and Actions in Copilot Studio
A head chef runs a busy restaurant kitchen. The chef is the master of the kitchen, but they can't do everything alone. They rely on their team: the sous-chef, the line cooks, and the pastry chef. Each team member has a specific role and specific ingredients they work with. For example, the pastry chef only uses flour, sugar, butter, and eggs. The line cook only uses meat, vegetables, and spices. When a waiter brings an order ticket to the kitchen, the chef reads the ticket and decides who does what. The ticket is a 'request' from a customer. The chef's job is to 'understand' that request using the ingredients they have on hand. They look at the ticket and see 'Steak, medium-rare, with mashed potatoes and a side salad.' The chef doesn't need to be told every tiny detail about what 'steak' is. The chef already knows that 'steak' is a type of meat. That's because 'meat' is a category. The chef has a mental list of what 'meat' includes. In this kitchen, 'meat' is an 'entity' — it's a type of thing the kitchen knows about. The chef also knows what 'medium-rare' means. That's a 'temperature' entity. So the chef interprets the ticket by pulling out the important pieces: the main dish (entity: meat), the doneness (entity: temperature), and the sides (entity: vegetables). Once the chef has identified these pieces, they give an 'action' command to the team: 'Sous-chef, cook the steak to medium-rare. Line cook, prepare the mash and salad.' The chef doesn't cook; the chef directs. The chef is the 'Copilot Studio', the ticket is the 'user's message', the ingredients are the 'entities', and the commands are the 'actions'. The chef's brilliance lies in mapping the right ingredients to the right actions so the meal comes out perfect. If the chef didn't understand entities (like confusing 'side salad' with 'main salad'), the kitchen would be chaos. Same with Copilot Studio: if it doesn't understand entities, it can't execute the right actions.
Let's start with the most basic idea: what is a 'Copilot'? In the context of Microsoft's Power Platform, a Copilot is an AI-powered chat interface. You see it in Microsoft Teams, on a website, or in a custom app. A user types a question, and the Copilot gives an answer or performs an action. Copilot Studio is the tool you use to build that Copilot — to tell it what to listen for and how to respond.
Now, the head chef in our analogy is Copilot Studio. But a chef needs ingredients to cook, and a Copilot needs 'entities' to understand what the user is talking about. An entity is a piece of information that the Copilot can recognise inside a user's sentence. Think of entities as the 'nouns' or 'variables' in a sentence. For example, if the user says 'Book a flight to London tomorrow', the Copilot needs to know that 'London' is a city and 'tomorrow' is a date. 'City' and 'Date' are types of entities. In Copilot Studio, there are pre-built entities (like 'PersonName', 'Date', 'Number', 'Email', 'Phone') that come ready to use. You can also create 'custom entities' for your specific business, like a list of product names or store locations. An entity has a 'name' and a 'value'. The name is the category (e.g., 'City'), and the value is the specific instance (e.g., 'London'). Without entities, the Copilot only sees a string of words. With entities, it extracts meaning.
Now, what about 'actions'? An action is what the Copilot does after it understands the user's request. An action can be a simple reply (like 'Hello, how can I help?') or a complex task like creating a support ticket, sending an email, or booking a meeting. Actions are the 'verbs' in the system. In Copilot Studio, actions are often connected to Power Automate flows, which are automated workflows. For instance, if the user says 'Show me my sales report', the Copilot might use a Power Automate action to fetch data from a database and display it. Actions can also trigger other actions — a chain of events.
The magic happens when entities and actions work together. Here’s how it works step by step:
The user types a message in the chat.
Copilot Studio processes that message using a mix of AI and pre-defined rules.
It scans the message for entities it recognises. For example, it spots the entity 'Date' with the value 'next Monday'.
It also spots the entity 'ProductName' with the value 'Widget A'.
Once it has the entities, it looks at the 'intent' — what the user wants to do. Intent is like the user's goal, such as 'checking stock' or 'placing an order'.
The Copilot then matches that intent to an action. The action is 'Look up inventory for the product on that date'.
The action runs, and the Copilot replies with the result.
So entities feed into actions. Without entities, the Copilot doesn't know what 'it' refers to — the action is incomplete. If the user says 'Order more', but the Copilot doesn't know what product or quantity, the action 'Order more' has nothing to act on.
Why does this exist? Before Copilot Studio, building a chatbot required writing a lot of custom code to parse sentences and map them to database queries. Copilot Studio simplifies this by providing a graphical interface where you define entities and actions without coding. It democratises chatbot creation — business analysts can build them, not just developers.
What does it replace? It replaces the need for a programmer to write regular expressions (a pattern-matching code) and database queries for every possible user request. Instead, you train the Copilot by giving it examples of sentences that contain the entities you care about. It learns from those examples.
There are three types of entities in Copilot Studio:
Pre-built entities: These are ready-made and cover common categories like Date, Time, Number, Currency, Email, and Phone. You don't need to teach the Copilot what a date looks like — it already knows.
Custom entities: You create these for your unique business. For example, you might create an entity called 'Gadget' that lists all the gadgets your company sells. When a user types 'gizmo', the Copilot can match it to the 'Gadget' entity if you added 'gizmo' to the list.
Closed list entities: These are a type of custom entity where you define a fixed set of possible values (e.g., a dropdown of 'Critical', 'High', 'Medium', 'Low' for priority). The Copilot will only recognise these exact values.
Open list entities: These are custom entities that can accept synonyms or new values on the fly. For example, if you create an open entity for 'City', the user could type 'Londres' and, if you've added that as a synonym for 'London', it will still recognise it.
Actions come in two main flavours:
Topic actions: These are built directly into a topic (a conversation thread). For example, a topic called 'Check Order Status' might have an action that calls a Power Automate flow.
Global actions: These are reusable actions that can be invoked from any topic. For example, a 'Send Email' action might be available to all topics.
To tie it all together, when you build a Copilot in Copilot Studio, you design 'topics'. A topic is a conversation flow. It starts with a user's question, and you define phrases that trigger that topic. Inside the topic, you set up the entities you want to capture and the actions you want to execute. For example, the topic 'Book a Meeting' might trigger on phrases like 'Schedule a meeting' or 'Arrange a catch-up'. It captures the entity 'Date' and 'AttendeeName'. The action then creates a calendar event using Microsoft 365.
This system is powerful because it handles the messy reality of human language. People don't phrase things the same way. One person says 'Set a meeting for Friday at 3pm with Alice', another says 'Schedule a call with Bob next Tuesday'. The Copilot uses entities to pull out the date, time, and name, regardless of the exact wording. The action remains the same: create the calendar event. Entities provide flexibility; actions provide consistency.
In summary, entities are your Copilot's vocabulary — what it knows about. Actions are its skills — what it can do. You build a useful Copilot by defining the right entities and connecting them to the right actions.
Identify the User's Intent
The Copilot first analyses the user's message to determine their goal, such as 'reset password' or 'order a laptop'. This is done using trigger phrases you defined in the topic. The intent tells the Copilot which topic to activate.
Capture Entities from the Message
Once the topic is activated, the Copilot scans the user's words for entities you have set up. For example, if the topic expects a 'Date' and a 'ProductName', the Copilot tries to extract those values from the sentence. If it finds them, it stores them for later use.
Ask for Missing Required Entities
If the user did not provide a required entity (e.g., they said 'Reset my password' but didn't specify urgency), the Copilot will prompt the user with a question like 'Is this urgent? Low, Medium, High, or Critical?'. This ensures the action has all the data it needs.
Execute the Action
With the entities captured, the Copilot runs the action associated with the topic. This could be a simple reply, a Power Automate flow, or a call to an external system. The action uses the entity values as inputs. For example, the 'Reset Password' action uses the user's name (entity) to find their account.
Return the Result to the User
After the action completes, the Copilot sends a response to the user confirming what happened. If the action failed (e.g., the user's name was not found), the Copilot should have an error handling topic that offers alternatives or asks for clarification.
Log and Learn (Optional)
Advanced Copilots can log the conversation and the entities captured for analytics. This helps the creator see if users are phrasing things in unexpected ways, allowing them to improve trigger phrases or add synonyms to entities.
Consider a real IT professional named Priya. She works at a mid-sized healthcare company called 'MediCare Solutions'. The company has a helpdesk that supports 5,000 employees. Employees constantly email the helpdesk asking for IT support, but the team is small and overwhelmed. Priya is tasked with building a Copilot in Microsoft Teams that can handle common requests automatically, freeing up the helpdesk staff.
Priya opens Copilot Studio. First, she creates a new Copilot and names it 'MediBot'. She needs it to understand requests like 'Reset my password', 'I need a new laptop', or 'What is the Wi-Fi password?'. So she starts defining entities. She creates a custom entity called 'ITService' with a closed list of values: 'Password Reset', 'Laptop Request', 'Software Install', 'Wi-Fi Info'. She also creates another custom entity called 'Urgency' with values 'Low', 'Medium', 'High', 'Critical'. Then she uses the pre-built entity 'EmployeeName' (which uses Microsoft Entra ID to recognise user names).
Now Priya builds topics. She creates a 'Password Reset' topic. She adds trigger phrases like 'I forgot my password', 'reset my password', 'lock me out'. Inside the topic, she sets up the following:
Entity capture: She tells the Copilot to capture the 'EmployeeName' entity (from the current Teams user context) and the 'Urgency' entity (asking the user if they have a deadline).
Action: She uses a pre-built action called 'Reset Password' that connects to the company's directory via Microsoft Entra ID. This action automatically resets the password and sends a temporary password to the user's mobile via SMS.
Confirmation: The Copilot then says 'Your password has been reset. A temporary code has been sent to your phone.'
Priya also builds a 'Laptop Request' topic. The trigger phrases are 'I need a new laptop', 'request a device', 'new computer'. She captures the entity 'EmployeeName' and a custom entity 'LaptopModel' which she creates with a closed list of approved laptops (e.g., 'Dell Latitude 5430', 'HP EliteBook 840', 'MacBook Pro 14'). For the action, she uses a Power Automate flow that creates an approval request in the IT manager's queue. The flow also checks inventory via an API to see if the laptop is in stock. If it is, it auto-approves and sends a notification to the warehouse.
Now here is the step-by-step flow when an employee named James uses the Copilot: 1. James opens Microsoft Teams and types 'MediBot, I need a new laptop - the Dell model'. 2. Copilot Studio processes the message. It recognises the trigger phrase 'I need a new laptop' and activates the 'Laptop Request' topic. 3. It identifies the entity 'LaptopModel' and extracts 'Dell Latitude 5430' from the list. 4. It also identifies the user's identity from the Teams profile (no need to ask for the name). 5. The action fires: the Power Automate flow runs. It checks inventory. The Dell is in stock. 6. The flow sends an auto-approval email to the warehouse and logs the request in the helpdesk system. 7. The Copilot replies: 'Great, James! Your Dell Latitude 5430 is in stock and has been ordered. You will receive it in 3 business days.'
Without entities, the Copilot would have no way to know which laptop model James wanted. Without actions, it would just say 'Okay, I understand you want a laptop' and do nothing. The combination is everything.
Priya also sets up error handling. If a user mentions a laptop model that isn't in the entity list (e.g., 'I want a Chromebook'), the Copilot asks the user to choose from the approved list. This is a 'disambiguation' technique. She also tests the Copilot by entering sample phrases and verifying that the right entities are captured.
In this real scenario, Priya has transformed a manual, slow process into an instant, automated one. The helpdesk team now only handles the 20% of requests that need human judgement. The Copilot handles the repetitive 80%. This is exactly why Microsoft markets Copilot Studio as a tool for 'empowering every employee' — it lets non-developers build these systems. The IT professional's job shifts from coding the logic to designing the entities and actions that make the logic work.
The PL-900 exam tests your understanding of entities and actions in Copilot Studio in a very specific way. This is not a hands-on coding exam. You will not be asked to write a JSON payload or configure a Power Automate flow in detail. Instead, you need to know the concepts, the terminology, and the relationships between the components.
Here are the exam topics that appear most frequently:
Recognising pre-built vs custom entities: The exam loves to ask which entity type you would use for a given scenario. They often present a scenario like 'a company needs to recognise its own product names in a chatbot'. The correct answer is 'custom entity' (specifically a closed list or open list). Trap: They might offer 'pre-built entity' as an answer, but pre-built entities are for standard things like dates and numbers.
Understanding entity synonyms: They test whether you know that you can add synonyms to custom entities. The trap is a question that says 'you want a user to be able to say 'cell' or 'mobile' and have it recognised as the same entity.' The correct action is to add 'cell' and 'mobile' as synonyms for that entity.
Knowing the purpose of actions: They ask what actions are used for. The correct pattern is 'Actions perform tasks like sending an email, creating a record, or calling a Power Automate flow.' They might contrast actions with 'topics' which are the conversation containers.
Identifying the sequence: A common question is 'What happens first when a user sends a message to a Copilot?' Answer: 'The Copilot identifies the intent and extracts entities.' Not the other way around.
Understanding topic triggers vs entity capture: They might describe a scenario where a user types something and the Copilot asks for more information. The question: 'Why does it ask for more details?' Answer: 'Because a required entity was not captured.' The trap is thinking it's because the topic didn't match.
Distinguishing between closed list and open list entities: Closed list entities only recognise exact matches (or synonyms you've added), while open list entities can recognise new values based on examples. The exam may ask you to recommend which one to use for a list of fixed office locations (closed list) vs a list of customer names that changes daily (open list).
Traps to be aware of:
Trap: They might ask 'Which entity type should you use to capture a user's age?' The obvious answer is 'Number', but they might want you to think about 'Age' as a custom entity. No — use the pre-built 'Number' entity because age is a number.
Trap: They might present a scenario where a Copilot is not working and ask 'What is the most likely cause?' If the Copilot fails to recognise a product name, the answer is likely 'The product name is not in the custom entity list', not 'The action is misconfigured'.
Trap: They mix up 'intent' and 'action'. Intent is the user's goal (e.g., 'check order status'), action is the thing the Copilot does (e.g., 'call order status API'). Be clear on that.
Key definitions to memorise:
Entity: A piece of information that the Copilot recognises in a user's message, such as a date, a product name, or a number.
Action: An operation the Copilot performs in response to a user request, often connected to a Power Automate flow.
Topic: A conversational flow that includes trigger phrases, entity capture, and actions.
Trigger phrases: Example sentences or phrases that tell the Copilot which topic to use.
Synonyms: Alternative words for the same entity value (e.g., 'cell' and 'mobile' for 'phone').
Closed list entity: Has a fixed set of values.
Open list entity: Can learn new values from user input or examples.
The exam also tests the concept of 'disambiguation'. If a user's message could match multiple topics, the Copilot might ask a clarifying question. For example, if you say 'I need help' and that matches both 'Password Reset' and 'Laptop Request', the Copilot might ask 'What kind of help?'. That's disambiguation.
Finally, be aware that the exam expects you to know that Copilot Studio is part of the Microsoft Power Platform, which includes Power Apps, Power Automate, Power BI, and Power Virtual Agents (now rebranded under Copilot Studio). So questions might reference the broader ecosystem. For example, 'Which Power Platform component would you use to create the workflow that an action triggers?' Answer: 'Power Automate.'
To prepare, practise with the 'Test your Copilot' feature in Copilot Studio (if you have access) to see how entities and actions work together. If you don't have access, focus on memorising the definitions and practising with Microsoft's official 'Learn' modules for PL-900. The exam does not require deep hands-on experience, but conceptual clarity is essential.
Entities are the specific pieces of information (like a date, name, or product ID) that a Copilot extracts from a user's message to understand the request.
Actions are the tasks the Copilot performs after understanding the request, such as sending an email, updating a database, or calling a Power Automate flow.
Pre-built entities cover common concepts like dates, numbers, and email addresses, and they cannot be modified or extended with custom values.
Custom entities let you define your own categories, such as product lists or office locations, and can be either closed list (fixed values) or open list (can learn new values).
A topic in Copilot Studio is a full conversation flow that combines trigger phrases, entity capture, and actions to handle a specific user goal.
Entities and actions work together: entities provide the 'what' (the details), and actions provide the 'how' (the execution).
Understanding the difference between a pre-built entity and a custom entity is a common PL-900 exam question.
Actions can trigger Power Automate flows, which allow the Copilot to automate complex business processes like approvals and data updates.
You cannot edit a pre-built entity to add your own company-specific values — you must create a new custom entity for that.
If a required entity is not captured from the user's message, the Copilot will ask a clarifying question rather than failing silently.
These come up on the exam all the time. Here's how to tell them apart.
Pre-built Entity
Comes ready-to-use in Copilot Studio
Covers common categories like Date, Number, Email
Cannot be edited or extended with new values
Custom Entity
Created by the user for specific business needs
Can be a closed list or open list
Supports synonyms and can be updated over time
Closed List Entity
Has a fixed set of allowed values
Only recognises exact matches or synonyms
Good for categories that rarely change, like 'Department'
Open List Entity
Can learn new values from user input
Requires training with example phrases
Good for things that change frequently, like 'Product Name'
Trigger Phrase
A phrase that activates a topic
Matches the user's intent, not specific details
Example: 'I want to book a flight'
Entity
A piece of information extracted from the message
Provides specific details like date or destination
Example: 'Paris' and 'next Friday'
Topic
A container for a conversation flow
Includes trigger phrases, entity capture, and one or more actions
Defines the overall user experience for one goal
Action
A specific task performed by the Copilot
Can be a simple reply, a Power Automate flow, or an API call
Executed after entities are captured
Synonym
An alternative word for an existing entity value
Does not create a new value in the list
Example: 'cell' is a synonym for the value 'phone'
Entity Value
A specific instance of an entity type
Can be singular or a list
Example: 'phone' is a value in the 'ContactMethod' entity
Mistake
Entities are the same as 'variables' in programming, and they store the answer the Copilot gives.
Correct
Entities are pieces of information extracted from the user's message, not the answer. The Copilot uses them to decide what to do, but the answer is generated separately by a topic or action.
Beginners confuse input (entities) with output (the reply). The Copilot extracts entities from the user's question, then uses them to produce a reply through an action or topic flow.
Mistake
If I add a word to a closed list entity as a synonym, the user can type that word and the Copilot will automatically learn that value as a new permanent member of the entity list.
Correct
A synonym is just an alternative way to reference an existing value. The Copilot recognises the synonym, but maps it back to the existing value — it does not create a new value in the list.
The word 'synonym' sounds like it adds new things, but in this context, it redirects to an already existing value rather than expanding the list.
Mistake
Actions and topics are the same thing. A topic is just a fancy name for an action.
Correct
A topic is a container for a conversation flow, which includes trigger phrases, entity capture, and actions. An action is a specific task (like calling an API) that happens inside a topic or globally.
Microsoft's documentation often shows topics and actions in the same menu, so beginners assume they are interchangeable. They serve different structural roles.
Mistake
Pre-built entities can be edited to include my company's custom values, like adding my product names to the 'PersonName' entity.
Correct
Pre-built entities are fixed and cannot be edited. You can only use or not use them. To add custom values, you must create a custom entity.
Beginners see 'pre-built' and assume they are templates that can be customised. In fact, they are non-editable basic building blocks.
Mistake
A Copilot can only have one action per topic, because an action is the main thing the topic does.
Correct
A single topic can contain multiple actions, arranged in a sequence. For example, a topic might first capture an entity, then run an action to check stock, then run another action to send an email.
The linear nature of the topic design in Copilot Studio can mislead people into thinking there is a one-to-one mapping, but you can add multiple steps.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
An entity is a type of thing that the Copilot recognises from the user's message, like a date or a product name. A variable is a container that stores the value of that entity so it can be used later. In Copilot Studio, when you capture an entity, it automatically creates a variable for it.
Yes. Once you define an entity (pre-built or custom), it is available globally across all topics in your Copilot. For example, the pre-built 'Date' entity works in any topic without you having to recreate it.
Make sure you added 'gizmo' as a value or a synonym in the correct custom entity. Also check that the entity is attached to the correct topic. If the entity is of type 'closed list', 'gizmo' must be listed as a value or synonym. If it is an 'open list', you may need to provide example phrases that include 'gizmo' for training.
No. Copilot Studio provides a graphical user interface with no-code tools. You define entities by typing values into a list, and you create actions by selecting from pre-configured connectors or creating simple Power Automate flows visually.
The Copilot has a default 'Fallback' topic that handles unrecognised requests. It typically asks the user to rephrase or provides a menu of options. You can customise this fallback topic to be more helpful, such as offering to connect the user to a human agent.
Yes. Actions can trigger Power Automate flows that connect to data sources like Microsoft Dataverse, SQL Server, or SharePoint. For example, an action could create a new row in a Dataverse table representing a support ticket, using entity values as the data for that row.
You've finished Working with Entities and Actions in Copilot Studio. Continue through the PL-900 study guide to build a complete picture of the exam.
Done with this chapter?