Microsoft Copilot Studio Topics vs Plugins: When to Use Each

Microsoft Copilot Studio lets you extend your Copilot with custom logic. Two core building blocks exist: Topics and Plugins. Many builders confuse their roles and pick the wrong one for a task. Topics handle conversational flows with branching logic. Plugins connect external systems or perform single actions. This article explains the difference between Topics and Plugins and gives clear rules for when to use each.

What Are Topics and Plugins in Copilot Studio?

Copilot Studio provides two distinct mechanisms for building custom Copilot behaviors. Topics and Plugins serve different purposes and have different design constraints. Understanding each one is essential before deciding which to build.

Topics: Conversational Flows

Topics are the primary way to define a conversation path. A Topic contains trigger phrases, conditions, and output messages. When a user types a phrase that matches a Topic trigger, Copilot enters that Topic. The Topic can ask follow-up questions, branch based on user responses, and present adaptive cards or forms. Topics support variables, loops, and logic nodes. They are ideal for scenarios where the user needs to provide multiple pieces of information or where the flow changes based on context.

Plugins: Action Connectors

Plugins are single-purpose connectors that perform an action or retrieve data from an external source. A Plugin can call a REST API, run a Power Automate flow, query a database, or execute a connector. Plugins do not handle conversation state or branching. They receive input, perform an action, and return a result to the Copilot. Plugins are stateless. They do not remember previous turns. They are the right tool when you need to integrate with a third-party service or execute a discrete task.

When to Use a Topic vs a Plugin

The decision depends on the user experience you want to create. Use a Topic when the interaction requires more than one exchange. Use a Plugin when the interaction is a single request-response.

Use Cases for Topics

Topics are best for scenarios that involve multiple steps or conditional logic. For example, a help desk Topic that asks the user to describe their problem, then asks for their department, then routes them to the correct support queue. Another example is a vacation request Topic that asks for dates, manager approval, and then submits the request. Topics can also handle error recovery by asking the user to rephrase or provide missing information.

Use Cases for Plugins

Plugins are best for single-action tasks. For example, a Plugin that checks the weather for a given city. The user says “What is the weather in London?” The Plugin calls a weather API and returns the result. Another example is a Plugin that looks up a customer record by ID and returns the customer name and status. Plugins do not ask follow-up questions. If the user does not provide the required input, the Plugin fails or returns an error.

Steps to Create a Topic in Copilot Studio

Creating a Topic requires defining trigger phrases and building the conversation flow.

1. Open Copilot Studio and select your Copilot
   Go to Copilot Studio and open the Copilot you want to edit. Click the Topics tab in the left navigation.
2. Create a new Topic
   Click the Add a topic button and select From blank. Name the Topic something descriptive like “Employee Onboarding Questions”.
3. Add trigger phrases
   In the Trigger section, type phrases a user might say to start this Topic. For example: “I need onboarding help”, “new employee guide”, “first day at work”. Add at least 10 phrases for reliable matching.
4. Build the conversation flow
   Drag nodes onto the canvas. Use Question nodes to ask for input. Use Condition nodes to branch based on user answers. Use Message nodes to display responses. Test the flow using the Test pane on the right.
5. Save and publish
   Click Save at the top, then click Publish to make the Topic live for users.

Steps to Create a Plugin in Copilot Studio

Plugins are created in the Plugins tab. You connect them to an external service via a connector or a custom API.

1. Open the Plugins tab
   In Copilot Studio, click the Plugins tab in the left navigation. Click Add a plugin.
2. Choose a connector type
   Select from the list of prebuilt connectors like Microsoft Dataverse, SharePoint, or Outlook. Or select Custom connector to connect to your own API.
3. Configure the action
   Define the input parameters the Plugin expects. For a weather Plugin, the input is the city name. Define the output the Plugin returns, such as temperature and conditions.
4. Test the Plugin
   Use the Test pane to send a sample request. Verify the Plugin returns the correct data.
5. Save and enable the Plugin
   Click Save. The Plugin is now available for Topics to call. You do not need to publish Plugins separately; they are enabled when you publish the Copilot.

Common Mistakes and Misunderstandings

Builders often misuse Topics and Plugins. The most frequent errors involve putting too much logic in a Plugin or treating a Topic like a simple lookup.

Building a Multi-Step Flow Inside a Plugin

A Plugin should perform one action. If you find yourself adding conditional logic or multiple API calls inside a single Plugin, you should split that into a Topic that calls multiple Plugins. A Plugin that tries to handle three different scenarios becomes hard to debug and reuse.

Using a Topic When a Plugin Would Suffice

If the user asks a single question and the Copilot returns a single answer, a Plugin is the right choice. Building a Topic for a simple lookup adds unnecessary complexity. The Topic requires trigger phrases, condition nodes, and output messages. A Plugin handles the same task with less maintenance.

Forgetting to Call the Plugin from the Topic

A Plugin does nothing on its own. It only executes when a Topic calls it. If you create a Plugin but do not add a Call an action node in a Topic, the Plugin remains unused. Always verify that your Topic includes a node that calls the Plugin and handles the return data.

Topics vs Plugins: Key Differences

Item	Topic	Plugin
Purpose	Multi-turn conversation flow	Single action or data retrieval
State management	Maintains conversation state across turns	Stateless; no memory of previous turns
Trigger method	User phrases matching trigger phrases	Called by a Topic node or by user intent detection
Complexity	Supports branches, loops, variables	Simple input-output logic only
External integration	Can call Plugins but does not connect directly to APIs	Directly connects to APIs, databases, and connectors
Example	IT support ticket creation with validation and routing	Check if a user is in an Active Directory group

Combining Topics and Plugins for Complex Scenarios

The most powerful Copilot experiences combine Topics and Plugins. A Topic handles the conversation flow while Plugins provide data from external systems. For example, an expense report Topic asks the user for the amount, category, and receipt. It then calls a Plugin that submits the expense to an accounting system. Another example is a customer support Topic that asks for the issue description, then calls a Plugin to look up the customer account, then calls another Plugin to check open tickets. This pattern keeps the conversation logic in the Topic and the data access in the Plugins.

You can now decide whether a Topic or a Plugin fits your next Copilot Studio project. Start by writing down the user interaction. If the user needs to give multiple inputs or see follow-up questions, use a Topic. If the user asks a single question and gets a single answer, use a Plugin. For advanced scenarios, build a Topic that calls one or more Plugins. Test each component separately before combining them.