A Quick Note Before We Begin
I have been working with Microsoft Copilot Studio for a while now, and one question that kept coming up — even from developers who are not new to the platform — is this: what exactly is the difference between System Topics and Custom Topics?
On the surface it seems like a simple question. But honestly, the first time I opened the Topics section in Copilot Studio, I stared at those two tabs for a good few minutes before things actually clicked. So I thought, let me write down exactly how I think about it — in plain language, with real examples from an actual agent — so others do not have to go through the same confusion.
Let us get into it.
First Things First — What is a Topic?
When you build an agent in Microsoft Copilot Studio, the entire conversation is driven by Topics. A topic is essentially a unit of conversation — it defines what the agent should do when a specific situation arises.
Think of it like this: if someone walks into a help desk, there are two kinds of situations the staff handles:
Things that happen regardless of what the customer says — like greeting every visitor when the door opens, or calling a manager when there is a serious complaint
Things that happen because the customer asked for something specific — like "I need to reset my password" or "What are your working hours?"
That is exactly how topics work in Copilot Studio. The first type maps to System Topics, and the second maps to Custom Topics.
System Topics — The Agent's Built-in Backbone
System topics are created and maintained by Microsoft. When you create a new agent, these topics are already there — you do not add them, and more importantly, you cannot delete them.
In my own agent (which I named Copilot 3 while testing), I can see exactly 8 system topics under the System tab:
Conversation Start — fires when the conversation begins
End of Conversation — fires when the chat wraps up
Escalate — fires when the user asks to speak to a human
Fallback — fires when no custom topic matches the user's input
Multiple Topics Matched — fires when the agent finds more than one possible topic match
On Error — fires when something goes wrong internally
Reset Conversation — fires when the conversation needs to restart
Sign In — fires when authentication is required
The key insight here is in how these topics are triggered. If you look at the trigger column in the Topics section, system topics show triggers like On Conversation, On Error, Redirect — these are events, not phrases. The agent is not waiting for the user to say something specific. It is reacting to something that happened.
That is the mental model I keep coming back to: System Topics = Events.
Something occurred in the system or in the conversation lifecycle — and the system topic responds to that occurrence automatically.
Can You Modify System Topics?
Yes, partially. You can open any system topic and change the message text, adjust the conversation flow, or tweak how the agent responds. For example, I changed the Conversation Start message to match a specific brand tone for a client project — something friendlier and more specific than the default.
But the structure of when it fires? That you cannot change. And again — you cannot delete it. The Microsoft documentation puts it clearly: without system topics, your agent may not behave as intended.
Custom Topics — Where You Build the Real Experience
Now here is where the actual business logic lives.
Custom topics are topics you create. Every single custom topic in your agent was either built by you from scratch, created using Copilot's AI authoring feature (where you describe what you want and it generates the topic for you), or came as a pre-built sample when the agent was first created.
When I look at my Copilot 3 agent, I have 7 custom topics:
Goodbye
Greeting
Lesson 1 — A simple topic
Lesson 2 — A simple topic with a condition
Lesson 3 — A topic with a condition, variables, and entities
Start Over
Thank You
Notice something here — Greeting and Goodbye are custom topics, not system topics. This confused me at first. But it makes sense once you think about it: these topics fire because the user said something — "hello", "hi", "bye", "see you". That is a phrase trigger, not an event trigger.
The Lesson topics (1, 2, 3) are sample topics Microsoft includes to help you learn how authoring works — from simple messages all the way to conditions, variables, and entities. These are completely deletable; they are just there as a starting point.
How Custom Topics Are Triggered
In the Topics list, every custom topic shows "Phrases" as the trigger type. This is the fundamental difference from system topics.
You define a set of trigger phrases — the things a user is likely to say. For example, hovering over Lesson 1 in my agent shows the configured phrases:
"When are you closed"
"When are you open"
"Store hours"
"Daily open hours"
When a user types something close to any of these — even if it is not word-for-word — the agent's natural language understanding engine matches it to the right topic and fires it. The match does not have to be exact. If someone types "what time do you guys open", it will still match the store hours topic.
What You Can Do With Custom Topics
Unlike system topics, custom topics give you complete control:
Add as many as your use case needs
Edit the trigger phrases, conversation nodes, branching logic, and messages anytime
Disable them temporarily without deleting
Delete them entirely when no longer needed
Redirect to other topics — including system topics like Escalate — when the logic requires it
Call Power Automate flows from within the topic to connect to backend systems
Collect user input into variables and use those values across the conversation
The Memory Trick I Use
After going back and forth on this for a while, the simplest way I explain this to anyone on my team is:
System Topics = EVENTS (something happened in the agent lifecycle) Custom Topics = PHRASES (the user said something specific)
If the trigger is an event — error, conversation start, sign-in, escalation — it is a system topic. If the trigger is a phrase — something the user typed or spoke — it is a custom topic.
That one distinction clears up almost every question that comes from it.
Why This Actually Matters in Real Projects
Understanding this difference is not just academic — it has practical implications when you are building production agents.
Scenario 1 — Customising the greeting experience: A client wanted the agent to greet users differently based on the time of day. My first instinct was to modify the Conversation Start system topic. But after thinking it through, I actually built a condition inside the Conversation Start topic itself — because that is the right place for it. The Conversation Start is a system event that always fires when a conversation begins, which is exactly when I need to check the time and branch accordingly.
Scenario 2 — Handling unanswered questions: When the agent could not answer something, it was just showing a generic fallback message. I went into the Fallback system topic and customised it to first attempt a generative AI answer from our knowledge sources before showing the "I don't know" message. That is a system topic doing exactly what it is supposed to do — but with a customised response path.
Scenario 3 — Building the actual HR use case: Everything business-specific — "request leave", "check payslip", "raise an IT ticket" — those are all custom topics. I built each one with specific trigger phrases, question nodes to collect information, variables to store responses, and Power Automate calls to push data to backend systems.
The system topics handled the infrastructure. The custom topics handled the product.
One Common Confusion — Cleared Up
A lot of people ask me: are Default Topics the same as System Topics?
The short answer is — people often use these terms interchangeably, but technically they refer to slightly different things.
System Topics is the official Microsoft term for the 8 protected, undeletable topics that handle agent lifecycle events.
Default Topics sometimes refers to the pre-built sample custom topics (like Greeting, Goodbye, Lesson 1, 2, 3) that come with a new agent out of the box. These are custom topics by nature — they just happen to come pre-loaded. You can delete them if you want.
So: all system topics are defaults in the sense that they come pre-built — but not all default topics are system topics.
Quick Reference
| System Topics | Custom Topics |
|---|
| Created by | Microsoft | You (or AI authoring) |
| Trigger type | Events (On Error, On Conversation, Redirect) | Phrases (what the user types) |
| Can be deleted? | No | Yes |
| Can be modified? | Partially (content, not trigger logic) | Fully |
| Count in new agent | 8 | Varies (samples included) |
| Examples | Conversation Start, Fallback, Escalate, On Error | Greeting, Goodbye, Reset Password, Check Order |
| Purpose | Agent lifecycle and infrastructure | Business logic and user tasks |
Wrapping Up
Topics are the foundation of every agent you build in Microsoft Copilot Studio. Understanding the distinction between system topics and custom topics early on will save you a lot of debugging time and help you design better, more intentional conversation flows.
The way I see it: system topics keep the lights on. Custom topics are where you actually build the product.
If you are just starting out with Copilot Studio, I would suggest opening the Topics section in your agent and spending 15 minutes just clicking through each system topic to see what is inside. Then do the same with the Lesson topics in the custom section. You will pick up the authoring patterns quickly, and once those click, building real business agents becomes much more straightforward.
I will be covering more of these foundational concepts in upcoming articles — including how variables and entities work, how to call Power Automate from a topic, and how generative orchestration changes the way topics behave in 2025 agents.
Stay tuned, and feel free to drop your questions in the comments below.
Join the conversation! Your thoughts help the community grow.