Microsoft Copilot Studio Tutorials: Build AI Agents Step by Step

Not long ago, building an AI assistant meant hiring a developer, writing a lot of code, and waiting weeks before anything was ready to test. Microsoft Copilot Studio changed that completely.

Today, you can build a fully functional, AI-powered agent that answers employee questions, processes requests, connects to your SharePoint data, triggers Power Automate flows, and hands off to a human agent when needed — all without writing a single line of code.

I’ve built these kinds of solutions for real organizations — IT helpdesk agents that eliminated 40+ repeated questions per week, leave request agents embedded directly in Microsoft Teams, and onboarding agents that new employees genuinely prefer over reading policy documents. The results surprise people the first time they see it working.

The tutorials on this page cover everything I’ve learned building with Copilot Studio — from creating your very first topic to advanced generative AI configurations, custom integrations, autonomous agents, and enterprise deployment. Written in plain language, step by step, with real examples from actual projects throughout.

What Is Microsoft Copilot Studio? (And Why It’s Different in 2026)

Microsoft Copilot Studio is a low-code platform for building AI-powered conversational agents that can be deployed across Microsoft Teams, SharePoint, websites, and other channels.

It was formerly known as Power Virtual Agents, and Microsoft rebranded and significantly expanded it in 2023 as part of the broader Copilot wave across the Microsoft 365 ecosystem. If you’ve used Power Virtual Agents before, Copilot Studio will feel familiar — but with far more capability, especially around generative AI and the agent framework.

As of 2025–2026, Copilot Studio has grown well beyond a chatbot builder. It now supports:

• Multi-model AI — choose from GPT-5, Claude Sonnet, and other models for orchestration and responses
• Multi-agent orchestration — build connected agents that delegate tasks to each other
• Computer Use — agents that can automate web browsers and desktop applications using natural language
• MCP Server support — connect your agent to any external data source via the Model Context Protocol standard
• SharePoint Lists as a direct knowledge source — not just SharePoint sites and documents
• Code Interpreter — agents that can analyze files and SharePoint data using code
• Agent Evaluations — built-in test sets and grading to measure response quality
• Voice-enabled agents — build agents that work over phone calls, not just chat

With Copilot Studio, you can build agents that:

• Answer questions based on your company’s SharePoint knowledge base, websites, or uploaded documents
• Walk users through step-by-step processes like submitting a leave request or raising an IT ticket
• Connect to backend systems through Power Automate flows or direct API calls
• Integrate with Microsoft Teams so employees interact with the agent right inside their daily workflow
• Handle conversations using generative AI when no predefined topic matches the user’s question
• Escalate to a live human agent when the conversation needs a real person
• Act as an autonomous agent that takes multi-step actions on behalf of a user without constant prompting
• Extend Microsoft 365 Copilot with your organization’s own knowledge and workflows

It sits at the intersection of Power Platform and Microsoft’s AI capabilities — making it one of the most powerful tools in the Microsoft 365 ecosystem right now.

Check out How to Monitor Token Usage by AI Model in Copilot Studio

Copilot Studio vs Power Virtual Agents — What Actually Changed?

If you’ve worked with Power Virtual Agents before, here’s the honest answer on what’s different.

The core canvas-based topic building is essentially the same — triggers, nodes, questions, conditions, and flow integrations all work similarly. What changed significantly is everything around it:

• The terminology shift — Microsoft has fully moved away from the word “bot.” Everything is now called an agent. This reflects the broader shift in how Microsoft thinks about AI assistants — they’re not reactive bots that answer questions, they’re proactive agents that take actions.
• Generative AI is now a first-class feature — In Power Virtual Agents, AI responses were bolted on. In Copilot Studio, generative answers are central to how the product works.
• Knowledge sources — You can point the agent at SharePoint sites, documents, SharePoint Lists, and websites directly. No need to pre-program every possible answer.
• Power Fx support — You can write Power Fx expressions inside topics for sophisticated logic — a huge advantage if you already know Power Apps.
• Autonomous agent capabilities — Agents can take multi-step actions proactively, triggered by events, not just user messages.
• Multi-agent orchestration — Agents can call other agents to handle specialized tasks, enabling modular, enterprise-scale AI solutions.
• Microsoft 365 Copilot extensibility — Copilot Studio is now the tool for extending and customizing Microsoft 365 Copilot with your organization’s knowledge and actions.
• Multi-model selection — You can now choose which AI model powers your agent’s responses and orchestration, including GPT-5 and Claude models.

If you know Power Virtual Agents, you’ll feel at home immediately. If you’re starting fresh, even better — you’re learning the current version without old habits to unlearn.

Who Should Learn Copilot Studio? (And What You’ll Be Able to Build)

• Complete beginners who have never built an agent and want to start from the very beginning
• Power Platform developers who already work with Power Apps and Power Automate and want to add intelligent agents to their solutions
• SharePoint administrators who want to surface SharePoint content conversationally instead of forcing users to search for it
• IT and HR teams who want to reduce repetitive questions by building a self-service agent for employees
• Business analysts who want to automate request and approval processes through a conversational interface
• Intermediate Copilot Studio users who know the basics and want to go deeper into generative AI, multi-agent orchestration, autonomous actions, and enterprise deployment

Every tutorial here assumes you’re new to Copilot Studio but not necessarily new to technology. The concepts are explained clearly before the steps — so you understand what you’re doing, not just how to click through a wizard.

Check out How to Create Your First AI Agent in Microsoft Copilot Studio

Real Examples of What You Can Build With Copilot Studio

Before diving into concepts, it helps to see what this actually looks like in practice. Here are three real agent types I’ve built:

IT Helpdesk Agent
A SharePoint knowledge source powers an agent that handles the top 30 IT questions employees ask — password reset instructions, VPN setup, software request process, printer configuration — all without IT staff involvement. The agent was live in Teams within two days. The first week alone, it handled over 60 conversations that would otherwise have been emails or calls.

Leave Request Agent in Microsoft Teams
A user types “I want to apply for annual leave” into a Teams chat. The agent collects the leave type, start date, end date, and reason using question nodes with date entities. It then calls a Power Automate flow that creates a SharePoint list item, sends an approval email to the manager, and sends a confirmation card back to the user — all within the same conversation. Zero navigation to a separate system required.

New Employee Onboarding Agent
Connected to the company’s SharePoint intranet, the agent answers policy questions for new joiners (“What is the expense reimbursement policy?”, “How do I set up my laptop?”) and walks them through day-1 tasks step by step. HR went from spending 2–3 hours per new joiner answering the same questions to directing people to the agent, which handles 80% of queries without any human involvement.

These are not hypothetical scenarios — they are the kinds of agents you’ll be able to build by working through these tutorials.

How Copilot Studio Works — The Core Concepts

Before you start building, here is the mental model that makes everything in Copilot Studio click.

A Copilot Studio agent is built around three core ideas:

1. Topics

A topic is a conversation path. It defines what the agent does when a user says something specific. Every topic has a trigger — a set of phrases that tell the agent “this is when you should activate this topic” — and a series of nodes that define what happens next: show a message, ask a question, call a flow, branch based on a condition, or end the conversation.

Think of topics as the building blocks of your agent’s knowledge and behavior. You can have system topics (pre-built by Microsoft — things like the greeting, fallback, and escalation behavior) and custom topics that you build for your specific use cases.

2. Entities

Entities are the specific pieces of information your agent extracts from what the user says. If a user types “I need to book a meeting room for next Friday,” the agent needs to understand “meeting room” (what they want) and “next Friday” (when they want it). Entities capture those pieces.

Copilot Studio has built-in entities for common things like dates, times, numbers, email addresses, and boolean yes/no responses. You can also create custom entities — either a fixed list of values (like department names or office locations) or regex patterns for structured data like order numbers or employee IDs.

3. Generative AI and Generative Answers

This is the feature that most changed what Copilot Studio can do. Instead of only responding to topics you’ve explicitly defined, you can point your agent at a knowledge source — a SharePoint site, a set of documents, a SharePoint List, a website — and it uses generative AI to answer questions it wasn’t specifically programmed for.

If the answer exists somewhere in your knowledge base, the agent finds it and responds naturally. This means you don’t have to pre-build a topic for every possible question. You build structured topics for the processes that need precise, step-by-step handling, and let generative answers cover everything else.

These three things — topics, entities, and generative AI — are the foundation of every agent you’ll build in Copilot Studio.

The Copilot Studio Interface — What You’re Looking At

When you open Copilot Studio at copilotstudio.microsoft.com, here’s what you’ll work with:

Agents panel — where you create and manage your different agents. You can have multiple agents in the same environment.

Topics — the section where you build and edit all your conversation paths. This is where you’ll spend most of your time as a builder.

Knowledge — where you add knowledge sources (SharePoint sites, SharePoint Lists, documents, websites) that power the generative AI capabilities of your agent.

Actions — where you connect your agent to Power Automate flows, HTTP endpoints, or MCP server connections that let it actually do things, not just answer questions.

Channels — where you configure where your agent will be deployed: Microsoft Teams, a SharePoint page, a custom website, a voice channel, and more.

Analytics — where you see how your agent is performing: conversations, session outcomes, topics that are working, topics where users drop off, unrecognized questions, and AI response quality scores.

Publish — where you trigger publishing so your latest changes go live across all deployed channels.

5 Lessons I Learned the Hard Way Building Copilot Studio Agents

These are practitioner insights that come from real project work — not from documentation. Apply them early and you’ll save yourself significant rework.

1. Start with a focused, narrow use case

The biggest mistake people make with Copilot Studio is trying to build an agent that does everything for everyone on day one. Start with one specific use case — “answer common IT helpdesk questions” or “help employees submit leave requests” — and build it well. A focused agent that works reliably will get adopted. A sprawling agent with gaps and inconsistencies will get abandoned. You can always expand later.

2. Add a knowledge source before you build every topic manually

Before you start hand-building topics for every question your agent should answer, add your SharePoint site or FAQ document as a knowledge source and enable generative answers. Test it. You’ll be surprised how many questions it handles correctly out of the box.

This lets you focus your manual topic-building effort on the processes and workflows that genuinely need structured conversation paths — approval flows, data collection, multi-step requests. Everything else, let generative answers handle.

3. Variables are more powerful than you think — learn them early

Most beginners skip variables until they hit a wall. But Topic variables, Global variables, and System variables unlock the majority of advanced logic in Copilot Studio. Learn System.User.DisplayName (the logged-in user’s name), System.LastMessage (what the user last said), and how to pass Topic variables into Power Automate flow inputs in your first week — not after you’ve already built 20 topics that need retrofitting.

4. Test constantly in the chat panel — don’t save testing for the end

Copilot Studio has a built-in test panel on the right side of the screen. Use it after every change. After every single node addition, not after you’ve built the whole topic. The most common beginner mistake is building a long, complex topic and only then discovering that a trigger phrase conflict or entity mismatch breaks the whole thing midway. Catch problems early when they’re easy to fix.

5. The Analytics unrecognized utterances report is your best product roadmap

After your agent has been live for a week, go into Analytics and look at the “Unrecognized utterances” — the questions users asked that your agent couldn’t handle. This report tells you exactly what topics to build next.

Don’t guess what users need based on assumptions. Let real conversation data drive your topic backlog. This single habit separates agents that improve over time from ones that stagnate.

Common Mistakes Beginners Make in Copilot Studio

❌ Trying to handle everything with one giant topic
Topics should be focused. If you find yourself building a topic with 15+ nodes and branching in every direction, it should be multiple topics that redirect into each other. Copilot Studio has a Redirect node specifically for reusing common conversation paths.

❌ Not configuring the Fallback topic
The Fallback topic is what your agent says when it doesn’t understand something, and generative answers don’t have an answer either. The default Microsoft fallback (“I’m sorry, I didn’t get that”) is not good enough for a production agent. Customize it to suggest alternatives, ask the user to rephrase, or offer to escalate to a human. The fallback experience shapes how users perceive your entire agent.

❌ Using Message nodes when a Question node is needed
Many beginners display information when they should be collecting it. If your flow needs data from the user — a date, a name, a selection — use a Question node with the correct entity type. Message nodes don’t wait for user input. This is one of the most common causes of broken conversation flows for beginners.

❌ Forgetting to configure authentication scope from the start
If your agent is internal-only (for Microsoft 365 users in your organization), set authentication to Microsoft Entra ID from day one. Retrofitting authentication into an already-deployed agent that had no authentication breaks existing channel configurations and requires re-publishing and reconfiguring. Decide your authentication model before you build a single topic.

❌ Publishing once and walking away
Copilot Studio agents require ongoing attention. Check Analytics weekly. Read through conversation transcripts. Look at session outcomes — how many conversations are marked as “resolved” vs “abandoned” vs “escalated.” A good agent improves continuously based on real user behavior, not based on what you thought users would ask when you built it.

What You’ll Learn in These Tutorials

The tutorials on this page are organized into learning tracks, from beginner fundamentals through to advanced enterprise configurations. New tutorials are added regularly.

Getting Started

• What is Copilot Studio, and how does it fit into Microsoft 365
• Setting up your environment and creating your first agent from scratch
• Understanding the Copilot Studio interface — a guided walkthrough
• Creating your first topic and testing it in the built-in chat panel
• The difference between system topics and custom topics
• How Copilot Studio fits alongside Power Apps and Power Automate in the Microsoft ecosystem

Building Topics

• Creating a topic from scratch — triggers, messages, and question nodes
• Using question nodes to collect information from users with the right entity type
• Branching conversations with condition nodes — if/else logic in topics
• Using the Message node effectively — text, images, videos, and adaptive cards
• Ending a conversation cleanly vs. escalating to a human agent
• Redirecting between topics — how to reuse common conversation paths across your agent
• The Fallback topic — customizing what happens when the agent doesn’t understand

Entities and Slot Filling

• Using built-in entities for dates, times, numbers, and email addresses
• Creating custom entities with a fixed list of values (department names, office locations, issue types)
• Creating regex entities for structured data like employee IDs and order numbers
• Slot filling — how the agent collects multiple pieces of information naturally in a single conversation turn

Generative AI and Knowledge Sources

• What generative answers are and how they work under the hood
• Adding a SharePoint site as a knowledge source — step by step
• Adding SharePoint Lists as a direct knowledge source (available from May 2026)
• Adding documents and files as a knowledge source — supported formats and file limits
• Adding public websites as a knowledge source
• Configuring generative answers — controlling tone, response length, citation behavior, and content scope
• Grouping files with custom instructions to guide how the agent uses specific knowledge sources
• Combining structured topics with generative answers in the same agent — when to use each
• Using Code Interpreter to let your agent analyze SharePoint files and data during a conversation
• Testing and tuning generative AI responses to improve accuracy and relevance

Actions and Integrations

• Calling a Power Automate flow from a Copilot Studio topic — the complete setup
• Passing data from the conversation into a flow — topic variables as flow inputs
• Returning data from a flow back into the conversation — using flow outputs in message nodes
• Using flows to read and write SharePoint list data from within a conversation
• Using flows to send emails and Teams notifications triggered by agent conversations
• Calling HTTP endpoints directly from a topic — when and how to use HTTP request actions
• Connecting your agent to external systems via MCP servers — what it is and how to configure it
• Using connectors and plugins to extend your agent beyond Power Platform

Variables and Logic

• What variables are in Copilot Studio and how they differ from Power Apps variables
• Topic variables vs Global variables vs System variables — when to use each
• Setting and reading variables across multiple topics in the same session
• Using Power Fx expressions inside Copilot Studio topics for advanced logic
• Building multi-branch conditional logic — practical examples with real conversation scenarios
• Passing system variable values like System.User.DisplayName into messages and flows

Adaptive Cards

• What adaptive cards are and why they make agent conversations significantly better
• Designing adaptive cards using the Adaptive Card Designer at adaptivecards.io
• Displaying information in a structured card format inside the agent conversation
• Using adaptive cards to collect structured input from users — form-style collection inside chat
• Sending adaptive cards through Microsoft Teams — formatting considerations and limitations
• Rendering adaptive cards on SharePoint and website channels

Channels and Deployment

• Publishing your agent for the first time — what happens when you click Publish
• Deploying your agent to Microsoft Teams — the complete step-by-step process
• Adding your agent to a SharePoint page using the bot web part
• Embedding your agent on a public or internal website with the embed code
• Configuring authentication — who can interact with your agent and how
• Using Microsoft Entra ID authentication for internal agents — setup and testing
• Configuring your agent for voice channels — building voice-enabled agents
• Managing multiple deployment channels from a single agent

Analytics and Improvement

• Reading the Copilot Studio analytics dashboard — what every metric means
• Understanding session outcomes — resolved, escalated, and abandoned conversations
• Using the unrecognized utterances report to discover what topics to build next
• Reading through conversation transcripts to identify gaps and breakdowns
• Measuring AI response quality with agent evaluations and test sets
• Analyzing user sentiment from conversation data — what’s available from May 2026
• A/B testing topic trigger phrases to improve recognition accuracy

Advanced Topics

• Multi-language agents — building assistants that support more than one language
• Copilot Studio and Dataverse — using Dataverse as a backend for your agent
• Extending Microsoft 365 Copilot with Copilot Studio agents — declarative agents and plugins
• Autonomous agents — building agents that take multi-step actions triggered by events, not user messages
• Connected agents and multi-agent orchestration — building modular AI solutions at enterprise scale
• Computer Use — building agents that automate web browsers and desktop applications
• Governance and ALM — managing agents across development and production environments
• Security and compliance considerations for enterprise agent deployment
• Choosing your AI model — GPT-5, Claude Sonnet, and when to use which
• Using the Copilot Studio extension for Visual Studio Code — advanced developer workflows
• Copilot Tuning — fine-tuning AI models on your organization’s own data

Start Here: Your First Step Into Copilot Studio

If you’re new to Copilot Studio and want to know where to begin, here is the recommended path:

1. Read the core concepts section on this page — Topics, Entities, and Generative AI. Make sure you understand the mental model before you open the product.
2. Open Copilot Studio at copilotstudio.microsoft.com — if you have a Microsoft 365 work account, you already have access to the free trial environment.
3. Start with the “Setting up your first agent” tutorial — it walks you through creating an agent, adding a knowledge source, and testing it in the built-in chat panel. You can have a working agent in under 30 minutes.
4. Then move to “Creating your first topic” — once you see what generative answers can handle automatically, you’ll understand where structured topics add value on top of it.
5. Come back to this page as your roadmap — as you grow more confident, use the curriculum outline above to identify the next skill to develop.

The tutorials here are designed to build on each other, but they also work as standalone references. If you hit a specific problem while building — slot filling isn’t working, your flow integration isn’t passing data correctly, your Teams deployment isn’t showing up — search this site and you’ll likely find a dedicated tutorial for that exact issue.

Every tutorial on this site comes from working through these problems on real projects. Not from reading documentation and paraphrasing it, but from building agents that real people use every day. That’s the perspective you’ll get here — practical, direct, and honest about what actually works.

Microsoft Copilot Tutorials

Here is the list of Microsoft Copilot Studio tutorials:

• How to Choose an AI Model in Copilot Studio: GPT-5, Claude, and More
• How Generative AI Works Inside Copilot Studio
• Environment Strategy for Copilot Studio: Dev, Test, Prod

Frequently Asked Questions About Microsoft Copilot Studio