Making sense of the Microsoft Copilot ecosystem

“We use Copilot” can mean anything from summarizing an email to building an agent that carries out business tasks. Microsoft hasn’t exactly made the naming easy. In the latest article in my AI series, I work through the Microsoft Copilot ecosystem: the different assistants, where Copilot Studio fits, how agents use work data, and what identity, permissions, and licensing mean in practice. The aim is to make the pieces easier to understand before deciding what to build—or buy.
Making sense of the Microsoft Copilot ecosystem

Microsoft has put the Copilot name on enough products that saying “we use Copilot” doesn’t tell me much about what someone actually uses. It could mean chatting with AI, getting help with a spreadsheet, or asking an assistant to work on some code. Same name, different jobs. A little like discovering that every appliance in the kitchen is now called Dave.

I find it easier to understand the ecosystem by separating the products from the way they work. First, which Copilot are we talking about? Then, whose information can it access, and whose authority is it using when it does something?

Helping me work, or getting on with the work?

Before getting into the products, it helps to start with what Microsoft means by a copilot: an AI assistant working on behalf of the person using it. I bring the task, and it helps me carry it out, whether that’s drafting an email, summarizing a meeting, or working through some code. I’m actively involved in the task. The name is a useful reminder of the relationship. I haven’t handed over the aircraft; I’ve asked for help in the cockpit.

An agent can take responsibility for a more focused piece of work. It receives a goal, uses the tools available to it, and works through the steps needed to reach an outcome. Depending on its design, it might start when I ask, when an event occurs, or on a schedule.

For example, I might ask a copilot to help summarize a support request. An agent could be configured to monitor incoming requests, look for relevant guidance, and prepare a proposed response for review. Whether it can send that response or update a record is a separate design decision.

There is a distinction here that is easy to blur: acting on behalf of a user, often shortened to OBO, and operating autonomously are different concepts.

An agent can act on my behalf using delegated access. It can also run without me sitting in front of it, using permissions granted to its own identity or another explicitly configured connection.

Which Copilot are we talking about?

Copilot Chat, Microsoft 365 Copilot, and GitHub Copilot apply that assistant role to different kinds of work, even though some of those products also include agents that can take on more independent tasks.

You don’t need a Microsoft 365 subscription to start using Copilot. Microsoft offers a free consumer version for asking questions, researching topics, drafting content, and other everyday AI assistance, subject to usage and capacity limits.

For work, the distinction is easier to follow as Basic versus Premium. Copilot Chat (Basic) is included at no additional charge with eligible Microsoft 365 subscriptions. It primarily uses web information, along with content I provide, such as a document to summarize or rewrite. It doesn’t require the paid Microsoft 365 Copilot add-on, but “included with my subscription” isn’t quite the same as “no subscription required.”

Microsoft 365 Copilot (Premium) is the paid experience that adds broader grounding in Microsoft 365 data. Grounding means using relevant information to give the answer context, rather than relying only on the model’s general knowledge. It can draw on emails, meetings, chats, and files I have permission to access, and provides a fuller integrated experience in applications such as Word, Excel, PowerPoint, Outlook, and Teams, subject to configuration.

For me, the useful distinction is between “help me with this content I’ve given you” and “help me find and use the relevant information from my work.” Summarizing an uploaded document is one task. Preparing for a meeting using relevant documents, correspondence, and previous discussions is another.

When Microsoft 365 Copilot retrieves organizational information on my behalf, my access permissions define what it can retrieve. If I don’t have access to a document, asking nicely in a prompt shouldn’t change that. Neither should adding “this is very important” in capital letters.

GitHub Copilot is aimed at software development. It can help suggest code, explain existing code, develop tests, and work through changes. Its capabilities also extend into agentic workflows, so it isn’t limited to guessing what I was about to type. Occasionally, what I was about to type probably needed an intervention anyway.

These are related products, but they aren’t interchangeable. Having Microsoft 365 Copilot doesn’t automatically give me a GitHub Copilot subscription, and having a Copilot chat window doesn’t establish what business information it can access.

A Segue on Entra Identity

Before getting further into what Copilot knows about my work, it’s worth understanding how it knows who I am. The model’s general knowledge and the organizational information retrieved to answer my question are different things. When Microsoft 365 Copilot grounds an answer in work data, my identity and permissions help determine which emails, files, and conversations it can use. Two people asking the same question can therefore receive different answers because they have access to different information.

That also explains why a missing document isn’t necessarily a problem with the AI, and why an unexpectedly revealing answer might point to permissions that were already too broad. Copilot doesn’t decide that I deserve access because I’ve written a particularly persuasive prompt. Understanding identity helps explain both what information is available to it and where the boundaries should be.

Microsoft 365 uses Microsoft Entra ID for identity. Entra is where the organization’s cloud directory holds identities such as users, groups, applications, and agents. There isn’t a separate set of Microsoft 365 user accounts hiding behind Outlook.

Two terms help keep this understandable. Authentication establishes who or what is signing in. Authorizationdetermines what that identity is allowed to do. Proving that I’m Rob doesn’t, by itself, establish that I should be allowed to administer the entire organization. A reassuring limitation for everyone involved.

Some organizations create and manage their users entirely in the cloud. Others already have an on-premises Active Directory and connect those identities to Entra. In that hybrid arrangement, there are three common approaches to authentication.

Let the cloud validate the password

With password hash synchronization, or PHS, a further-derived, non-reversible hash of the on-premises password hash is synchronized to Entra. The user’s readable password isn’t copied into the cloud.

Entra can then validate password-based sign-ins in the cloud without contacting an on-premises domain controller for each one. The user can use the same password in both places, although password changes need to synchronize before the new password is available for cloud validation.

This reduces the dependency on the on-premises environment during sign-in. If that environment has an outage, cloud password validation doesn’t have to go down with it.

Ask the on-premises directory

With pass-through authentication, or PTA, Entra handles the cloud sign-in experience but uses an authentication agent to validate the password against on-premises Active Directory.

The password check therefore depends on the on-premises authentication agents and domain controllers being available. This can meet requirements to apply on-premises account restrictions during password validation, but it also keeps those systems in the sign-in path.

The “agent” here is authentication software, by the way, not an AI agent. Apparently, reusing Copilot wasn’t enough; we also needed another meaning for agent.

Trust another identity provider

With federation, Entra delegates authentication to a trusted identity provider, such as Active Directory Federation Services or another supported federation service. That provider authenticates the user and returns a trusted assertion that Entra can use to continue the sign-in process.

The distinction is where the authentication decision happens. PHS allows cloud password validation. PTA checks the password against the on-premises directory through an agent. Federation trusts a separate identity provider to authenticate the user.

These are hybrid authentication approaches, not three different permission models. They also don’t replace considerations such as multifactor authentication, passwordless sign-in, or Conditional Access. However I authenticate, the next question remains what I’m allowed to access.

Giving an agent its own identity

If an agent is going to carry out work, I want to be able to distinguish its activity from mine. Borrowing someone’s account and hoping the audit trail makes sense later is not much of an operating model.

Microsoft Entra Agent ID provides dedicated identities for AI agents. An agent identity represents software rather than a human user and gives the agent a distinct identity for authentication, access decisions, and tracking its activity.

In supported Microsoft experiences, including Copilot Studio, agent creation can provision an identity in the organization’s Entra tenant. That doesn’t mean every AI agent, wherever it was built, automatically appears in Entra. Custom implementations need an appropriate identity integration, and some workloads use established application identities or managed identities instead.

Having its own identity doesn’t give an agent unrestricted access. It still needs permission to use the relevant services and data. It can use delegated access when acting on behalf of a user, or permissions granted directly to the agent for supported autonomous work.

An identity isn’t a permission slip

Once an identity exists, we need to decide what it can do. This is where groups, roles, and scope come into the picture.

Security groups let us manage access for a collection of identities rather than maintaining every permission one person at a time. I can grant a group access to a supported resource and manage who belongs to that group.

A regular security group doesn’t need an email address. A mail-enabled security group combines access-control use with the ability to email its members. Having an address doesn’t make it a different class of super-permission; it means the group can also receive mail. A distribution group, by contrast, is for email distribution, not for granting resource access.

Microsoft 365 groups are built around collaboration. They provide shared membership for resources such as a group mailbox, calendar, and SharePoint site, and can underpin a Microsoft Team. Membership gives people access to the associated collaboration resources, but it doesn’t make them administrators across Microsoft 365.

Groups collect identities. Roles define sets of permitted actions. Scope defines where those actions apply.

In role-based access control, or RBAC, a role assignment brings those pieces together:

Give this identity or supported group this set of permissions over this particular scope.

For example, an administrator might receive a supported role assignment to manage a particular application registration rather than every application in the tenant. The role defines the permitted operations; the assignment specifies who receives them and where they apply.

There are different access-control systems across the ecosystem. Entra directory roles govern directory administration, Azure RBAC governs Azure resources, and services such as SharePoint and Dataverse have their own permission models. The general idea is similar, but the roles and assignments aren’t interchangeable. Entra administrative roles also require a group configured as role-assignable if we want to assign them through group membership; an ordinary project group isn’t automatically eligible.

For a person or an agent, start with the work it needs to perform and grant the smallest appropriate permission set at the narrowest practical scope. An agent that reads a project library and drafts a summary doesn’t need permission to reorganize the tenant. We have enough opportunities for accidental reorganization already.

Building an agent with Copilot Studio

With identity and permissions covered, we can return to building something useful. Microsoft Copilot Studio is a low-code environment for creating and managing agents, connecting them to information and tools, and making them available where people work. It provides the authoring tools and a managed platform to run the agent; it isn’t just a text box connected to a model.

A starting point is to describe the agent in everyday language. For example: “Help employees find approved onboarding guidance and prepare a checklist for their first week.” Copilot Studio can use that description to generate an initial agent configuration, which can then be reviewed and refined. Describing the job gets things started. It doesn’t mean the job description is finished, much as “other duties as assigned” has never been a complete operating manual.

Give it a job and the information to do it

The instructions define the agent’s purpose and how it should behave. They should explain what it handles, what falls outside its remit, and what to do when it doesn’t have enough information. For the onboarding example, that might mean answering from approved guidance, identifying the source, and referring unanswered policy questions to a person rather than inventing an impressively confident policy.

Knowledge sources provide the information the agent can draw on. Depending on the agent and configuration, these can include SharePoint content, uploaded documents, websites, and supported business data sources. Connecting a source gives the agent material to retrieve and use when answering; it isn’t the same as retraining the underlying model on those documents.

This pattern is called retrieval-augmented generation, or RAG. When a question comes in, the system retrieves relevant information from connected sources and provides it to the model as context for generating an answer. For our onboarding agent, that could mean finding the approved first-week guidance and using the relevant passages to prepare a checklist, rather than relying on the model’s general training. Think of it as an open-book answer, although having the book available doesn’t guarantee that the answer is correct.

RAG helps ground a response in organizational information, but it doesn’t fix outdated documents, resolve contradictory policies, or replace access controls. The retrieval configuration and permissions still determine what information can be brought into the answer.

Start with a focused set of current, authoritative content. An onboarding agent doesn’t need every document the organization has ever produced, especially the three contradictory versions of the same procedure that everyone promises to tidy up next quarter.

Give it tools when it needs to act

Knowledge helps an agent answer questions. Tools let it do something with the answer or interact with another system. Copilot Studio supports connections through built-in capabilities, connectors, and flows, with custom integrations where needed.

The onboarding agent might begin by producing a checklist in the conversation. A connected tool could let it create the checklist in a business application or submit a request. Those are additional capabilities to configure deliberately, not automatic consequences of giving the agent some documents.

Some interactions benefit from defined topics and structured steps, such as collecting required details before submitting a request. Others can use generative orchestration, where the agent selects appropriate knowledge and tools based on the request and its instructions. The available options depend on the agent’s underlying execution engine and configuration.

For autonomous work, a supported trigger can start the process when an event occurs or on a schedule. That still leaves decisions about what the agent may do without review, when it must ask for approval, and when it should stop or escalate. “Autonomous” describes how the work starts and proceeds, not an exemption from supervision.

Where pro-code fits

Low-code doesn’t mean developers have to leave their code editor at the door. Pro-code development fits alongside Copilot Studio in two useful ways: editing the agent’s definition as code and building custom capabilities for the agent to call.

Microsoft’s Copilot Studio extension for Visual Studio Code supports working locally with agent definitions for agents using the standard execution engine. Developers can clone an agent, edit its YAML components, track changes in Git, and review them through pull requests before synchronizing changes back to a Copilot Studio environment. It’s another way to author the same agent; Copilot Studio still provides its managed runtime. Opening the files in VS Code doesn’t move the agent onto the laptop.

The other approach is to write custom services in languages such as C#, TypeScript, or Python and expose them through an API, custom connector, or supported MCP integration. Our onboarding agent could collect the required details in Copilot Studio, then call a custom service to validate them against a business system or carry out a provisioning task. That service runs wherever it is deployed, such as an Azure Function, and needs its own security, testing, and operational support.

In short, developers can work on the agent as code, or build code the agent uses as a tool. These approaches can be combined: keep the conversation and agent management in Copilot Studio, use developer workflows to maintain its definition, and add custom code where the business requirements call for it.

Test the behavior before sharing it

Copilot Studio provides a test experience for trying the agent while developing it. Check ordinary requests, ambiguous questions, missing information, and attempts to push it beyond its intended job. Where the agent uses restricted information or takes actions, test with representative user accounts as well; a successful test under the creator’s account doesn’t establish that everyone else’s access is correct.

For the onboarding example, useful checks include whether the agent finds the current procedure, acknowledges when guidance is missing, and refuses to submit a request until the required information and approvals are present. A friendly response is pleasant. A correct response that stays within its remit is more useful.

Publishing makes a version of the agent available for use, and supported channels determine where people interact with it, such as Microsoft 365 Copilot, Teams, or a website. The intended audience, authentication, organizational policies, and licensing need to match the deployment. Publishing and granting access are related steps, but they aren’t the same thing.

Once people start using it, review the results and refine the instructions, knowledge, and tools. Creating an agent can begin with a short description. Making it dependable takes the same attention to requirements, testing, and maintenance as any other business application.

Graph, Work IQ and the Semantic Index

Connecting an agent to a document library is one thing. Helping Copilot find the right information across our working day is a broader problem. A decision might be in an email, the explanation in a Teams conversation, and the supporting document in SharePoint. Naturally, the meeting invitation contains a link to an older version.

Microsoft Graph, the Semantic Index, and Work IQ help address different parts of that problem. They work together, but they aren’t interchangeable names for the same capability.

Graph connects the information

Microsoft Graph provides a common way for applications to access data and capabilities across Microsoft 365 and other Microsoft cloud services. Its API, or application programming interface, exposes resources such as people, messages, calendar events, files, and teams, along with relationships between them.

That matters because work rarely sits neatly inside one application. A calendar event has attendees. Those attendees have organizational profiles. A file has an author and people it has been shared with. Graph makes those resources and relationships available through a consistent interface, subject to authorization.

Graph isn’t a giant folder containing a second copy of everything, and it isn’t itself the language model. It’s a gateway to the underlying services and their data. For Copilot, that provides access to work information and signals that help establish context: which people, documents, and conversations are relevant to the request.

The Semantic Index helps find the meaning

Access to information doesn’t automatically make it easy to find. If I ask for “the guidance for a new employee’s first week,” the relevant document might be called “Staff induction procedure.” An exact phrase match could miss a useful answer because the writer and the reader chose different words.

Semantic indexing helps retrieve information by meaning as well as by keywords. It uses numerical representations called vectors to capture aspects of the meaning of supported content, allowing retrieval to find material that is conceptually related to a question even when the wording differs. Traditional keyword matching still has a role; semantic retrieval complements it rather than making exact names and terms obsolete.

In Microsoft 365 Copilot, the Semantic Index works with Microsoft Graph to help locate relevant organizational information for grounding. This connects back to RAG: the index helps find useful source material, and that material can then become context for the model’s answer. The index isn’t the model, and indexing a document doesn’t train the model on it.

Nor does it grant access to the document. Results still need to respect the user’s existing permissions. Better discovery can make already-accessible information easier to uncover, which is another reason to get sharing permissions right.

Work IQ brings the work context together

Work IQ is Microsoft’s workplace intelligence layer for Copilot and agents. It brings together organizational information, context, and tools so the system can reason over work rather than treating every request as an isolated question. It builds on the Microsoft 365 information foundation; it doesn’t replace Graph or simply rename the Semantic Index.

Microsoft describes Work IQ in terms of data, memory, and inference. Data supplies signals from sources such as files, email, meetings, and chats. Memory supports continuity around how people and teams work. Inference uses models and tools to draw on that context, work through a request, and take supported actions. Here, “memory” means retained context within the supported experience, not a promise that every agent remembers every interaction forever.

Consider a request such as “Help me prepare for the onboarding meeting tomorrow.” Useful assistance could involve identifying the meeting and attendees, finding the approved guidance, and bringing in relevant discussion about the new employee’s arrangements. Graph provides access to resources and relationships. Semantic retrieval helps locate relevant material even when the wording differs. Work IQ provides the broader contextual capabilities that help Copilot or a connected agent assemble and use that information.

Work IQ can also expose work context and actions to custom agents through supported interfaces. In Copilot Studio, the available integration depends on the agent’s execution engine and configuration; adding an ordinary knowledge source isn’t the same as enabling Work IQ. Its scope and permissions still need to match the job the agent is meant to perform.

The distinction is useful when designing a solution. Calling a Graph API, retrieving passages for a RAG answer, and using Work IQ’s contextual capabilities solve related but different problems. Choose the capability that fits the work, rather than assuming that connecting to Microsoft 365 gives an agent every kind of organizational intelligence at once.

Understanding Copilot licensing

Copilot licensing depends on which product we’re using and what we’re asking it to do. There isn’t one universal Copilot license that covers the assistant, every agent, and all the services behind them. Some capabilities are included with an eligible subscription, others need a separate per-user license, and agent activity can introduce usage-based charges. Before comparing prices, separate the cost of giving someone access from the cost of the work an agent performs.

Copilot Chat

For work, Microsoft 365 Copilot Chat is available at no additional charge with an eligible Microsoft 365 subscription. Users don’t need the paid Microsoft 365 Copilot add-on for that baseline chat experience. The organization still pays for the underlying subscription, so “included” is more accurate than “Microsoft has stopped sending invoices.”

That included experience provides web-grounded chat with enterprise data protection, subject to applicable usage limits. It doesn’t include the paid offering’s broader grounding across the user’s Microsoft 365 work data. Using configured agents can introduce separate usage charges, so access to Chat shouldn’t be mistaken for an unlimited agent budget.

The free consumer Microsoft Copilot is a separate offering and doesn’t require a Microsoft 365 subscription. It shouldn’t be treated as interchangeable with the organization’s work-account experience when handling business information.

M365 Copilot Premium/Paid

The paid offering has variants for small businesses and enterprises. Microsoft 365 Copilot Business is designed for organizations with up to 300 users on eligible Business plans, while enterprise licensing serves larger organizations and those on eligible enterprise plans.

Microsoft 365 Copilot’s paid, or Premium, experience adds broader grounding in the user’s work data through Microsoft Graph and Work IQ, along with the full Copilot experience in supported Microsoft 365 apps. That means assistance informed by accessible emails, meetings, chats, and documents, rather than relying mainly on web information or material supplied in the conversation. Permissions still apply; buying a license doesn’t promote anyone to chief reader of everybody else’s inbox.

The license is assigned to a person. It provides that user’s paid Copilot entitlement, including qualifying assistive custom-agent use under the applicable terms and usage limits; it doesn’t provide unlimited execution for every agent or advanced AI capability. Separately metered activity still needs its own funding arrangement. The distinction is between licensing the person to use Copilot and paying for agent work that falls outside that entitlement.

Per user, per month means a recurring subscription charge for each licensed person, expressed as a monthly rate. It isn’t a charge for each prompt, and a monthly rate doesn’t necessarily mean a month-to-month contract: the commitment and payment schedule depend on the purchased plan.

Pay as you go means charges based on actual metered consumption, such as billable agent activity, rather than a fixed license charge for each person. It can sit alongside the paid Microsoft 365 Copilot subscription for capabilities outside its included entitlement; it isn’t simply another payment schedule for the same user license.

Copilot Studio

With Copilot Studio, separate access to build and manage agents from the capacity needed to run them. A maker needs an appropriate license or authoring entitlement, along with the required environment permissions.

Billable activity is measured in Copilot Credits. Organizations can fund it through prepaid credit subscriptions, pay-as-you-go billing linked to an Azure subscription, or an eligible prepurchase arrangement. Prepaid subscription capacity provides a monthly allowance, with unused monthly credits not rolling forward. Pay as you go charges for actual metered consumption instead of requiring that monthly capacity purchase.

Credits aren’t simply a count of people, agents, or conversations. For agents using the standard execution engine, different operations, such as generating an answer, grounding it in organizational information, or taking an action, can consume different amounts. One request can involve several billable operations. Other execution engines have their own metering rules, so estimate usage against the type of agent being deployed rather than assuming every chat costs the same.

A paid Microsoft 365 Copilot license can cover qualifying agent usage in supported Microsoft 365 experiences, subject to the applicable terms and limits. It doesn’t add credits to the organization’s shared capacity pool or cover every autonomous process and advanced capability. Equally, making a standalone agent available in Teams doesn’t automatically make its usage included for everyone.

Who needs a license, and whose credits are used?

Take our onboarding chatbot, built in standalone Copilot Studio using the standard execution engine and published to Teams. In a prepaid subscription setup, the organization holds the Copilot Studio tenant subscription and assigns the developer a Copilot Studio User License, together with the required environment permissions. A pay-as-you-go setup can instead use the supported Copilot Studio authors access arrangement. The developer doesn’t universally need the paid Microsoft 365 Copilot add-on just to build this standalone bot.

The employee asking the bot a question doesn’t need a Copilot Studio maker license. They need access to the bot and Teams, and appropriate permissions for any protected information the bot retrieves on their behalf. Whether they have a paid Microsoft 365 Copilot license then helps determine how qualifying interactions are funded.

If the employee has ordinary Microsoft 365 access but no paid Copilot entitlement, billable operations draw against the organization’s applicable Copilot Studio capacity allocation or its configured Azure-linked pay-as-you-go arrangement. This isn’t a personal allowance attached to the developer. Publishing the bot to Teams doesn’t change that funding responsibility.

If the employee has a paid Microsoft 365 Copilot license, qualifying employee-facing usage can be included when the bot operates using that authenticated user’s identity, subject to the applicable terms and fair-use limits. Those included operations don’t deduct billed credits from the organization’s shared pool. The developer’s license alone doesn’t extend that entitlement to everyone who uses the bot.

Start with the work

I find the Copilot ecosystem easier to follow when I stop treating the name as the specification. An assistant helping with a document, an agent carrying out a business task, and the platform used to build that agent have different responsibilities. Understanding those differences makes it easier to choose what belongs in a solution and what doesn’t.

Start with a task people actually need help with. Decide which information is authoritative, whose identity the solution will use, and which actions need human approval. Then choose the tools and confirm that the licensing covers the intended audience and workload. A successful demonstration under the developer’s account is a starting point, not evidence that the solution is ready for everyone.

For the onboarding example, a sensible first release might simply help employees find approved guidance and prepare a useful checklist. Test that with the people who will use it before adding provisioning tools or unattended processing. Expand its responsibilities when the results justify it, rather than because another capability has appeared in the menu.

That’s the approach I’m taking to Copilot and agents: understand the pieces, give them a useful job, and check the work. The product names will keep changing. Knowing what the system can access, what it can do, and who remains responsible gives us a more durable basis for deciding whether it belongs in our working day.


Write a comment