Microsoft Copilot Studio

About the Microsoft Copilot Studio Training

A complete, one-day training to build, publish and govern AI agents in Microsoft 365 with Copilot Studio.

Copilot Studio is Microsoft's low-code platform for building AI agents: agents that answer from your organisation's validated sources, act on your business systems through connectors and workflows, and are published where your colleagues already work, in Microsoft Teams. The training is built for the people who know the subject: HR, operations, communications, finance, IT. No code is required.

In practice, participants learn to:

• create an agent in Copilot Studio and write instructions that drive its behaviour,
• ground its answers in your documents, SharePoint sites and business data,
• connect it to your systems through connectors, workflows, Dataverse and MCP tools,
• script the part of a process that must not be improvised, and only that part,
• publish it to Microsoft Teams, decide who may use it, and measure how it performs.

The eaQbe Methodology: A Progressive Learning Curve

We don't believe in training that overwhelms participants with theory. We believe in structured immersion: understand before you build, use before you implement, see the end goal before diving into technical details.

The training teaches generative orchestration end to end. It is how Copilot Studio creates new agents by default, and it is what participants build with from the first hour: instructions, knowledge and tools, with the agent choosing what to use for each request. The classic experience, scripted topics, remains part of the product and will remain available: we show it and we name the cases where it still applies, voice, contact centre, and processes that must run exactly as designed.

Learning path

1) Foundations: what an agent is, and where it lives

What separates an agent from a scripted chatbot, the three Microsoft platforms (Microsoft 365 Copilot, Copilot Studio, Microsoft Foundry) and when each one is the right answer, and the environment your agents and their data live in. Participants then dissect a working agent built from a template before building anything themselves.

2) Making the agent useful: instructions, knowledge, tools

Instructions that hold, knowledge sources that ground the answers in your own material, and tools that let the agent do rather than only say: connectors, REST APIs, MCP, Power Automate workflows. Participants build a working generative agent with no scripted topic at all.

3) Control: topics, variables and the deterministic path

The scripted world, shown rather than taught at length: topics, nodes, triggers, variables and entities, and above all the rule for deciding when a process earns a script instead of the model's improvisation.

4) Publish, govern, measure

Testing with the activity map, publishing to Microsoft Teams and other channels, deciding who may talk to the agent and what it may show them, and reading the five numbers that say whether it is doing its job.

What you leave with

Participants do not leave with a demo. They leave with an agent of their own and the small set of decisions that keep it useful once nobody is watching:

• A published agent: built in the room, grounded in real sources, reachable from a channel your colleagues already use.
• A decision rule: generative by default, scripted when the process needs exact wording, an exact sequence, reproducibility, or a controlled action with real consequences. Four cases, named, so your team can apply the rule without us.
• Descriptions that do the work: under generative orchestration the agent chooses its topics, tools and knowledge by reading their descriptions. Writing those descriptions is the skill that decides whether it picks the right one.
• Grounded answers: knowledge sources configured, so the agent answers from your validated documents instead of from the model's general knowledge, and says so when it does not know.
• A boundary: who may talk to the agent and what it may show them, decided through authentication and security trimming before publishing, not after an incident.
• A place for it to live: the environment, what it isolates, and the two reasons an organisation ends up needing more than one.
• A debugger: the activity map, which shows the agent's plan and tells you why it chose what it chose. The answer to "why did it say that".
• An instrument panel: sessions, engagement, escalations, abandonment and satisfaction, read as a story rather than as five isolated figures.
• The written reference: the full course material, including the sections only shown in the room, so the day is a starting point and not a memory test.

Two sentences govern the rest, and they are the ones to leave with: the agent answers from your sources, never from its own memory; and a process that must not be improvised gets scripted, while everything else is better left to the model.

Everything assembled during the session leaves with you: your agent, the material, and the reasoning behind each decision so your team can extend it without us. That is what building capability rather than dependency means here.

Practical details

• Format: 1-day intensive workshop (hands-on, lab-based)
• Group size: 5–10 participants (small groups for personalized coaching)
• Prerequisites: everyday use of Microsoft 365, no code and no developer tooling required
• Follow-up: evaluation + post-training anchoring exercises