What Copilot Studio is for
Microsoft Copilot Studio is a low-code environment for building custom conversational agents that answer questions, complete tasks, and connect to your organisation's systems. You build an agent by defining the conversations it can hold, the knowledge it can draw on, and the actions it can take — then publish it to a channel such as Microsoft Teams or a website.
It is the entry point to the Deploy pillar's agent-building track. Before you optimise, automate, or extend, you need a working mental model of how an agent is composed. This unit gives you that model and walks you through building a first agent end to end.
By the end of this unit- Describe the core building blocks of a Copilot Studio agent and how they fit together.
- Author a topic with trigger phrases and capture user input using entities.
- Add a knowledge source, attach an action, and publish the agent to a channel.
The anatomy of an agent
- Topics are the conversational paths an agent can follow
- Each topic is started by trigger phrases — examples of what a user might say
- Within a topic you ask questions, branch on conditions, and send messages
- Topics are the deterministic, designed part of the conversation
- Knowledge sources let the agent answer from your content using generative answers
- Sources include public websites, SharePoint, Dataverse, and uploaded files
- Knowledge handles the open-ended questions topics do not explicitly cover
- You control which sources the agent is permitted to use
- Actions let the agent do something — call a flow, query an API, run a connector
- Actions turn a conversation into work completed in a connected system
- Inputs and outputs are passed between the conversation and the action
- Actions are where conversation becomes capability
Topics, triggers, and entities
A topic is the unit of designed conversation. You author it in the topic editor as a sequence of nodes: trigger phrases that start it, questions that gather input, conditions that branch, and messages that respond. Building a reliable first agent begins with authoring a clear topic.
1. Write trigger phrases that reflect real user language
Trigger phrases are the example utterances that start the topic. Provide five to ten varied phrasings — "I need to book annual leave", "how do I request time off", "holiday request". Copilot Studio uses these to recognise intent, so cover the genuine ways people ask, not just the formal phrasing.
2. Capture input with entities
Entities classify and extract information from what the user types. Use prebuilt entities (date, number, email, city) where they fit, and create custom entities — a closed list of values, or a regular-expression pattern — for organisation-specific data such as a project code. A "Question" node that expects an entity will pull the value straight out of the user's reply.
3. Branch on conditions, then respond
Use condition nodes to route the conversation based on captured variables. Keep branches shallow and named clearly. End each path with a message node that confirms what will happen or hands off to an action. A topic that gathers input but never confirms leaves the user uncertain whether anything occurred.
Test trigger recognition early using the test pane. If two topics share overlapping trigger phrases, the agent may route unpredictably. Keep each topic's triggers distinct, and use the "Topic overlap" checker to catch collisions before publishing.
A user types "what's left on my holiday allowance" but the leave-request topic does not trigger. What is the most likely cause?
Knowledge sources and actions
Topics handle the conversations you anticipate. Knowledge sources and actions handle the rest — answering open questions and completing work. A capable first agent usually combines a handful of designed topics with at least one knowledge source and one action.
Adding knowledge
When you add a knowledge source, Copilot Studio can generate answers from that content rather than requiring you to author a topic for every possible question. You can connect public websites, SharePoint sites and documents, Dataverse tables, or upload files directly. You control which sources are in scope, and the agent cites where an answer came from.
Choose sources you trust and keep current
Scope SharePoint access deliberately
Let knowledge and topics work together
Attaching actions
An action lets the agent do something beyond conversation. You can call a Power Automate flow, invoke a connector, or call a REST API. The agent passes inputs (often captured via entities) into the action and uses the returned outputs in its reply. This is how a leave-request conversation actually creates a record, rather than just describing how to.
Picture one agent your team could use this quarter. Which questions are designed paths (topics), which are open-ended (knowledge), and what single action would turn it from informative into genuinely useful? Naming that one action is often the difference between a demo and a deployment.
Adaptive cards and publishing
Once the agent can converse, find, and act, you make the interaction clearer with adaptive cards and then publish it to where people work.
Adaptive cards
Adaptive cards render structured, interactive content inside the conversation — a form to collect several fields at once, a confirmation summary, or a set of choice buttons. Use them when a plain message would be cluttered: collecting a date, a category, and a note in one card is clearer than three sequential questions. Cards keep the exchange tidy and reduce back-and-forth.
1. Test in the authoring canvas
Use the built-in test pane throughout authoring. Confirm topics trigger correctly, entities capture cleanly, knowledge answers are accurate and cited, and actions return what you expect. Fix routing and recognition issues here, before any user sees the agent.
2. Publish the agent
Publishing makes the current version of the agent live to its connected channels. Until you publish, changes stay in the authoring environment. Publish deliberately when a coherent set of changes is ready, not after every edit.
3. Connect a channel — Teams or web
Add the agent to Microsoft Teams so colleagues can chat with it where they already work, or embed it on a website or via the demo website link for external or anonymous use. Each channel has its own settings — Teams respects organisational identity; a public web channel may allow anonymous access, which changes your security and knowledge-scoping decisions.
Build on these fundamentals with the official learning paths:
Create copilots with Microsoft Copilot Studio ↗
Add knowledge to Microsoft Copilot Studio agents ↗
Create and manage copilots with Copilot Studio (Applied Skill) ↗
End of Unit 6
You should now be able to:
- Explain how topics, knowledge, and actions combine to form an agent.
- Author a topic with trigger phrases and entity-based input capture.
- Add a knowledge source, attach an action, use adaptive cards, and publish to Teams or web.
Unit review
What is the role of trigger phrases in a topic?
When should you prefer a knowledge source over authoring a topic?
Why scope a SharePoint knowledge source to specific sites rather than the tenant root?
What does publishing an agent do?
End of module
You have completed Course 06: Copilot Studio Fundamentals. Next: Building Custom Copilots — generative answers, authentication, Power Automate integration, and enterprise deployment with ALM.