Microsoft 365 Copilot Agents: The 4 Levels of Mastery

Microsoft 365 Copilot is no longer limited to simple conversational chat. Between pre-built agents, the Agent Builder, skills integrated into Excel and PowerPoint, and now Copilot Cowork, the platform now covers a genuine spectrum of technical maturity. This article details four levels to understand how to progress from passive usage to governed automation, including prerequisites, known pitfalls, and an audit script for Microsoft 365 administrators.

Understanding the progression: four levels, one single license

All levels described here are based on the same foundation: a Microsoft 365 Copilot license (add-on to Microsoft 365 Enterprise subscriptions). What changes from one level to the next is not access but the technical skill required: prompt writing, instruction structuring, Markdown writing, then workflow design.

Level 1 — Beginner: leveraging pre-built Copilot agents

At this stage, no configuration is necessary. The Researcher agent, for example, is directly available with ready-to-use prompts: one click generates a daily summary ("daily briefing") delivered to your inbox each morning.

To go a little further without changing technical level, two options exist:

• Customize the prompt with a structured formula like GCES (Goal, Context, Expectations, Source), which allows you to guide the result without writing complex instructions.
• Schedule the execution: by hovering over a prompt, a button allows you to schedule it exactly like a recurring meeting — daily frequency, specific time (for example 11:00 AM), with the option to receive the result by email.

Level 2 — Intermediate: creating an agent with Agent Builder

The natural temptation after level 1 is to build your own agent. In Copilot Chat, the left panel offers a "New agent" button, which opens the Agent Builder: a conversational interface where you describe in natural language what the agent should do (for example: "write emails in my style").

The result works, but remains generic as long as no detailed instructions have been provided. This is the structural limit of this level: the agent responds, but without real tuning on format, tone, or expected options.

Two concrete examples illustrate the difference between a "raw" agent and a truly configured agent:

• An agent renamed "Email 101 Manager", invokable directly from the Copilot button in Outlook (Copilot icon → "+ " → "More" → "All agents"), capable of offering multiple versions of responses (short, long, intermediate) because precise instructions were injected into its configuration.
• A "PowerPoint Guru" agent, to which you attach a presentation to automatically obtain a summary of the deck, key points to prepare, and a database of questions classified by angle.

Level 3 — Advanced: skills in Markdown in Excel and PowerPoint

This is where the mechanics really change in nature. Skills allow you to automate repetitive tasks directly in Office applications, via instruction files structured in Markdown and stored in OneDrive.

In Excel, the "Manage skills" menu (accessible via the three dots at the top of the Copilot interface) distinguishes two categories:

• Pre-built skills, such as the financial model "three statements" (income statement, balance sheet, cash flow).
• Custom skills, stored in a dedicated OneDrive folder, where each file uses standard Markdown syntax (#, ##) to structure instructions. A # title becomes a section, and the text that follows takes on bold formatting in the agent's interpretation.

A typical example: a "make calendar" skill invoked with the mention @make calendar, which generates a complete calendar in Excel and automatically highlights today's date in yellow — an instruction explicitly coded in the skill file under a dedicated section.

The "three statement model" skill goes further: from a simple prompt, it generates an income statement, balance sheet, and coherent cash flow statement, with the usual consistency checks of a financial model. It is then possible to chain a second skill dedicated to visual formatting (colors, visual brand).

Replicating a skill in another application

A more advanced technique is to use a dedicated agent — an "Agent Instructions Builder" — to generate a new skill from an existing model. By providing as an example the "make calendar" skill file and describing the objective (add a mention of type learn.copilot.ai at the bottom right of each slide), the agent produces a new skill file ready to deploy in PowerPoint.

Once the file is corrected and placed in the OneDrive skills folder, it must be activated manually in PowerPoint via "Manage skills → Custom skills" — each Office application manages its own list, independently of the others. The skill is then invoked with @, choosing along the way the underlying language model (multiple Copilot applications offer a model choice, including Claude depending on deployments). On a 96-slide presentation, the result is applied systematically to each slide — a task that, done manually, would have required a PowerPoint master template or tedious repetitive work.

Level 4 — Expert: orchestrating complex tasks with Copilot Cowork

Copilot Cowork constitutes a separate layer, billed on a usage basis in the form of credits consumed with each prompt sent — unlike agents and skills described above, included in the standard Copilot experience. It is this separate billing model that explains still marginal adoption of this functionality.

Two use cases illustrate its ability to handle tasks too complex for a standard agent:

• Analysis of an Excel file of webinar participants (from Microsoft Teams), then automatic drafting of targeted emails towards the ten most qualified profiles, directly in Outlook.
• Exhaustive search in a mailbox of all customer notification alerts from an online learning platform (Thinkific), with automatic compilation into a templated Excel file — across several years of message history, a task deemed beyond the reach of a standard agent due to volume.

Implementation: auditing Copilot licenses and custom agents on the tenant

Before generalizing the use of agents and skills described above, a Microsoft 365 administrator should know precisely who has an active Copilot license and which custom agents (published as declarative Teams applications) are already circulating on the tenant.

The following script uses the Microsoft Graph PowerShell SDK module (Microsoft.Graph, version 2.x or higher) with read-only scopes only, in accordance with the principle of least privilege.

1# Module installation (one time only, on the administration workstation)
2Install-Module Microsoft.Graph -Scope CurrentUser
3 
4# Connection with read-only scopes only (least privilege)
5# TeamsApp.Read.All requires prior administrator consent in Entra ID
6Connect-MgGraph -Scopes "User.Read.All","TeamsApp.Read.All"
7 
8# 1. Identify SKUs (license identifiers) containing "Copilot"
9$skusCopilot = Get-MgSubscribedSku | Where-Object { $_.SkuPartNumber -like "*Copilot*" }
10 
11$skusCopilot | Select-Object SkuPartNumber, ConsumedUnits, `
12    @{Name='AvailableUnits';Expression={$_.PrepaidUnits.Enabled - $_.ConsumedUnits}}
13 
14# 2. List users with an active Copilot license
15foreach ($sku in $skusCopilot) {
16    Write-Host "--- Users under SKU $($sku.SkuPartNumber) ---"
17    Get-MgUser -All -Property DisplayName,UserPrincipalName,AssignedLicenses `
18        | Where-Object { $_.AssignedLicenses.SkuId -contains $sku.SkuId } `
19        | Select-Object DisplayName, UserPrincipalName
20}
21 
22# 3. List custom agents (declarative agents) published internally
23# in the Teams catalog, with their publication status
24Get-MgAppCatalogTeamsApp -Filter "distributionMethod eq 'organization'" -ExpandProperty "appDefinitions" `
25    | Select-Object Id, `
26        @{Name='Name';Expression={$_.AppDefinitions[0].DisplayName}}, `
27        @{Name='Status';Expression={$_.AppDefinitions[0].PublishingState}}
28 
29# Clean disconnection from the Graph session
30Disconnect-MgGraph

This script produces three usable outputs: an inventory of Copilot licenses with their consumption rate, the list of licensed users, and the catalog of custom agents published internally with their status (published, blocked, pending). No write operation is performed: it can be executed safely in production, including on a scheduled basis for monthly reporting.

Common pitfalls and troubleshooting

• A custom skill doesn't appear in the @ list: it must be activated manually via "Manage skills → Custom skills" in each Office application. Activation is never global across Excel, PowerPoint, and Word.
• Error "Insufficient privileges to complete the operation" on Get-MgAppCatalogTeamsApp: the TeamsApp.Read.All scope requires explicit administrator consent in Entra ID, unlike User.Read.All which can be consented to by the user themselves.
• Cowork credit consumption even if prompt fails: usage-based billing applies from the moment the request is sent, regardless of the relevance of the result obtained — a point to integrate into any internal governance policy.
• A skill generated by an agent produces an incorrect result on first execution: this is behavior frequently observed when automatically generating complex Markdown files. Manual review before activation remains essential.

What you need to remember

Maturity on Copilot agents is not measured by the number of agents created, but by the precision of the instructions you know how to give them. Specifically:

• Start by scheduling an existing pre-built agent rather than creating a new one — it's the fastest gain.
• Move to Agent Builder only once capable of formulating precise instructions (expected format, tone, output structure).
• Invest in writing Markdown skills as soon as Excel or PowerPoint tasks repeat every week: this is the level where return on investment is clearest.
• Enable Copilot Cowork only after framing a credit budget and identifying use cases truly beyond the reach of a standard skill.

If your organization plans to deploy at scale, run the audit script above before any training campaign: knowing exactly who has a license and which agents are already circulating avoids duplicates and ungoverned skills.