Copilot Studio topics, instructions, and actions explained
When building agents in Copilot Studio, you need to create a set of rules to ensure the agent behaves and responds accurately. If you think of an agent as a company-specific version of ChatGPT, you might think you need to prompt the agent so that it will do what you want.
This prompting approach is necessary with commercial LLMs like ChatGPT, Gemini, Grok and Claude, but when building an agent for your company in Copilot Studio, prompts are only one of three controls, and typically not the most important one.
You can use three methods to control the agent:
-
Instructions: These are your agent’s always-on system prompt. Use instructions to set the persona, tone, and the goals the agent should aim for on every interaction.
-
Topics: Each topic is a conversational flow built on an authoring canvas using nodes: Message, Question, Adaptive Card, Condition, Variable management, Topic management and Tool nodes. With generative orchestration (the default for new agents), the agent selects topics based on their description. With classic orchestration, topics fire from trigger phrases. Either way, once the agent enters a topic, it follows the script you have drawn rather than selecting a response probabilistically.
-
Tools (also called actions): Single-step integrations that allow your agent to interact with other applications. A tool might call a Power Automate flow, query Dataverse, send an email, or call an external API. You can call a tool from a Tool node inside a topic, or let generative orchestration invoke it directly when the user’s request matches the tool’s description.
When to use instructions
Instructions work best for simple personas and guardrails. If you need your agent to always respond in a particular tone, never discuss competitors, or introduce itself with a specific greeting, instructions are the right place. Generative orchestration reads the instructions on every turn and uses them to decide how to route the conversation, which knowledge sources to search, and which topics or tools to invoke.
Simple tasks that do not require the user to provide multiple pieces of information are the best fit for instructions combined with a knowledge source. An internal FAQ agent, for example, can answer policy questions purely from instructions and uploaded documents without a single topic.
If you are setting up knowledge sources for your agent, see how to connect SharePoint as a knowledge source in Copilot Studio.
Instructions don’t work well with conditional logic. If you find yourself writing “if the user says X, do Y, but if they say Z, do W”, you have outgrown instructions. That branching belongs in a topic.
When to use topics
Topics are the right choice when you need a multi-step conversation with branching. If your agent needs to collect several pieces of information in a specific order, present adaptive cards, or follow a predictable journey, a topic gives you explicit control over every step.
Topics also work well when you need your agent to follow compliance and audit requirements. Because the flow is deterministic, you can guarantee the agent asks the right questions in the right order and stores the answers in the right variables. There is no risk of the LLM skipping a step or rephrasing a mandatory disclaimer, which Microsoft’s orchestration guidance reinforces.
Use a topic whenever you want the LLM to follow a script rather than improvise. If you need to create or edit topics, the authoring canvas in Copilot Studio makes the branching logic visual.
When to use tools (actions)
Use tools to handle single-step calls: fetch a record from Dataverse, send a confirmation email, look up a customer’s order status, or post a message to Teams. They are self-contained units of work.
You can combine tools with topics by adding a Tool node inside a topic flow. This is the pattern I recommend for agents that must write data back to a database. Letting generative orchestration call a write tool directly means the LLM decides when to trigger it based on its description, which can be risky if the user’s intent is ambiguous. Wrapping the tool inside a topic lets you enforce a deterministic flow before the write happens.
For read-only operations, letting generative orchestration invoke tools directly is usually fine. The agent reads the user’s question, decides it needs data, calls the tool, and returns the result.
If you need the agent to run several steps in sequence without waiting for user input, consider an agent flow instead. Agent flows are multi-step automation sequences (similar to Power Automate flows) that the agent can trigger from a topic or autonomously.
The decision framework
Most IT professionals who start learning Copilot Studio assume that instructions are all they need to ensure the agent follows the rules. This happens because it is easy to assume that a Copilot agent is like a custom ChatGPT or a project in Claude where a long and complex prompt improves the output and reduces hallucinations.
I have seen plenty of cases of long instructions with conditional logic written using natural language. The most common is a list of rules the agent must follow, such as “Use SharePoint list X if the user asks about this topic” or “ask before sending an email”. This approach does not work in Copilot Studio where instructions, topics and tools all serve a different purpose and all have a place in your AI strategy.
This is the core reference method I use when I consult my clients or when I teach Copilot Studio:
| Use case | Recommended approach | Why |
|---|---|---|
| Internal FAQ answering policy questions | Instructions + knowledge source | One-shot answers; no data collection needed; generative orchestration routes to the right knowledge |
| IT helpdesk intake form | Topic | Multi-step data collection with required fields; predictable flow; audit trail |
| CRM record lookup | Tool | Single-step read; the agent calls Dataverse and returns the result |
| HR onboarding flow with conditions and data writes | Topic + tools | Branching logic collects information step by step; Tool nodes write to Dataverse at controlled points |
| Consistent persona and hard rules across all conversations | Instructions | Always-on system prompt; applies to every turn without extra authoring |
| Send confirmation email after form submission | Tool called from a topic | The topic gathers the data; the tool fires only after the topic confirms the submission |
How instructions, topics and tools work together
Consider an HR agent built in Copilot Studio. The instructions set the persona: friendly, professional, always responds in UK English, never gives legal advice, and directs complex queries to the HR team.
When an employee asks to book annual leave, generative orchestration matches the request to the absence request topic based on its description and routes the conversation there. The topic asks for the leave type, start date, end date, and any handover notes using Question nodes. It confirms the details with the user using an Adaptive Card node. Once confirmed, a Tool node calls Dataverse to create the absence record, and a second tool sends a confirmation email to the employee’s manager.
When the same employee later asks “how many days of leave do I have left?”, there is no topic for that. The instructions and a connected knowledge source handle it: generative orchestration calls a read tool to pull the balance from Dataverse and returns the answer in a single turn. No topic needed.
In this pattern the instructions carry the always-on rules, the topics run the structured multi-step flows, and the tools read and write the data.
If you need to build an agent that runs without user input, read about autonomous agent event triggers. For more on building agents with Power Platform or preparing for the PL-200 certification, explore those guides next.