Copilot Studio Blog articles

Computer-using agents in Microsoft Copilot Studio are now generally available

MustaphaLazrek — Wed, 13 May 2026 17:28:08 GMT

The next chapter of enterprise AI isn't about chatting with assistants—it's about agents that actually do the work. Until now, automating long-tail, UI-driven business processes meant either building and maintaining brittle RPA scripts or waiting on APIs that legacy systems were never going to expose.

That gap has kept some of the most valuable workflows—the ones buried in vendor portals, internal web apps, and proprietary line-of-business systems—out of reach for modern automation. For enterprise IT teams, the challenge hasn’t just been automating these workflows. It’s been doing so in a way that remains secure, governable, and scalable across the business.

The gap is now closing. Computer use in Microsoft Copilot Studio is now generally available, and we're expanding availability to all commercial geographies in Microsoft Power Platform.

New computer use features generally available

With this release, every Copilot Studio maker can build agents that don't just reason and respond—they take action directly inside any application a person can use. For IT teams, GA represents more than a new automation capability; it’s a shift toward a more governable and enterprise-ready model for AI-driven work. Organizations can better standardize how agents operate across applications while maintaining security, observability, and administrative control through the Power Platform admin center.

With this release, computer use delivers:

Global availability across all commercial Power Platform geos, so customers in every region can deploy computer use in agents under their tenant's data residency and compliance boundaries.
Secure authentication with built in credentials and Azure Key Vault when signing in to website or desktop applications.
Enterprise governance built in, allowing lists for websites or desktop applications and native Power Platform governance capabilities such as DLP policies, environment isolation, and audit trails.
Human-in-the-loop checkpoints for low-confidence steps, exceptions, and decisions that require an operator's approval.
Run history and observability, so makers and admins can see exactly what the agent saw, what it clicked, and why. Logs are also propagated to Purview and Dataverse for audits and admin review.
Model choice for your agents, with models from OpenAI and Anthropic.

Add computer use as a tool in a Copilot Studio agent

Reach every system, including the ones without APIs

Computer use gives an agent the same tools a person has: a browser, a screen, a keyboard, and the ability to read what's on the page and take the next logical step. Instead of brittle selector-based automation, the computer use tool uses vision and reasoning to navigate live UIs—adapting when layouts shift, fields move, or workflows branch.

For organizations with deep investments in proprietary platforms or third-party portals, this changes the math on automation. Workflows that previously required either a multi-quarter integration project or an army of contractors clicking through screens can now be handed to an agent.

For enterprise IT organizations, this can also reduce pressure to modernize or rebuild every legacy workflow before automation can begin. That helps teams extend the value of existing systems while still moving toward broader AI transformation goals.

Customer spotlight: Graebel automates global service order processing end to end

Graebel, a global leader in talent mobility with approximately 1,500 employees, manages thousands of cross-border employee relocations every year for multinational clients. A significant share of those relocation requests arrives the way most enterprise work arrives: as free-form emails, full of unstructured instructions, attachments, and edge cases. Each email had to be read, interpreted, and entered by hand into Graebel's proprietary Global Connect platform.

Global Connect couldn’t support a API-based integration, and earlier robotic process automation (RPA) attempts proved too rigid to keep up with the variability of human-written emails. Graebel needed automation that could use reasoning, not just click.

Working with GET AI and Microsoft, Graebel built and deployed the Graebel Service Order Agent, equipped with computer use, in Microsoft Copilot Studio. The agent now:

Monitors designated mailboxes and interprets unstructured service-order emails using Azure Content Understanding, extracting key data into structured form with confidence scoring.
Validates each request against Graebel's business rules, service logic, and compliance requirements before any action is taken.
Operates Global Connect directly through its UI—navigating screens, entering data, and completing transactions exactly as a trained human operator would, without APIs or platform redevelopment.
Escalates exceptions and low-confidence cases through human-in-the-loop workflows, preserving governance and service quality.

Architecture of Graebel’s Power Automate flow and custom Service Order agent

“By adopting Microsoft Copilot Studio and AI agents, we’ve moved beyond traditional automation to a more intelligent, scalable operating model. This initiative strengthens our ability to serve clients faster and more accurately while positioning Graebel for long-term growth.” - Matt Brownlee, Chief Revenue Officer, Graebel

The Service Order Agent is live today and processing real volume, with an architecture designed to scale across more than 30 relocation service categories. For Graebel, the results include a meaningful reduction in manual effort, faster service-order turnaround, more consistent data quality, and a repeatable blueprint for bringing intelligent automation to the rest of their operations.

Read how Graebel drives growth and automation with Power Platform and Copilot Studio.

How to get started

Ready to try computer‑using agents in Copilot Studio?

Create or open an agent in Microsoft Copilot Studio.
Go to Tools → Add tool → Add new computer use.
Describe the task you want the agent to perform in natural language.

For deeper guidance, configuration details, and best practices, see the computer use documentation.

Before you go: We’re actively investing in advanced governance, operations, and scale for CUAs—and customer feedback directly informs the roadmap. Tell us what you think of the latest CUA updates today:

Email feedback to computeruse-feedback@microsoft.com
Join the Copilot Studio community

4 ways to build a curated Agent Store and scale agent adoption

AnnaCao — Tue, 12 May 2026 17:00:00 GMT

The agent adoption gap is real

Agents are quickly becoming a core part of enterprise AI strategy. The 2026 Work Trend Index shows 58% of employees are now producing work they couldn’t do a year ago, and AI is increasingly used for analysis, reasoning, and decision-making—not just tasks. While individual capability is accelerating, many organizations are struggling to keep up. The gap isn’t access to AI—it’s how work is designed around it.

In customer conversations, we consistently hear three blockers:

Where do we start? The catalog of AI solutions is expanding faster than most organizations can evaluate.
What can we trust? Without a curated channel, every new agent introduces security, compliance, and data governance work—slowing adoption.
How do we drive adoption? Even a great agent delivers zero value if employees don’t discover it or embed it in daily workflows.

Find and use agents from the Agent Store

Agent Store is a curated hub in Microsoft 365 Copilot where users can discover, install, and use agents directly in the flow of work. It brings together agents built by Microsoft, trusted partners, and your own teams, making them accessible across Microsoft 365 surfaces including Teams, Outlook, Word, Excel, and PowerPoint. It provides:

One central place to find agents from Microsoft, trusted partners, and your own teams.
Personalized discovery experience that surfaces relevant agents based on each user’s work context.
Fully vetted third-party agents designed to help you adopt with confidence.
IT-administered control and oversight on store catalog curation and management.

Agent Store homepage, showing a variety of available agents

4 pathways to a curated store: start where you are

There isn’t a single path to populate your catalog. Most organizations use more than one approach based on their goals and business needs:

Deploy pre-built agents from Microsoft and verified partners. This is the fastest route to get started with a new agent, with no development effort required.
Build agents and distribute through Agent Store using Microsoft Copilot Studio for faster time to value, or the Microsoft 365 Agents Toolkit and Agents SDK for pro-code development and deeper control.
Bring your own agents. If you’ve already built on Microsoft Foundry, third-party AI platforms, or custom code, you can still onboard them through the Microsoft 365 Agents Toolkit and SDK so they’re discoverable in the Agent Store.
Integrate with the Microsoft Agent 365 SDK to add enterprise capabilities such as Entra-backed identity, governed Microsoft 365 data access, observability, and cross-surface notifications without a full rebuild.

New Agent Store whitepaper available

To help organizations move from AI experimentation to scaled adoption, the new Agent Store whitepaper is now available for download. If you’re responsible for agent adoption strategy, governance, and scaled deployment, the new guide walks through the “why,” the “what,” and the “how.” It includes:

The business case for a curated, governed Agent Store.
A walkthrough of the Agent Store user experience.
Step-by-step IT deployment guidance for the four pathways.
Getting-started recommendations to help you move from exploration to impact.

Get the guide

Download the Agent Store whitepaper

More resources:

Documentation: Set up Agent Store in Microsoft 365 Copilot — Microsoft Learn
Agent Store Partner Guide
Administering and Governing Agents whitepaper

NEW UPDATES: Administering and Governing Agents whitepaper v3.2

Joe_Unwin — Mon, 11 May 2026 19:50:47 GMT

As AI agents move from pilot to production across organizations of every size, the question IT administrators are asking isn't just "How do we build agents?" It's "How do we govern them, at scale, without slowing the business down?"

That's exactly what the Administering and Governing Agents whitepaper is designed to help with. Downloaded more than 65,000 times by IT practitioners worldwide, it has now been updated to Version 3.2. Today you’ll find new and updated guidance that includes security and observability of your agents with Microsoft Agent 365, as well as discoverability of agents with the Microsoft 365 Agent Store. Additionally, there is new guidance on zone-based governance strategies, agent sharing controls, and agent owner reassignment.

As you continue to investigate, evaluate, or deploy agentic AI for your organization, keep this updated whitepaper on hand.

Why governance matters more than ever

Agents are being built by IT professionals, developers, and makers alike, using Microsoft Copilot Studio, Agent Builder in Microsoft 365 Copilot, and Microsoft Foundry. With that growth comes real accountability. Organizations carry responsibility for the agents they deploy—including how the agents access data, how they behave, and whether they comply with organizational and regulatory standards.

Governance can't be an afterthought. It needs to be built into the foundation from the beginning. As a long-time authority on security and governance, you can trust Microsoft to keep you updated with the information you need to run a secure agent ecosystem.

What the whitepaper covers

The Administering and Governing Agents whitepaper is designed specifically for IT practitioners and IT decision-makers in SMBs and large enterprises. It provides a structured, practical framework for securing and governing agents across the full Microsoft 365 ecosystem, from initial creation through deployment, monitoring, and ongoing management.

A governance framework built on three pillars

Effective governance starts with fundamentals. The whitepaper organizes core governance principles into three pillars: Policy, Process, and People.

Figure 1 Governance pyramid

No set of tools on their own can replace a clear governance strategy and disciplined processes, but the right tools make it far easier to operationalize those practices at scale.

Zones: a zonal tiered path to governance maturity

One of the most practical elements of the whitepaper is its zoned governance model, a structured framework that maps agent risk and technical complexity to three distinct governance levels, implemented as Environment Groups with the Copilot Studio admin controls. This model is designed to help IT teams adjust governance practices as agent risk evolves, enabling more intentional selection of controls over time while also still supporting early experimentation.

Zone 1: Personal productivity

The entry point. Agents assist with personal tasks, interact with Microsoft Graph data, and are confined to individual use. Security and sharing are tightly constrained by default, with connector access limited to approved Microsoft Enterprise plan and Copilot Studio core connections.

Zone 2: Team collaboration

Builds on Zone 1 with stricter connector controls, scoped Microsoft Entra security group access, and support for departmental agents. Editor access can be granted for collaborative development, but sharing remains governed and limited to internal channels.

Zone 3: Enterprise managed

The advanced tier for mission-critical or organization-wide agents. Managed by central IT or a Center of Excellence (CoE), with formal ALM pipelines, phased rollout controls, Sentinel integration, and the most rigorous security and compliance requirements.

Figure 2 Zonal Governance

Taken together, the zoned model gives organizations a practical way to govern agents as they grow. This methodology provides a clear path to go from individual experimentation to enterprise‑managed deployments without constantly redefining governance expectations. The whitepaper will show you how these zones map to real controls IT teams can apply over time.

Read the whitepaper

Governance pillars in depth

The whitepaper walks through three governance pillars applied consistently across each zone: Security controls, Management controls, and Agent Reporting.

Security controls span the Copilot Studio data policies, Microsoft 365 admin center, SharePoint Online permissions, Microsoft Purview (DLP, Insider Risk Management, Communication Compliance, eDiscovery, Audit), and Microsoft Sentinel for enterprise-grade threat detection.

Management controls cover environment provisioning, Managed Environments, Application Lifecycle Management (ALM), pipelines, connector management, and agent publishing controls.

Agent reporting is delivered through four experiences: Inventory, Monitoring, Security, and the Copilot hub, alongside Microsoft Purview for cross-tenant data security and compliance reporting.

Each of these pillars is explored in detail throughout the whitepaper, covering how to configure controls, interpret reporting signals, and apply governance continuously as your agent deployments grow in scale and complexity.

The Agent Store as a governed distribution point

The whitepaper also highlights the Microsoft 365 Copilot Agent Store as a discovery and access point for agents. It covers distribution paths for Microsoft-built, partner-built, custom Copilot Studio, Teams Toolkit, and Agent 365 SDK-enabled agents, and how IT administrators maintain control over what is available and to whom. This is an area we've heard about consistently from admins, partners, and the field. Who gets access to which agents, and how IT stays in control of that, matters.

Figure 3 Agent Discoverability via Agent Store

Summary: What's new in Version 3.2

This update brings three focused changes.

Agent Store as a governed entry point: New coverage of the Microsoft 365 Copilot Agent Store as a discovery and access point for agents, including distribution paths for all five agent categories and how IT administrators maintain control at every stage.
A365 security and observability: Guidance has been introduced, covering onboarding and critical steps for maintaining visibility and security for agent activity across the tenant.
Terminology and graphics updates to comply with name changes and enhancing visuals.

Get started

If you are just starting your agent governance journey or looking to put a more robust framework in place, the updated Administering and Governing Agents whitepaper (Version 3.2) is a practical, comprehensive resource for IT teams managing agents in Microsoft 365.

Download the whitepaper to start building governance that scales with your agents and your business.

Read-only analytics access and custom metrics now available in Microsoft Copilot Studio

Eran_Manor — Tue, 05 May 2026 20:25:38 GMT

Turning Copilot Studio analytics into clear business insight

As organizations scale their use of AI agents, IT teams face a familiar dilemma: How do you give stakeholders the insight they need—without compromising proper oversight?

Expanding access to analytics can mean granting permissions beyond what’s appropriate for a given role. Meanwhile, locking things down preserves control…but creates bottlenecks to information. This forces teams to rely on a small group of people to export and share data across multiple tools just to answer basic questions on analytics—let alone dig into data that truly demonstrates how effective your agents are.

So how can your team get the most relevant, important agent metrics to the right people with the right level of access? Microsoft Copilot Studio now offers two new analytics capabilities that address this need directly:

- Analytics Viewer role, which allows an agent owner to grant read-only access to an agent’s Analytics page.

- Custom metrics, which gives teams the flexibility to add and track specific outcome-based measures aligned to their particular goals for an agent.

The Analytics Viewer role in Copilot Studio

The Analytics Viewer role provides view-only access to an agent’s Analytics page, without permission to edit, configure, publish, or share the agent.

Now generally available, it enables analysts and stakeholders to monitor agent performance securely without affecting agent behavior.

. When you share an agent with Analytics Viewer permissions:

Users get access only to the Analytics page.
All other agent pages, actions, settings, test panels, and publishing experiences are hidden and unavailable.
Analytics Viewers currently can’t define or update custom metrics and savings.

Tip:
For deeper investigation and root-cause analysis, consider granting analysts the Dataverse Bot Transcript Viewer role. This allows Analytics Viewers to drill into the transcripts for detailed analysis.

See the new Analytics Viewer option in the agent sharing experience:

Who should use the Analytics Viewer role in Copilot Studio?

Analytics Viewer is designed for users who need visibility without authoring access. This includes analysts, product owners, business stakeholders, and operations teams that monitor agent performance, trends, and issues.

This feature supports clear separation of duties: IT pros and admins manage agents, while analysts consume insights and investigate performance.

Analytics page for Analytics Viewers:

Why the Analytics Viewer role matters

For many organizations, access to analytics has been a major blocker for adopting agents in production. It’s understandable. Teams often need production insights, but only a small set of users should be able to change production agents.

Until now, customers have typically exported analytics for offline analysis or built custom reporting outside Copilot Studio. With the Analytics Viewer sharing role, agent owners can share analytics safely—without expanding edit permissions.

Not only does this expand access to insight while maintain proper oversight, it removes a key point of friction, helping teams keep tools streamlined and reduce time to information:

Stakeholders can access analytics directly, on demand, without relying on exports or intermediaries.
Teams can grant visibility more broadly, with permissions scoped appropriately to each role.
Business and product stakeholders can monitor performance that updates after every use, helping them make quicker decisions.

This shift allows analytics to function as a shared, operational capability across teams, while allowing IT and admins to maintain confidence that governance standards are upheld.

“The Analytics Viewer role allows us to provide meaningful performance insights to business and operational stakeholders while maintaining strict production governance. It cleanly separates operational visibility from agent configuration and publishing rights.”

Mohamed Arhab

Solution Architect, City of Montreal

Learn more about the Analytics Viewer role here.

Custom metrics: measure the outcomes your business cares about

As agents become part of business workflows, analytics must move from usage to impact. Standard metrics show activity but don’t answer the key question: did the agent achieve the desired business outcome?

Custom metrics in Copilot Studio shift analytics from activity to business outcomes - helping you understand not just usage, but the results agents deliver. They enable evaluation in business terms, supporting ROI, decision making, and stakeholder alignment.

Define success in your own terms

With custom metrics, now available in public preview, you define success in terms your business understands. Custom metrics are calculated by analyzing agent conversations.

You describe:

The outcome you want to measure.
The set of allowed result categories that represent that outcome.

These results are classification-based. For example, outcomes might be:

Ticket deflected or Not deflected.
Goal completed correctly, Completed with issues, or Not completed.
Converted or Not converted.

Based on your definition, Copilot Studio automatically generates the prompt that will be used to evaluate agent conversations. This helps keep evaluations consistent, while maintaining the focus on business meaning rather than technical implementation.

Clear, actionable results provided by custom metrics

Each conversation with an agent maps to exactly one outcome category that you define for it. This classification-based approach makes results:

Easier to interpret, because outcomes are explicit.

Easier to explain to stakeholders, because they map to business language.
Easier to act on, because teams can see clear outcome distributions rather than abstract scores.

As examples of clear, actionable results, consider the sample use cases from before:

Ticket deflection: Understand how effectively (how often, by percentage) an agent resolves issues without escalating to human support.
Goal completion quality: Evaluate whether users are achieving the intended business outcome successfully (yes/no).
Sales conversion: Measure how often interactions lead to a qualified outcome or purchase (by percentage or number).

When used thoughtfully, these outcome classifications become a shared language across teams, helping organizations operate agents with greater confidence and clarity as they scale.

How custom metrics help teams operate more effectively

Custom metrics shift agent Analytics pages from being purely a reporting tool to becoming an operational decision-making tool.

Teams can align early on what “good” looks like, using a common definition of success across product and business stakeholders. When performance is evaluated based on outcome distributions—not isolated signals—it’s easier to understand what’s working and what isn’t in your agents.

Over time, this helps facilitate a more intentional approach to agent fine-tuning and iteration:

Teams can see how changes to an agent affect real outcomes.
Decisions can be tied directly to business impact.
Leaders can use measurable results to prioritize investment decisions.

As agents take on more responsibility, this outcome-first model becomes essential for scale because teams need a clear, consistent way to measure impact, align decisions, and confidently expand what agents are trusted to do.

Learn more about custom metrics, now in preview, here.

The right insights for the right people

Individually, the Analytics Viewer role and custom metrics solve different challenges. Together, they help reshape how teams work with analytics and create more value. Analytics Viewer makes it possible to share analytics safely, without expanding access beyond what’s secure and sensible. Custom metrics help ensure your business can measure what you care about.

The result is a better balance between insight and oversight—a fulcrum where visibility can scale across teams without introducing new governance risks. As agents become a core element of business workflows, this combination helps organizations measure impact, demonstrate ROI, and operate agents with greater accuracy and confidence to expand.

That’s the direction Microsoft Copilot Studio continues to move toward: helping organizations not just build and deploy agents, but analyze them with clarity, confidence, and control at scale.

Explore Analytics Viewer and custom metrics in Copilot Studio today to start bringing the right metrics to the right people—at the right level of access.

Work IQ API public preview: Build Copilot powered agents with A2A

tolgaki — Mon, 11 May 2026 19:44:43 GMT

Today, the Work IQ API is available in public preview, expanding access to the same underlying intelligence capabilities used by Microsoft 365 Copilot for developers and partners.

Work IQ gives developers programmatic access to Copilot so you can build agents and apps that use Copilot’s grounding, context, and reasoning without wiring raw data or permissions. In this public preview, that access is exposed in three formats—Agent‑to‑Agent (A2A) for agent collaboration, Model Context Protocol (MCP) for IDEs and tools, and REST for app integrations—letting you choose the right surface for your scenario while relying on the same intelligence runtime.

Work IQ continuously builds context through memory and a semantic index across organizational data, Microsoft 365, line‑of‑business systems, and external sources. The result is a unified foundation for building agents, applications, and workflows grounded in how work actually happens, with enterprise‑grade security and governance built in by default.

With the Work IQ API, developers build on permission‑aware intelligence—context, intent, signals, and skills—so applications and agents understand what’s in motion, what’s been decided, and what needs attention next.

For developers, this means:

No raw data wiring: Work with intelligence instead of directly accessing emails, files, or chats.
No orchestration overhead: A single runtime handles context assembly, grounding, skill selection, and tool invocation.
No security rework: Enterprise compliance, governance, and access controls are inherited automatically.

Where Work IQ API is available

Work IQ API meets developers where they are, supporting four protocols that share the same underlying intelligence runtime. This means that the behavior, grounding, and response quality stay consistent across every surface.

Model Context Protocol (MCP) — local server (available now): Works with GitHub Copilot through the Work IQ CLI, giving MCP-compliant agents governed access to organizational context as tools and resources directly from their IDE or CLI workflow.
Agent-to-Agent (A2A), new in this public preview: A cloud-hosted protocol that enables custom agents to interact directly with Copilot intelligence as a peer—delegating work, receiving grounded responses, and maintaining context across interactions.
REST (coming May 2026): Standard request/response access to Work IQ intelligence for applications and integrations that don't require streaming or agent-to-agent coordination.
Model Context Protocol (MCP) — remote server (coming May 2026): A hosted MCP server exposing a standard set of tools and skills for interacting with M365 data, so any MCP-aware surface can connect to Work IQ without running a local server.

What’s new: Agent-to-Agent (A2A) protocol

This public preview introduces the Agent‑to‑Agent (A2A) protocol, which allows custom‑built agents to interact directly with the intelligence layer behind Copilot. Over time, A2A will expand to support collaboration across a broader set of agents and tools that support A2A or MCP, meaning agents can work together with specialized, organization‑aware capabilities.

With A2A, agents communicate as peers. Rather than calling a traditional API and parsing a response, an agent can delegate work to another agent running on Work IQ—an agent with access (subject to the user’s and tenant’s permissions) to organizational context across emails, meetings, files, and conversations—and receive responses that are grounded in enterprise data and governed by the same security and compliance policies.

Here’s what that looks like in practice: a single A2A message sent to a Copilot agent using standard .NET A2A SDK:

var credential = new InteractiveBrowserCredential(clientId);
        var token = await credential.GetTokenAsync(new (["api://workiq.svc.cloud.microsoft/WorkIQAgent.Ask"]));
        var httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", token.Token);

        // Create an A2A client that talks to the default WorkIQ agent endpoint, using the authenticated HttpClient
        var client = new A2AClient(new Uri("https://workiq.svc.cloud.microsoft/a2a/"), httpClient);

        // Compose a query
        var question = "What meetings do I have tomorrow that I need to prepare for?";

        // Send the query and WorkIQ returns an A2A task that when complete will contain
        //  a grounded, permission-trimmed answer
        var response = await client.SendMessageAsync(new SendMessageRequest
        {
            Message = new Message
            {
                MessageId = Guid.NewGuid().ToString("N"),
                Role = Role.User,
                Parts = [Part.FromText(question)]
            }
        });

Developers can rely on Work IQ to handle common retrieval and permission-enforcement tasks, reducing the need to build and maintain custom pipelines. The full working samples (C#, Rust, and Swift) are available here.

What A2A unlocks for developers

Multi-agent collaboration: Your agents delegate to Copilot agents that understand organizational context.
Embedded intelligence via agents inside SaaS products that tap into a customer’s real work context.
Enterprise assistants tailored to specific roles, powered by Copilot’s grounding and reasoning.
Autonomous workflows where agents hand off tasks, track progress, and exchange structured artifacts.

See A2A in action

The demo above shows an agent sending a natural-language request to Copilot via A2A and receiving a streamed, grounded response—backed by the user’s real organizational data, with no custom retrieval or permissions code. Try it yourself with the Work IQ samples on GitHub.

How developers can use Work IQ API

Whether you’re connecting agents via A2A, surfacing organizational context through MCP in developer surfaces like IDEs and CLIs, or embedding conversational experiences via REST, the patterns share a common foundation.

A2A is the natural fit when your agent needs to collaborate with Copilot intelligence as a peer—delegating work, receiving structured results, and maintaining context across interactions. For example, a sales enablement agent could ask to pull together a customer's recent email threads, meeting notes, and shared documents, then use that grounded summary to auto-generate a pre-call brief—without ever touching the raw data itself.

MCP is ideal when you need to expose Work IQ data as tools and resources to an existing MCP-compliant agent using standard protocols and tooling, without needing custom, one-off connections. For example, with the Work IQ CLI running as a local MCP server, a developer using GitHub Copilot can ask, "What did the team decide about the migration timeline?" and get an answer grounded in actual emails, meeting transcripts, and chat threads—right inside their IDE, without leaving their coding workflow.

The common thread across these approaches is a shift from isolated AI features to agent‑driven systems that stay aligned with how work actually unfolds.

Security and governance

Developers can rely on Work IQ for common security and compliance controls. The Work IQ API draws a clear platform boundary between data access and intelligence:

Permissions: User and tenant permissions, conditional access policies, and sensitivity labels are automatically enforced.
Responses: Permission-trimmed by design.
Compliance: All activity operates within the same audit, compliance, and data-loss-prevention boundaries as Microsoft 365.

Because the API exposes intelligence rather than raw data, applications cannot accidentally bypass tenant security or create shadow-AI risks. Agents operate within the tenant’s existing security and compliance controls from day one.

What comes next for Work IQ

Users with the appropriate license will be able to access Work IQ in customer and partner apps and agents starting today.

General availability is planned for summer 2026. The Work IQ API will also be available to unlicensed users on a consumption basis in summer 2026.

We will continue to add more to the Work IQ API in the coming weeks and months. Our investments will target three areas:

M365 Agent access, enabling more M365 agents to work with and alongside agents across the Copilot ecosystem, unlocking richer multi-agent collaboration patterns.
Remote MCP server public preview, exposing Work IQ as tools and related skills for MCP-compliant agents, so any MCP-aware surface can access governed organizational context.
Deeper connection and richer intelligence, expanding across platforms and developer tools in addition to building on top of organizational data with contextual grounding, skills, and tools.

Resources

Building with the Work IQ API and have questions? Join our developer communities for support:

Microsoft Q&A: Microsoft Copilot | Microsoft 365 Copilot | Development
GitHub: Work IQ GitHub repository: microsoft/work-iq: MCP Server and CLI for accessing Work IQ
Reddit: copilotstudio or microsoft_365_copilot subreddits
Documentation: Microsoft Work IQ API (preview) | Microsoft Learn
Samples: https://github.com/microsoft/work-iq-samples

We can’t wait to see what you build.

Automate agent evaluation with the Evaluation APIs

Efrat_Gilboa — Wed, 29 Apr 2026 18:34:14 GMT

When you build an agent in Microsoft Copilot Studio, you want confidence that it behaves exactly as intended: answering correctly, using the right tools, and following the logic you designed. Agent Evaluation (generally available) provides this foundation by allowing you to define test sets, run them against your agent, and understand how it performs.

As agents evolve from experimentation into real production scenarios, this foundation becomes part of an ongoing process. Evaluation is no longer a one-time step, but a continuous part of the development lifecycle. Teams are looking to validate changes quickly, track quality over time, and ensure consistent behavior across updates, environments, and use cases.

To support this, evaluation scales alongside your agents. Automated evaluation enables teams to expand their testing coverage, run evaluations more frequently, and establish consistent quality signals across the lifecycle. It brings evaluation closer to the way modern systems are built: iterative, data-driven, and continuously improving.

To fully realize this at scale, evaluation integrates seamlessly into your workflows and systems.

Now, these same evaluation capabilities can be used programmatically through Power Platform REST API and your connectors. Here’s how you can use these Evaluation APIs to automate agent evaluation as part of your development and release workflows.

What you can do with the Evaluation APIs

The Evaluation APIs expose the core evaluation experience as programmable endpoints. Using those endpoints, you can trigger evaluations on demand, integrate evalutaions into pipelines and approval workflows, and design processes relying on the results. Whether you prefer a code-first approach with APIs or a low-code experience using Microsoft Power Automate flows and Copilot Studio agent workflows, you can easily automate when and how evaluations run – and use the results for quality gateway.

Here are the capabilities included in the Maker Evaluation API:

Capability	What it does
List test sets	Retrieve the test sets configured for your agent
Run a test set	Trigger a test set to execute against your agent
Poll run status	Poll a running evaluation to see when it completes
Retrieve results	Retrieve detailed results including per-test-case scores
List historical runs	List all previous evaluation runs for reporting or comparison

These APIs work with any HTTP client, Python scripts, Azure DevOps pipelines, GitHub Actions, or custom tooling. For teams working in the Power Platform ecosystem, the same actions are available through the Microsoft Copilot Studio certified connector, which integrates directly with Power Automate flows.

When to use Evaluation APIs

The Evaluation APIs exist so you can run evaluations without manually triggering them, letting evaluation happen automatically as part of your pipelines, your flows, or your own tools. By default, runs evaluate the agent’s unpublished (draft) version, which makes this especially useful for CI/CD and pre-publish validation. The Copilot Studio UI is still the right place for one-off, interactive evaluation. Reach for the APIs when you want evaluation to happen on its own.

Here are three common scenarios.

1. Add evaluation to your CI/CD pipeline

When your agent source lives in a repository, every pull request and every merge to main is an opportunity to validate quality before changes reach production. Wire the Evaluation APIs into Azure DevOps, GitHub Actions, or any CI runner: each pipeline run triggers an evaluation, waits for the result, and passes or fails the build based on the score. Quality regressions are caught at PR time, not in production.

2. Trigger evaluation from a Power Automate flow

Many events that may affect agent quality happen outside Copilot Studio: a knowledge source is updated in SharePoint, a new article is added to a file library, a Dataverse record changes agent behavior. Use Power Automate (with the Microsoft Copilot Studio certified connector) to listen for these events and kick off an evaluation test run automatically, then route the results to Teams, email, or whichever channel your team watches.

3. Embed evaluation in your own tools

Sometimes you want evaluation as part of a tool you’re already building: a Center of Excellence dashboard tracking quality across many agents, an admin script that confirms every new agent has been evaluated before publish, or a custom integration that adds evaluation to an existing approval workflow. The APIs let you call evaluation programmatically from any system, with whatever logic fits your scenario.

How an evaluation run works through the API

The evaluation flow follows a simple pattern: Trigger → Poll → Get Results.

Trigger: Send a POST request to start an evaluation run for a specific test set
Poll: Check the run status until it completes (the execution is asynchronous)
Get results: Retrieve the score and detailed per-test-case outcomes

Optionally, you can pass an MCS Connection ID when triggering a run. This allows the evaluation to run using an authenticated user context, enabling access to tools and knowledge sources that require authentication. Without it, the evaluation will run anonymously.

Working with the Evaluation APIs: the key endpoints

Below are the core Evaluation API endpoints available today, starting with how to retrieve test sets and trigger evaluation runs programmatically.

Prerequisites

API Permissions.

Go to https://portal.azure.com
Go to App Registrations
Search for your App
Click API permissions
Click Add a permission
Click APIs my organization uses
Search "Power Platform API"
Click Delegated permissions
Expand CopilotStudio
Select MakerOperations.Read, MakerOperations.ReadWrite
Click Add Permissions

Endpoint 1: Retrieve available test sets

Use this endpoint to list all evaluation test sets defined for a specific agent.

Request:

GET https://api.powerplatform.com/copilotstudio/environments/{yourEnvironment}/bots/{replaceWithYourCdsBotId}/api/makerevaluation/testsets?api-version=1

Expected result:
Returns the list of maker evaluation test sets associated with the agent.

Sample response:

Endpoint 2: Retrieve a specific test set

Once you have a test set ID, you can fetch its full definition.

Request

GET https://api.powerplatform.com/copilotstudio/environments/{yourEnvironment}/bots/{replaceWithYourCdsBotId}/api/makerevaluation/testsets/{yourTestSetId}?api-version=1

Expected result
Returns the full configuration and structure of the selected test set.

Sample response:

End point 3: Trigger an evaluation run

This endpoint allows you to programmatically start an evaluation run for a given test set.

The Body consists of a JSON object with the following attributes:

McsConnectionId - string value. If an empty string is provided, the evaluation runs anonymously, meaning tools and knowledge sources are not used. Agents that rely on authenticated connectors, actions, or auth‑gated knowledge sources will therefore produce different (likely worse) evaluation results.

RunOnPublishedBot - optional boolean value, defaults to false. Runs against the draft version (true runs against the published version).

EvaluationRunName - optional string value, useful for naming runs in dashboards.

Request

POST https://api.powerplatform.com/copilotstudio/environments/{yourEnvironment}/bots/{replaceWithYourCdsBotId}/api/makerevaluation/testsets/{yourTestSetId}/run?api-version=1

Body

{

“RunOnPublishedBot”: {boolean value},

"mcsConnectionId": "{yourMCSConnectionId}",

“evaluationRunName”: “{yourEvaluationRunName}”,{

}

Sample request:

Sample response:

Removed the note

How to obtain mcsConnectionId

Go to: https://make.powerautomate.com
Open Connections from the side menu
Select the relevant Microsoft Copilot Studio connection
Copy the connection ID from the URL

This connection ID will look something like:

https://make.powerautomate.com/environments/Default-00000000-0000-0000-0000-000000000000/connections/shared_microsoftcopilotstudio/shared-microsoftcopi-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/details

Note: One run at a time
The API returns HTTP 422 if you try to start a run while another is already in progress for the same agent.

Endpoint 4: Get evaluation run status and results

After triggering a run, use the returned run ID to retrieve status and results.

Request

GET https://api.powerplatform.com/copilotstudio/environments/{yourEnvironment}/bots/{yourCdsBotId}/api/makerevaluation/testruns/{yourTestRunId}?api-version=1

Expected result
Returns the status and once completed, the evaluation results.

Sample response:

End point 5: List previous evaluation runs

This endpoint is useful for tracking trends, building dashboards, and supporting automated decision logic.

Request

GET https://api.powerplatform.com/copilotstudio/environments/{yourEnvironment}/bots/{yourCdsBotId}/api/makerevaluation/testruns?api-version=1

Expected result
Returns an array of previous evaluation runs, each with the same schema as the run details API.

Sample response:

Start using the Evaluation APIs today

Pick a test set, call the API, and see what your agent scores. That first run gives you a baseline. From there, you can automate evaluations into your workflow, set thresholds, and build the checks that make sense for your team. The APIs are available now. Start simple, and build from there.

Sign into Copilot Studio to get started today.

Hello, World - Welcome to the Copilot Studio Blog!

David_Abu — Thu, 09 Apr 2026 18:16:55 GMT

We’re so excited you’re here.

Today marks the launch of the Copilot Studio Tech Community Blog, a space for the builders and admins shaping the agent era in the real world.

Agents are moving from demos to production, so we’ll focus on practical patterns for building, shipping, and governing at scale, beyond what docs and product announcements cover. Makers will find templates and build tactics; IT and security will get governance guidance; developers will get deeper dives on extensibility and production operations.

Hit Follow at the top of the page and introduce yourself in the discussion forum, with what you’re building

What Is Microsoft Copilot Studio?

Microsoft Copilot Studio is Microsoft’s platform for building and governing AI agents across the enterprise, from prototyping to production. For the full product overview and getting-started guidance, visit the Copilot Studio website.

What’s New in Copilot Studio

We’re not starting this blog quietly. Here’s a look at three of the biggest updates that have shipped recently.

1. Agent Evaluation — Now Generally Available

Testing agents manually, one conversation at a time, doesn’t scale. Agent Evaluation gives makers a built-in, no-code way to test and monitor agent quality, safety, and reliability at scale. Create evaluation sets using AI-generated queries, past test sessions, or your own QA pairs — then run them automatically to catch regressions before they reach users.

2. Computer-using agents — more secure UI automation at scale

Computer-using agents (CUA) can now automate tasks through user interfaces—clicking, typing, and navigating apps when an API isn’t available—while delivering a more secure approach for UI automation at scale (with stronger controls for admin governance and credential handling).

3. Multi-agent orchestration, connected experiences, and faster prompt iteration

One of the biggest recent updates is improved multi-agent orchestration, alongside new connected experiences and faster prompt iteration, so you can coordinate specialized agents more effectively and refine behavior faster as you move from prototype to production.

Resources to Bookmark

Resource	What It's For
Copilot Studio Documentation	Official product docs, tutorials, and references
2026 Release Wave 1 Plan	What's shipping April–September 2026
Copilot Studio Discussion Space	Ask questions, share ideas, connect with peers

Next steps

1. Hit Follow at the top of the page and introduce yourself in the discussion forum with what you’re building

2. New to Copilot Studio? Sign up for the free trial and bookmark the resources below for docs, release plans, training, and governance guidance.

We can’t wait to see what you create.

Agent Evaluation in Microsoft Copilot Studio is now generally available

Efrat_Gilboa — Tue, 31 Mar 2026 19:13:36 GMT

As agents move into production, evaluations help take each build from experimentation to a reliable system. And they help answer the question that matters most in production: Can we trust this agent to behave correctly, consistently, and safely — every time?

Manual testing simply can't scale to answer that question. Spot-checking responses one-by-one is slow, inconsistent, and not designed for agents that handle hundreds or thousands of interactions. Agent Evaluation in Microsoft Copilot Studio helps fill that gap.

Today, we are giving every maker a better way to assess agent behavior at scale—before launch and over the agent's lifecycle. Agent Evaluation is now generally available.

Validate production readiness before launch and after every change

Agent Evaluation is built directly into Copilot Studio—there’s no separate tool to install and no integrations to configure. Within the agent, the evaluation experience provides an end-to-end workflow for creating test cases, running evals, and reviewing results, all without writing a single line of code.

Whether you're a maker validating readiness before publishing, a quality assurance (QA) team enforcing organizational standards, an agent owner preparing for rollout, or a compliance team that needs documented evidence of agent behavior, Agent Evaluation is designed to integrate into the workflows teams already use to ship and operate agents.

Designed to build trust at scale

Agent Evaluation is designed for organizations that carry real accountability for the agents they deploy. That means evals need to fit into existing workflows, help gather compliance documentation, and produce results that hold up to scrutiny.

Versioned and auditable results

Every evaluation run produces a structured record, including the test set used, the user profile that ran it, the date and duration, and the results from each grader for every test case. These records are available in the evaluation history view, where teams can track performance over time and compare results across runs. For regulated industries and compliance-driven deployments, this record is the artifact that can help demonstrate that an agent was tested against defined behavioral standards before reaching users.

Identity-based evaluation

Each evaluation run is associated with a selected user profile. The agent is evaluated under that identity, using the same knowledge sources, tools, and connectors that the maker accesses in production. This helps ensure evaluation results reflect real-world behavior, rather than a simplified test environment.

API-based evaluation

For teams that operate continuous integration and delivery pipelines, Agent Evaluation is available via API. Teams can retrieve test sets, trigger evaluation runs, and track results programmatically, integrating evals directly into existing deployment workflows to assess agent behavior proactively at scale.

Running an evaluation: from test case to results

Agent Evaluation in Copilot Studio follows a guided workflow that helps makers move from setup to results without disrupting their workflow or leaving the product.

Step 1: Create a test set

Evaluation starts with creating a test set—a collection of questions or scenarios used to assess an agent’s behavior. Makers can build test sets in multiple ways: uploading a CSV with prepared questions and expected responses, writing targeted questions manually, or generating questions from production conversations based on common topics.

To help teams save time configuring test questions, Copilot Studio even includes built-in AI generation options:

The quick question set generates 10 questions instantly based on the agent’s description, instructions, and capabilities, providing an initial signal with minimal preparation required.
The full question set generates up to 100 questions drawn from the agent’s knowledge sources or defined topics, helping teams build broader coverage grounded in the agent’s actual content.

Step 2: Configure evaluation methods

With test cases in place, makers can determine how evaluations measure agent responses by selecting one or more test methods. Built-in methods cover a range of evaluation dimensions, including:

General response quality
Semantic meaning relative to an expected answer
Keyword presence
Text similarity
Exact match
Capability usage

However, for organizations that need to go beyond these dimensions, Custom Graders (available as a Classification method) allow makers to encode your organization’s policies, quality standards, or other rules directly into the evaluation.

Keep in mind, multiple methods can be combined in a single test run, giving teams a layered view of agent performance.

Step 3: Run the evaluation and review results

Once the test set and methods are configured, makers can run the evaluation directly from Copilot Studio. Results appear in a structured table, with each row representing a test case and each column representing an evaluation method.

Pass and fail signals are visible immediately, and the Evaluation summary panel shows aggregated scores across all methods for a given run. Selecting an individual test case opens a detailed view with the agent's full response, the result and explanation from each grader, the expected answer where you've provided one, and the knowledge sources the agent used to generate its response.

Because a test set can be saved and reused, evaluation becomes a repeatable quality check across agent versions. When a prompt changes, a knowledge source is updated, or a new capability is added, the same test set then runs again—producing consistent, comparable signals that help teams validate changes before they reach end users.

What's next for Agent Evaluation?

General availability establishes the foundation. From here, there are already plans to expand evaluation coverage to support multi-turn conversation, deeper automation, and more of the deployment lifecycle, so organizations can monitor agent reliability at scale.

The goal is evaluation that travels with your agent from first build through ongoing production use. And you can start today. Open the Evaluation tab in Copilot Studio, choose a test method, and run your first evaluation in minutes. No code required.