[Copilot Studio] Building "Movement" with Topics, Tools, and Agent Flows: From Design to Operation Verification

Introduction

Hello, I'm Kema.

In the previous articles, we created an agent and enabled it to answer questions based on knowledge.
However, just answering questions keeps it at the level of an "assistant." In actual business operations, you often want one step further — things like "execute a fixed procedure," "follow a set flow when a specific type of question comes in," or "fetch external data and process it."

Copilot Studio provides three components for building these "behaviors": Topics, Tools, and Agent Flows. The names sound similar and can be confusing at first, but their roles are clearly distinct.

In this article, I cover these three components and verified them hands-on in the actual product as of June 2026. The subject is "an agent that accepts KPI report creation requests." I'll walk through the entire flow — with screenshots — of creating a topic that captures the company name and quarter, then having a tool (prompt) and agent flow generate a report based on the received information. I hope this serves as a reference for those who want to build out conversation flows and processing in Copilot Studio.

This article is the third installment in a series on building agents in Copilot Studio.
The series as a whole aims to build an agent that handles "collection → aggregation → charts → insights → documentation" end-to-end, and this article covers the "moving parts" that form its foundation.

Target audience: Those who want to understand the differences and use cases of topics, tools, and agent flows in Copilot Studio, and try them out in practice.

Series Article List

1. What We're Doing This Time

• Organize the roles and use cases of the three components: topics, tools, and agent flows
• Create a topic from scratch and verify that the conversation flow works in the test chat
• Review the contents of a tool (AI prompt) on screen and understand the flow from input to output
• Review the structure of an agent flow on screen and understand its role as a deterministic automation component

2. The Differences Between the Three "Moving" Components

First, let's organize what each of the three components is for. Understanding this will help you avoid confusion about which one to use in each situation.

Roughly speaking: topics create the conversational path, tools add individual capabilities, and agent flows automate procedures precisely.

When generative orchestration is enabled, users don't need to specify "which component to use." The agent automatically selects and executes the appropriate topic, tool, knowledge, or other agent based on descriptions and names. Note that agent flows are not independently selectable — they become selectable by being added as a tool.

This behavior of "the agent choosing its own components" is hard to grasp from text alone, so we'll verify it with actual screens in Chapter 3.

3. Topics: Designing the Conversation Flow

A topic is a component that assembles conversation flow using a node-based editor.
It consists of a trigger (when it activates) and the nodes that follow (what it does).

Here, we'll create a topic to "accept a report creation request" from scratch. There are three things we want to accomplish:

• When the user asks to "create a report," this topic activates
• Capture "which company" and "which quarter" and save them to variables
• Confirm acceptance with a message that includes the captured information

3.1 Creating a Topic

Open the "Topics" tab of the agent to see the topic list.
Press "Add a topic" and select "From blank" to create an empty topic.

Select "Add a topic" → "From blank" in the topic list. Selecting "Add with Copilot" lets you automatically generate a draft from a description.

3.2 Setting the Trigger and Description

When you open the topic editor, the trigger appears at the top. For agents with generative orchestration, the trigger defaults to "When the agent selects it." This doesn't mean "activate when a specific keyword appears" — rather, the agent uses the topic's description to decide whether to activate it.

This makes the description extremely important. By writing "when this topic should be used" in the description, the agent reads it to determine activation. Here's what I wrote:

Activates when the user requests the creation or delivery of a KPI report. Confirms the target company and quarter, then notifies the user that the report creation request has been accepted.

The trigger is "When the agent selects it." By writing "when it should activate" in the description, the agent reads this text to decide whether to activate the topic.

3.3 Saving Responses to Variables with Question Nodes

Add nodes below the trigger. To add a node, press the "+" below a node. A list of node types you can add will appear.

Press "+" to see the list of addable nodes. We'll use "Ask a question" this time. Others include send a message, condition branching, variable management, etc.

Select "Ask a question" to add a question node. The question node has three main settings:

• Question text: What to ask the user (e.g., "Which company's report would you like to create?")
• Identify: What information to extract from the answer. This time, we used "The user's entire response" (use the typed text as-is)
• Save the user's response as: Which variable to store the extracted value in

This "save to variable" is the most important point in topics. By storing the answer in a variable, you can use that value in later nodes. This time, we saved the company name to a variable called CompanyName.

Question node settings. It asks "Which company's report would you like to create?" and saves the entire response to CompanyName (string). This is the "variable set" state.

3.4 The Complete Topic Overview

Following the same approach, add a second question node to save the quarter to the Quarter variable.
The completed topic flows like this:

The completed topic. Trigger → Question 1 (save company name to CompanyName) → Question 2 (save quarter to Quarter) → Confirmation message, flowing from top to bottom.

To summarize, this topic assembles a conversation where "once activated, it asks for the company name and quarter in order, saving each to variables." A topic is a component that visually assembles "when to activate (trigger)," "in what order to ask and guide (nodes)," and "where to save answers (variables)."

3.5 Verification: Having a Conversation

Let's run the created topic in the test chat.
When I typed "I'd like you to accept a report creation request," this topic activated and the first question came back.

When I requested "I'd like you to accept a report creation request," the topic activated and asked "Which company's report would you like to create?"

What's notable here is that the user didn't specify "use this topic." The agent compared the request text with the topic's description (written in 3.2) and determined "this is a report request" to activate it. This is how topics work under generative orchestration.

Continuing to answer with the company name (CloudNova) and quarter (Q2 2025) completes the acceptance. The actual exchange in the test chat looked like this:

Agent: Hello, I am the KPI Report Creation Assistant. Please let me know what you need.
You: I'd like you to accept a report creation request
Agent: Which company's report would you like to create? (e.g., CloudNova / StreamForge / Datapeak)
You: CloudNova
Agent: Please tell me the target quarter. (e.g., Q1 2026)
You: Q2 2025
Agent: I will create the KPI report for CloudNova for Q2 2025. Please wait a moment.

Even with the vague request "I'd like you to accept a report creation request," the topic activated, captured the company name and quarter one by one, and completed acceptance. At this point, the execution trace on the left shows "which topic was selected and what happened."

The execution trace on the left shows the "Report Request Acceptance" topic as completed. On the right side of the chat, an acceptance message reflecting the captured company name (CloudNova) and quarter (Q2 2025) was returned.

The captured company name and quarter are reflected directly in the response. This is because we're using the CompanyName and Quarter variables saved in the question nodes within the confirmation message. By saving to variables, you can retrieve and use the values later.

3.6 Verification: Topic Connecting to a Tool

After acceptance, the agent suggested what it could do next — things like "create a chart of metrics like ARR" or "create a Word-format report." When I asked "Please make this KPI report into a Word file," the agent referenced the knowledge (registered KPI summary) and called a tool (the next chapter's prompt "KPI Report Insertion (Word)"), generating a Word-format KPI comparison report.

Here is a summary of the generated report (from the agent's response; target period: Fiscal Year 2025, Q2):

The agent also included insights such as "Datapeak leads in both ARR and NRR with the highest operating profit margin. CloudNova has a high NRR, indicating strength in customer retention. StreamForge has a negative operating profit margin and needs improvement in both growth and profitability," and notified that the KPI comparison report (Word format) was complete (figures are fictional test data).

When asked to "make it a Word file," the agent referenced the knowledge and called the "KPI Report Insertion (Word)" tool. The trace on the left shows 3 steps: Acceptance → Knowledge Reference → Insertion (Word), and on the right, the KPI comparison report (Word format) content generated by the tool is displayed.

Through this, we can see the connection between components: "the topic receives information through conversation, then a tool takes over the processing." In the next chapter, we'll look inside this "tool."

4. Tools: Building Processing with AI Prompts

A tool is a component that adds one "capability" to the agent.
Opening "Add a tool" displays a list of types you can add.

Adding a tool. New creation options include Agent Flow / Prompt / Model Context Protocol (MCP) / Computer Use. The bottom row shows connectors like Office 365, Teams, and SharePoint.

The main types you can create new are as follows:

In addition, connectors like Office 365 Outlook, Microsoft Teams, and SharePoint, as well as REST APIs, can also be added as tools.

Among these, prompts are the easiest way to create "processing." A prompt tool is a component that receives input, performs AI inference according to instructions (a prompt), and returns the result. The "KPI Report Insertion (Word)" that the agent called in Chapter 3 is also this type of prompt tool. Let's look at what's inside.

4.1 Writing Instructions in the Prompt Builder

Creating a new prompt opens the prompt builder.
You write the instructions (prompt) on the left and verify the results on the right while building. This is the "place to enter the prompt."

The prompt builder. Instructions (prompt) on the left, the model to use in the upper center, and the output format and results on the right.

Write "what kind of AI this is" in the instructions. For this KPI report insertion, the instructions say "insert the provided KPI figures into the designated fields of the Word template."

4.2 Selecting a Model

Near the instructions, there's a field for selecting the model to use. This determines which AI model will be used for the prompt's processing.

Model selection. Divided into Basic, Standard, and Premium grades; the default is GPT-4.1 mini in Basic. Claude and xAI models are also listed at the bottom.

As of June 2026, the following models were available in my environment:

Without changing anything, the default GPT-4.1 mini (Basic) is used. The approach is to start with this default, which is sufficient for light summarization or insertion tasks, and switch to a higher-grade model when you need more complex reasoning.

4.3 Defining Inputs and Outputs

A prompt tool is roughly made up of three parts: "input → AI inference → output." Here, we decide the entry point (input) and exit point (output).

• Input: Where you define the data passed to this tool from outside (set in the tool details screen)
• Output: What format to return the processing result in (text / JSON / document; selected in the prompt builder)

First, input. The tool details screen has an "Input" field.

Tool details screen. "Input" is not set (no input). The "Done" section below determines the agent's behavior after the tool finishes (default is "Don't respond"), which is separate from the output format.

No input is needed this time. This tool has the KPI figures to insert written directly in the instructions (prompt), so no input is required. If you want to change the company name, quarter, and KPIs per call, you would add inputs here and pass values from the agent when calling it (that dynamic passing approach will be covered in a future "documentation" installment).

Next, output. The output format is selected from the "Output" in the upper right of the prompt builder seen in 4.1. The default is text; choose JSON when you want structured output, and choose Document (preview feature) when you want to create a Word file.

Opening "Output" in the upper right of the prompt builder. You can choose from text, JSON, or document. We chose "Document" this time to create a Word file.

With document output, you provide a Word template with blank fields, and the AI model fills in the appropriate values for each field and outputs a Word document.

To summarize, the tool we created this time is: "Input: none (KPIs embedded in instructions) → AI inference: selected model determines values to insert → Output: Document (Word)." The Word report the agent returned in 3.6 was generated by exactly this tool.

5. Agent Flows: Deterministic Automated Processing

An agent flow is a component that executes fixed procedures from top to bottom in order.
While topics handle "conversation" and prompts handle "single AI inference," agent flows are suited for reliably executing multi-step automated processing like "fetch data, process it, create a file..."

5.1 Assembling Steps in the Flow Designer

Agent flows are built in a dedicated flow designer.
Starting from a trigger, actions are arranged from top to bottom in order.

The flow I created for this series fetches figures from Excel → generates an aggregation comment with a prompt → creates a Word file → issues a sharing link.

Note that the Word document the agent returned in 3.6 was generated by the standalone prompt tool from Chapter 4. The flow in this Chapter 5 is a separate, more complex example that includes Excel aggregation and file distribution.

The flow designer. Triggered by "When an agent calls a flow," it executes from top to bottom: get rows (Excel) → run a prompt → create a file → create a sharing link.

Looking at each step reveals the flow's character well:

• Get rows: Reads figures from Excel Online (connector)
• Run a prompt: Calls a prompt (AI inference) like in Chapter 4 within the flow
• Create file / Create sharing link: Creates a file in OneDrive and issues a sharing link (connector)

In this way, a flow is a component that combines connectors and AI inference in a fixed order. It allows you to divide responsibilities within a single procedure — parts that require AI flexibility (generating aggregation comments) and parts that must be done mechanically and reliably (reading Excel, creating files).

5.2 Checking Execution Status and Connectors

Flows have an overview screen. Here you can check the flow's execution history and the connectors (connections) it uses.

Flow overview screen. The execution history at the bottom shows that past executions "succeeded." On the right, the connections this flow uses (Excel Online, Dataverse, OneDrive) are listed.

The execution history shows when it ran and whether it succeeded. Since a flow is a component that executes fixed procedures, you can use this history to verify after the fact "did it run through the same steps correctly each time."

A flow can be added to an agent as a "tool." This means the agent calls the flow as needed and has it execute fixed procedures (this is what was mentioned in Chapter 2 about "flows becoming selectable as tools").

5.3 How to Differentiate from Topics and Prompts

Why is a flow needed separately from "topics" or "prompts"?

Because there are processes where you want to reliably follow the exact same steps every time. AI generation is flexible, but it doesn't always produce exactly the same result. On the other hand, business processes like "fetch figures from Excel → aggregate → insert into Word → issue sharing link" are things you want to run through exactly the same steps every time. The basic approach is to leave such deterministic processing to flows and leave only the parts that require flexibility — like text generation — to prompts.

6. Summary

We confirmed the three components for building "behavior" in an agent through a single subject matter.

• Topic: Designs the conversation flow (trigger + nodes). We actually created a "report request acceptance" topic from scratch, saved company name and quarter to variables, and confirmed the behavior of the agent selecting and activating the topic based on the request content.
• Tool (Prompt): Creates one unit of input → AI inference → output processing. We reviewed the instructions, model, and input/output on screen. Suited for flexible generative processing like inserting into Word.
• Agent Flow: Reliably executes fixed procedures. Suited for deterministic processing like Excel aggregation and file distribution.

The difference between the three is easy to remember as: "topics create conversation," "tools add capabilities," "flows automate procedures." And as we saw this time, these don't just work independently — they work together like "topic accepts → tools and flows handle processing" to complete a single task.

References

• Copilot Studio overview | Microsoft Learn
• Key concepts - Create and edit topics | Microsoft Learn
• Add tools to custom agents | Microsoft Learn
• Change the model version and settings | Microsoft Learn
• Agent flows overview | Microsoft Learn
• Automate web and desktop apps with computer use | Microsoft Learn
• Document output (preview) | Microsoft Learn