What you’ll see this month: New generally available capabilities for multi-agent coordination across Microsoft Fabric, the Microsoft 365 Agents SDK, and open Agent-to-Agent (A2A) protocols—all of which help agents collaborate across your ecosystem and perform more valuable work. Plus, you’ll find updates to prompt authoring, model choice, and governance controls that can help make it faster to build and refine high-quality agent experiences with confidence.

Agents that work together across your entire ecosystem

The challenge in scaling AI inside an organization isn’t creating a useful agent. It’s about getting many agents—across teams and tools—to work together in a way that’s reliable and repeatable.

In many organizations, data teams might build one kind of agent, app teams another, and productivity teams yet another. Each agent can be valuable on its own, but once a workflow needs knowledge from one system, reasoning from another, and action in a third—teams often run into brittle handoffs and custom integration work. This slows agent adoption and makes it harder to move from promising pilots to real business impact.

This month, Copilot Studio takes a meaningful step forward: several multi-agent capabilities are rolling out to general availability over the next few weeks, giving your teams new ways to connect and orchestrate agents across your ecosystem. These updates include Microsoft Fabric integration, Microsoft 365 Agents SDK orchestration, and Agent-to-Agent (A2A) communication—all designed to help your agents operate together as a coordinated system rather than in isolated silos.

Multi-agent support for Microsoft Fabric

With multi-agent support, your Copilot Studio agents can work with Fabric agents to reason over enterprise data and analytics at scale. That means you can connect business-facing agent experiences more directly to the data estate they already rely on, without treating every data-intensive scenario like a one-off engineering project. Instead of working with limited or disconnected data, these agents will be able to operate with full business context—helping make their outputs more accurate, relevant, and actionable.

Multi-agent support for the Microsoft 365 Agents SDK

Using the Microsoft 365 Agents SDK, teams can now orchestrate Copilot Studio agents alongside agents built for Microsoft 365 experiences. Instead of recreating the same logic across multiple agents (think retrieving data, applying business rules, or completing common tasks), you’ll be able to reuse and combine existing capabilities. This makes it easier to compose cross-app workflows from what’s already been built, reducing duplication and keeping experiences more efficient and consistent.

Agent-to-Agent (A2A) support

With A2A support, Copilot Studio agents can directly communicate with and delegate work to other agents—first-party, second-party, or third-party—using an open protocol that allows universal access. This matters because the future of enterprise AI will not belong to a single stack. Organizations need to build agents on platforms that can participate in a broader ecosystem, not just operate within one product boundary. Copilot Studio A2A provides that interoperability and power.

The impact of multi-agent systems

We’ve already seen the power of this approach with the Ask Microsoft web agent, one of our early “customer zero” implementations. As site traffic and knowledge sources grew, the single-agent architecture began to strain, creating slower response times. Using Copilot Studio, the team upgraded the agent to a modern architecture with generative orchestration and multi-agent coordination.

Now, multiple sub-agents handle different parts of the site—Microsoft Azure, Microsoft 365, pricing, trials, and more—while the main agent orchestrates them to provide fast, coherent, multi-turn responses. This setup allows Ask Microsoft to answer complex questions involving multiple products or services, and to tailor responses based on where the customer is on the site.

Building a more advanced assistant with Copilot Studio has meaningfully raised the bar for our customer experience and enabled us to scale faster across products to deliver real business impact

– Alyse Muttera, Director of eCommerce Programs at Microsoft

To show how this approach works in other organizations, consider a common scenario at a bank. The loan department has one agent handling mortgage applications, while the banking department runs a separate agent for account inquiries. A customer, however, expects a single seamless experience.

Multi-agent orchestration lets each specialized agent manage its area of expertise while coordinating responses behind the scenes. For instance, if a customer asks about a mortgage payment and their account balance in the same interaction, the system delivers a cohesive, context-aware answer that combines insights from both agents—no juggling multiple interfaces required.

When specialized agents work together behind the scenes, customers can get a unified experience and employees can get time back.

That’s exactly the kind of impact Coca‑Cola Beverages Africa is realizing today by using Copilot Studio agents and Microsoft Dynamics 365 to autonomously run planning cycles and automate workflows end to end, saving planners 1 to 1.5 hours every day.

These features will be fully available to all eligible customers as of April 2026. Three capabilities, one outcome: agents that can operate more like a system and less like a collection of disconnected point solutions.

Build prompts faster while maintaining control

As agent experiences grow more sophisticated, the quality of the prompt an agent maker uses matters more. A great prompt yields more powerful results from agents than a good prompt, and fine-tuning prompts is key to unlocking them.

But in practice, prompt iteration has historically felt disjointed and slow. Makers previously balanced their flow of work with jumping into a separate editor, making a small change, testing it, and then repeating the process again. That friction can add up quickly, especially when teams are tuning prompts for specialized business scenarios.

The new immersive Prompt Builder, now generally available, helps reduce that friction by bringing prompt editing directly into each agent’s Tools tab. You can update instructions, switch models, add inputs or knowledge, and test changes—all in one place. Instead of breaking context every time you want to refine an agent’s behavior, you can iterate while staying grounded in the agent you’re building.

This matters most in real-world scenarios where prompt behavior is tied to domain knowledge and policy nuance. For example, a team building an agent to support clinical documentation might need to refine instructions, swap in a better knowledge source, and test outputs against terminology that is common in healthcare but more likely to trigger default safeguards. Doing that from one workspace can make iteration faster and help lower the effort required to get a production-ready result.

More options for prompts: Content moderation and model choice

Speaking of triggering default safeguards, Copilot Studio has also added content moderation settings for prompts, now generally available in supported regions. This gives makers more control over harmful content sensitivity on managed models, including turning down that sensitivity to help unblock legitimate scenarios in industries like healthcare, insurance, and law enforcement, where default settings may be overly restrictive for the content being processed.

For even more control over prompts, the Prompt Tool now supports Anthropic Claude Opus 4.6 and Claude Sonnet 4.5 in paid experimental preview in the United States. That gives makers more choice in matching the right model to the right prompt, rather than forcing every scenario into the same tradeoff profile. This feature is great for teams that want more flexibility in how they balance performance, reasoning depth, and cost.

All together, these improvements help teams move faster on prompt iteration while maintaining the control and flexibility required in production scenarios.

What else is new and improved in Copilot Studio

We have also recently released several additional updates across automation, meetings, retrieval quality, and model support.

• ServiceNow and Azure DevOps connector quality improvements are now generally available. These help agents better understand operational questions, retrieve the right ticket or work item data, and return more complete, actionable answers automatically.
• Evaluation automation APIs are now generally available through Microsoft Power Platform APIs and connectors. These APIs help make it easier to run evaluations programmatically and integrate quality checks into continuous integration and continuous delivery (CI/CD) workflows.
• Agents for Microsoft Teams meetings can now access real-time meeting transcripts and group chat. This supports scenarios like answering questions during the meeting, surfacing relevant information, or helping track decisions and follow-ups as they happen.
• Model context protocol (MCP) apps and Apps SDK support have expanded how agents connect to your external work apps, helping to make it easier to integrate business systems and enable agents to take action across your broader ecosystem—not just respond with information.
• Additional model support, including Grok 4.1 Fast, GPT-5.3 Thinking, and GPT-5.4 Instant in paid experimental preview, gives makers more options as they tune experiences for speed, cost, and capability.

Overall, these updates reflect a continuing broader shift in Copilot Studio: moving from building individual AI experiences to building connected, governed systems that can fit more naturally into how work already happens. As you scale up your organization’s use of multi-agent ecosystems, these will help your teams reach further across channels and knowledge sources to more accurately fulfill your business needs.

Stay up to date on all things Copilot Studio

More is coming in April 2026 across voice channels, workflows, and the building experience. Check out all the updates as we ship them, as well as new features releasing in the next few months here: What’s new in Microsoft Copilot Studio.

To learn more about Microsoft Copilot Studio and how it can transform productivity within your organization, visit the Copilot Studio website or sign up for our free trial today.

The post New and improved: Multi-agent orchestration, connected experiences, and faster prompt iteration appeared first on Microsoft Copilot Blog.

Microsoft Copilot Studio and Agent Builder in Microsoft 365 Copilot are designed to help customers reliably create agents that scale and deliver real, sustained business value—not just prototypes. Recent enhancements focus on making it easier to move from building an agent to running one confidently across complex, dynamic environments, with consistent quality and the ability to evolve as business needs change.

Discover the latest capabilities in agent evaluations, exciting updates for computer-using agents (including expanded model support), a new Agent Academy Operative training path, and more. Plus, learn how you can use these capabilities to help ensure your agents are ready for scale.

Build trust at scale with enhanced agent evaluations in Copilot Studio

Agents aren’t “set and forget.” Prompts evolve, models update, and data changes—which raises a critical question as agents take on real work: can we trust them at scale? Agent evaluations answer that question with evidence. They’re designed to turn expectations into measurable checks, help teams catch regressions early, and provide a repeatable way to assess agent quality as behavior and context evolve.

For example, a finance leader rolling out an agent for expense policy guidance or month‑end analysis needs to trust its behavior before moving beyond a pilot. With enhanced agent evaluations in Copilot Studio, teams can now validate performance using their own scenarios, policies, and production data—measuring quality, usability, and responsiveness across a full test set instead of isolated cases.

Side‑by‑side comparisons then help catch regressions before changes go live. Meanwhile, built‑in transparency and session replays support internal and external stakeholder review. The result is a clear, evidence‑based path from experimentation to trusted deployment.

Available in public preview, here’s a quick rundown of the latest eval enhancements.

Holistic and multi-dimensional agent evaluation

• Set-level grading framework: You can now evaluate agents across an entire test set instead of individual test cases, enabling an accurate measure of overall quality. By consolidating results from multiple tasks, makers can better understand real-world performance by seeing how agents maintain quality across a range of scenarios.
• Multiple graders per test set: With the ability to apply multiple grading approaches—such as quality, performance, and usability assessments—to the same test set, teams can gain a more complete evaluation without the complexity of managing separate test sets.
• Comparative testing: Teams can compare multiple agent versions side by side, which can make it easier to spot regressions and validate improvements before pushing the best version live.

Improved transparency and control

• User reactions and feedback: Makers can now provide quick feedback on evaluation results using a simple thumbs up or thumbs down action. This feedback helps Copilot Studio capture signals about evaluation accuracy, grader alignment, and edge cases, which means our team can continuously refine our evaluation models and improve result quality for agent makers.
• Open activity map in evaluation: Direct integration with the activity map gives teams immediate insight into how agents executed tasks, helping identify where issues occurred faster and improve optimization.
• Enterprise-grade auditing: Advanced session replays, action logs, and Microsoft Purview integration offer detailed visibility into agent behavior, helping makers preserve quality and streamline troubleshooting.

Streamlined workflow and data integration

• CSV downloadable format: Makers can now download a ready-to-use comma-separated values (CSV) template that follows the exact structure required for importing test cases into evaluation. Instead of creating files from scratch—and running into formatting errors, missing columns, or failed imports—teams can rely on a validated template that can help shorten setup time and remove unnecessary friction.
• Import production data into evaluation: Real-world production data can now be imported directly into evaluations, providing high-quality test sets that reflect actual user interactions. This is designed to improve evaluation accuracy and help makers tune agents more closely to their specific audiences.
• Import and export of test sets, test cases, and results: Makers can import or export test sets, individual test cases, and evaluation results. This helps simplify teamwork and support repeatable testing across environments—essentials for enterprise-scale agent development.

Scale automation across real-world systems with nimbler computer use

Most organizations don’t lack ideas for automation. Instead, the challenge tends to be with fragmented systems, limited APIs, legacy desktop tools, and workflows that go across multiple departments. Replacing everything isn’t realistic. But maintaining brittle, script-based automation isn’t sustainable either.

Copilot Studio’s computer-using agents (CUAs) can address this gap by interacting directly with web and desktop interfaces, supporting automation across systems that weren’t designed to integrate. They facilitate automation in complex, dynamic environments where traditional robotic process automation (RPA) falls short.

Consider a customer support organization handling service requests across disconnected systems. When a customer submits a support request, a computer-using agent can:

1. Retrieve customer and entitlement details from the customer relationship management (CRM) system.
2. Create or update a case in the service management system.
3. Pull relevant troubleshooting steps from a knowledge base.
4. Update the case status and resolution checklist in Microsoft SharePoint.
5. Notify the assigned service representative and escalate if service-level agreements (SLAs) are at risk.

This would be impossible with RPA alone because of the need to transcend systems. Although pieces could be automated, a person historically would need to initiate each step. With computer use, the organization can now accelerate this process and mitigate missed steps, without requiring a redesign of existing systems.

And the latest updates enhance the value of your computer-using agents, adding key capabilities that enable improved flexibility, security, and scalability:

• Expanded model availability: We’ve added Claude Sonnet 4.5 as an additional model choice for CUAs. You can choose between Anthropic models and OpenAI’s Computer-Using Agent to get the best possible results for your task.
• Built-in credentials: Simplify and secure authentication with built-in credentials that require minimal setup. Users simply input their username and password once, and Copilot Studio stores the credentials securely.
• Enterprise-grade logging and auditing: New monitoring tools, integrated with Microsoft Purview, enhance computer-using agent session visibility. This includes detailed logs of agent activity and session replays with screenshots that support traceability and compliance processes.
• Cloud PC pool: Powered by Windows 365 for Agents, this scalable, managed cloud infrastructure integrates with Microsoft Entra and Intune. These PC pools auto-scale based on workload demand, helping you handle spikes without over-provisioning.

We know the more tools that help drive operational efficiency while maintaining control over automated workflows, the more confident teams can be about adopting computer use. That’s why these updates help elevate computer-using agents as a more reliable, adaptable solution for enterprises looking to scale their use of agentic automation.

Learn to build multi-agent systems with the Agent Academy Operative path

Finished the Recruit training from the Copilot Studio Agent Academy and looking to go deeper? The new Operative path unlocks the next level of training for agent makers who are ready to build their skills. It’s designed for practitioners who already have their first agent working and want to expand their skills to build more sophisticated, production-ready solutions.

The Operative path walks learners through building a complex, multi-agent hiring automation system, using it as an applied learning example that can be adapted to any business scenario.

Along the way, participants develop critical skills such as writing clear and effective agent instructions, selecting and evaluating AI models, and applying advanced prompt patterns, agent flow integration, and Model Context Protocol (MCP). The curriculum also emphasizes operational readiness, including feedback loops, telemetry, and AI safety throughout the agent lifecycle.

By the end of the path, learners can gain a deeper understanding of how to design, build, and architect scalable multi-agent systems that can evolve with business needs. For creators ready to move from basic agents to more advanced, reliable solutions, the Operative path provides a practical and structured next step.

What else is new and improved in Copilot Studio

Now, let’s take a quick look at some other exciting updates—all generally available (GA)—that further enhance your Copilot Studio (and Agent Builder) experience:

• Copy agents from Agent Builder into Copilot Studio to scale impact: Agents that start as individual ideas in Agent Builder and prove team-wide value can now be opened directly in Copilot Studio for a more extensive maker experience. This unlocks advanced features such as topics, automations, expanded publishing channels, and enterprise governance controls, including data loss prevention and application lifecycle management. For example, a support representative’s personal helper agent can be expanded into a shared tool that categorizes tickets, suggests responses, and routes issues to the right specialists—without rebuilding from scratch.
• Query your agent inventory from Azure Resource Graph: The Microsoft Power Platform agent inventory, which organizes and displays all your published Copilot Studio and Agent Builder agents, is now generally available. Admins can query this inventory programmatically using Azure Resource Graph to access detailed data about both draft and published agents across the tenant, using Azure portal, CLI, PowerShell, or REST API.
• Generate icons for your agents using AI in Agent Builder: Makers can now generate custom agent icons directly in Agent Builder using AI. Instead of browsing or creating artwork manually, they simply describe how the icon should look—using the agent’s description or a custom prompt—and get a unique icon designed to stand out in the Agent Store.
• Try the Copilot Studio extension for Visual Studio Code: The Copilot Studio extension lets teams version, edit, and deploy agents directly from Visual Studio Code, making it easier to align with existing software development workflows.

The big takeaway: Stronger Copilot Studio tools for more scalable agent experiences

These updates aren’t just new features; they strengthen the tools teams rely on to create agents that scale with their business. By enhancing flexibility, security, and visibility, these updates are designed to make it easier to scale agents without starting over each time.

This continuity helps makers innovate quickly while IT teams maintain control over governance, compliance, and performance—bridging the gap between rapid iteration and enterprise-grade reliability. Why? Because at the end of the day, the best agents are those that are built to grow with your needs, and with these updates, that evolution becomes more attainable every month.

Stay up to date on all things Copilot Studio

Check out all the updates as we ship them, as well as new features releasing in the next few months here: What’s new in Microsoft Copilot Studio.

To learn more about Microsoft Copilot Studio and how it can transform productivity within your organization, visit the Copilot Studio website or sign up for our free trial today.

The post New and improved: Agent evaluations, computer use, and advanced maker training appeared first on Microsoft Copilot Blog.

To help teams like yours answer these complex questions faster and move with confidence, we’ve launched the new agent architecture guidance hub and a refreshed Microsoft Copilot Studio guidance hub. These on-demand resources offer end‑to‑end documentation across the agent lifecycle—from design and planning through operations, governance, and advanced architectural patterns.

Built on established practices from Microsoft engineering teams and real‑world deployments, these hubs give architects, developers, and IT a shared blueprint to work from. And they were designed to help your team make smarter architectural decisions, accelerate delivery with practical how‑to guidance, and scale safely with trusted governance, security, and responsible AI practices.

Whether you’re building your first agent or scaling across your enterprise, these hubs can help you start—and stay—on the right path.

Now, let’s explore what each hub offers and how to put them to work for your organization.

Meet the new agent architecture guidance hub

The new agent architecture guidance hub is a technology‑agnostic playbook for designing secure, reliable, and accountable agents. Unlike the Copilot Studio guidance hub and Azure Well‑Architected guidance, this hub focuses on the principles and patterns required to build scalable agent systems—regardless of platform, tools, or runtime.

Grounded in the same practices Microsoft 365‑grade agents use, this hub distills lessons from real‑world deployments into a single source of truth. It provides clear answers to foundational architecture questions, such as how your agents should be structured, how they should run, and how they should be governed at scale.

Use the agent architecture guidance hub to:

• Identify fit for purpose by mapping your scenario to the right agent flows, components, and reference architectures.
• Design for operability by building reliability in from the start, using deployment lifecycle and evaluation guidance.
• Establish trust, traceability, and transparency through responsible AI practices, governance, auditability, and security practices.
• Optimize search and tool‑use patterns by adopting retrieval, grounding, and tool‑execution approaches used in Microsoft 365 Copilot.

Discover the redesigned Copilot Studio guidance hub

The reimagined Copilot Studio guidance hub is your end‑to‑end playbook for designing, building, and operating agents in Copilot Studio. Unlike architecture‑level resources, such as the agent architecture guidance, this hub focuses on hands‑on implementation—so makers, developers, and IT admins know exactly how to execute their work inside the product.

The newly reorganized and expanded hub now mirrors the full lifecycle of an agent. It’s built around five practical stages—Plan, Implement, Manage, Improve, and Extend—so your team can quickly find the right guidance at the right moment, whether you’re starting fresh or scaling an existing deployment:

• Stage 1: Plan. Align on business goals, define success measures, apply responsible AI considerations, and design effective language understanding before building anything. This helps to ensure every agent starts with a clear purpose, measurable outcomes, and a responsible foundation.
• Stage 2: Implement. Focus on the design and build work inside Copilot Studio. Learn generative orchestration patterns, build topics effectively, integrate systems and APIs, and publish agents with confidence using patterns established to work in production.
• Stage 3: Manage. Operate agents with governance, ALM, capacity planning, project security, testing guidance, and compliance best practices. This stage helps teams define the guardrails and decisions needed to maintain trust, reliability, and control over time.
• Stage 4: Improve. Center continuous optimization around analytics, KPIs, and conversation insights to drive measurable improvements in accuracy, containment, deflection, and user satisfaction—turning real usage data into targeted enhancements.
• Stage 5: Extend. Go beyond out‑of‑the‑box capabilities with hands‑on extension guidance. Use the Copilot Studio Kit and work with the Microsoft 365 Agents SDK to add custom logic, actions, and richer workflows tailored to your organization’s unique scenarios.

Together, these stages make this hub a practical, step-by‑step playbook for building agents in Copilot Studio that are useful, safe, and maintainable from day one—and that can scale as your needs grow.

Build agents with confidence

Successful agents require more than a powerful platform—you also need clearer choices, practical guardrails, and a way to spend less time reinventing the wheel. The new agent architecture guidance hub and Copilot Studio guidance hub (together with our other resources like the Copilot Studio adoption site and Copilot Studio community forum) make it easier to go from early experiments to confident, repeatable delivery.

Use the agent architecture guidance hub to clarify what to build and why. Then, turn to the Copilot Studio guidance hub when you’re ready to design, build, and operate those agents more effectively in Copilot Studio.

Whether you’re experimenting with your first agent or managing a collection of agents in Microsoft Copilot Studio, put these resources to work to make your next build easier, safer, and faster.

The post New resources and guidance to plan, build, and operate enterprise-ready agents appeared first on Microsoft Copilot Blog.

Then, reality arrives. 

The people who use the agent phrase questions differently. Conversations stretch across multiple turns. Context accumulates. Permissions prove table stakes. The right tools need to be invoked. Edge cases appear. Suddenly, the question becomes “can I actually trust how the agent behaves?”

Agent evaluations exist for this exact moment. AI agents do not behave the same way twice. Their responses shift with model updates, data changes, prompts, tools, and context. What works today may drift tomorrow.

Thankfully, agent evaluations reinforce confidence in the agents you build. Let’s walk through how you can make the most of this capability.

What exactly are agent evaluations?

Agent evaluations (or “evals”) are the standardized mechanism that make agent variability visible and manageable. Unlike debugging, evals are not a one-time check or a manual review. It is a consistent process that helps you stay ahead of what could go wrong and improve agent performance over time. 

By running evaluations, makers can launch agents into production knowing how they’ll behave, not how we hope they do. They can also ensure that an agent’s behavior remains stable over time.

As such, every maker should be evaluating all their agents. But this initiative can start with a few quick evaluations that require minimal setup, using default data and default grading to unlock quick signals.

However, as your agents mature, you’ll likely need to evolve this strategy, configuring additional evaluations that test behaviors in specialized scenarios.

Agent evaluation in 8 simple steps

Imagine you’re a maker that just built an internal human resources (HR) agent that helps employees understand leave policies, benefits, and when to escalate to HR systems. 

Here’s how you’d evaluate this agent in Microsoft Copilot Studio, from deciding what to evaluate to understanding real-world behaviors and confidently iterating:

Step 1: Decide what you’re evaluating

Before you can run an evaluation, you need to be clear about what you’re trying to validate. 

This starts with defining the scenario. What kind of behavior are we testing? What assumptions are we making about the user’s intent, the context, and the information the agent has available? A well-defined scenario sets the foundation for meaningful results.

With this information, you’ll need to define your scope. Some evaluations focus on a narrow behavior to get a precise signal. Others cover a wider range of interactions to reflect real usage. A narrower scope makes results easier to interpret, while a broader scope helps surface risks that only appear at scale. 

You’ll need to make these choices deliberately. By explicitly defining the scenario and scope, evaluations produce signals that are relevant, reliable, and aligned with how you expect people to use the agent in practice. And it can impact the success of your evaluation.

Step 2: Ground evaluation in real user behavior 

Once you’ve defined the scope, the next question emerges: “What are we evaluating against?” 

Strong evaluations start with realistic data. Not idealized prompts, but the messy, imperfect ways people actually ask questions. For your HR agent, this includes vague phrasing, partial information, and mixed intents like asking about leave while referencing a personal situation. 

You can bring data from multiple sources, including manually authored scenarios, AI-assisted generation to broaden coverage, imported datasets, and even historical or production conversations.

We recommend starting with a small but meaningful test set, focusing on the high-value scenarios that matter most to your business.

This data ensures that the evaluation inputs reflect real behavior, not the maker’s assumptions. But even with this data in place, you’ll likely ask: “How will this help me judge whether the agent behaved as expected?” This brings us to step three.

Step 3: Define your evaluation logic

Sometimes makers start with default grading to understand baseline behavior, before deciding what they want to measure more precisely. 

Meanwhile, others define more specific grading logic upfront based on what they already know and what they want to validate. 

Evaluation logic does not require full certaienty at the start. It provides a structured way to observe outcomes and refine what matters over time. 

Makers can choose from a collection of ready-to-use graders and even combine multiple graders within a single evaluation to get a richer, multi-dimensional view of agent behavior. 

For example, your HR agent configuration might include three separate graders:

1. General quality grader to assess whether the response is complete and addresses the full question.
2. Classification grader, where you describe the expected behavior as using natural language prompts.
3. Capability grader to confirm the agent uses the right topic or tool at the right time.

Even better, you can make these expectations explicit: what matters, what does not, and what “good behavior” looks like in this scenario. By defining evaluation logic upfront, you’ll reduce ambiguity, make success observable and explainable, and shift quality from subjective judgment to measurable signal. 

Step 4: Set the right identity context 

Once you’ve outlined what you’re testing, you need to define when the evaluation should run. Specifically, which user profile should the agent act like is sending the questions when it’s being evaluated?

The user context you select determines the agent’s behavior, including what data it can retrieve and reason over. It also ensures evaluations catch permission‑related risks early, such as inappropriate data access.

So, making this choice explicit helps avoid a common source of false confidence. When results are reviewed later, makers can trust that successes and failures are grounded in the same access boundaries their users will experience.

For example, an HR agent that references internal policy articles may behave very differently if it’s responding to a full-time employee or a contractor.

Running the evaluation under only the intended user identity ensures evaluation results reflect real conditions rather than an idealized setup. This can help you identify and mitigate unexpected behavior, such as sharing your company’s healthcare options with a contractor.

Step 5: Evaluate the agent’s responses

Now, it’s time to run your evaluation. Based on the data you provided, Copilot Studio simulates real user prompts and the agent generates responses, curated to your prescribed user context. Each configured grader then evaluates a different aspect of the response, such as quality, correctness, or capability.

This evaluation process turns individual answers into structured signals. Together, these signals make agent behavior observable, repeatable, and explainable at scale. 

The maker is no longer relying on intuition or spot checks to assess their agent’s quality. They’ve created a disciplined feedback loop that replaces assumptions with evidence and transforms agent quality from a subjective impression into a measurable outcome. 

Step 6: Step back to see the bigger picture

Once your evals gather sufficient signals, your focus shifts outward: “What does this tell me overall?” 

Aggregated results provide a high-level view of quality, consistency, and trends across scenarios and graders. For the HR agent, this might reveal strong performance on common policy questions, but weaknesses around edge cases or escalation behavior. 

With these signals, you can better prioritize. Not every failure matters equally. Patterns matter more than anomalies. And evaluation becomes a decision-support tool, not just a reporting surface. 

Step 7: Investigate why single cases pass or fail

High-level signals are useful, but confidence is sturdiest when it’s grounded in the details. 

When a maker drills into a specific test case, explainability comes to the foreground. They can see which grader triggered a failure, how the agent responded across turns, which knowledge sources it used, and whether it invoked the expected tool or topic. 

This is often the turning point. Instead of guessing why something went wrong, you can finally understand what actually happened. Was the agent’s instructions unclear? Was the data incomplete? Did the agent confidently answer the prompt when it should have escalated it? 

With this newfound understanding, you can make informed changes to your agent, adjusting instructions, data, or behavior based on what the evaluation revealed. 

Step 8: Validate progress through comparison 

Evaluation doesn’t end with a single run and a few gathered signals. Agents change over time. Instructions get updated. Data grows. Tools are added. 

With evaluations as an always-on motion, you can compare runs. You can check whether things are improving and catch regressions early. This ongoing view helps your team answer a simple but critical question: “Are we actually getting better?” 

For your HR agent, evaluations might confirm that an update made to the instructions reduced hallucinations without harming coverage. Confidence is no longer anecdotal. It is earned through evidence. 

Make agent evaluations your confidence loop

Evaluations don’t slow you down. They accelerate progress. Each iteration builds understanding and offers clarity. Each run reduces uncertainty. And each comparison strengthens trust, empowering you to build with confidence.

That confidence is what encourages teams to move from test to production, and from promising prototypes to agents that can be relied on in real business scenarios at scale. 

Ready to run your first agent evaluation? Get tactical guidance for configuring evals in Copilot Studio—complete with best practice evaluation methodologies.

New to Copilot Studio? Discover how you can transform your business by building, evaluating, managing, and scaling custom AI agents—all in one place.

The post How to evaluate AI agents in Microsoft Copilot Studio appeared first on Microsoft Copilot Blog.

This shift marks the moment AI moved from helping people do work faster to helping organizations optimize their workflows.

Microsoft Copilot Studio has played a central role in this transition. It gives you more flexibility to evaluate and use the models best suited to your business as agent adoption scales.

In 2025, we laid the groundwork for what scalable, impactful agentic work should look like. In 2026, we believe the organizations that benefit most will be the ones that build on that foundation. These six trends define what organizations need to make agent adoption stick in 2026 and beyond:

1. Ability for anyone to turn intent into agents
2. Agents that can own workflows from end to end
3. Power to coordinate agents for real outcomes
4. Flexibility to control your agent models
5. Agents that can act across your systems
6. Capability to scale agents without sacrificing control

Organizations that have all six aren’t just experimenting with agents. They’re operationalizing them, turning curiosity into confidence, and transmuting innovation into sustained business value.

1. Ability for anyone to turn intent into agents

Historically, building an agent meant translating business intent into technical instructions. This process slowed adoption and limited who could participate. In 2025, that barrier fell away. Conversation became the agent-making interface in both Copilot Studio and the Agent Builder in Microsoft 365 Copilot Chat. Now, people can describe what they want done using natural language and create an agent to do it. These agents can interpret intent, context, and goals thanks to their underlying model and knowledge, not specially built code.

That shift is designed to empower everyone on your team to build agents. Sales leaders, operations managers, and human resource (HR) officials no longer need to wait for technical assistance to automate everyday work. Meanwhile, IT teams retain clarity and structure under the hood, with agents grounded in logic that can be reviewed, refined, and governed—all in Copilot Studio.

The results? Faster fast agent creation, broader participation, and fewer translation gaps between business needs and technical execution.

For example, a sales operations manager can now describe and publish an agent that:

• Monitors pipeline changes, such as changed estimated close dates.
• Flags deals that may be at risk, based on predefined criteria (e.g., no activity with stakeholders for over a month).
• Notifies account owners with recommended next steps based on the type of flag.

The payoff: More people can build knowledgeable, context-aware, and helpful agents, which can translate to less bottlenecking on centralized teams and faster time to value.

2. Agents that can own workflows from end to end

For many teams, early adoption wins came from AI assistance: drafting content, summarizing meetings, answering questions. Useful, but incremental. In 2025, agents crossed an important threshold; they evolved from helping with work to handling it on your behalf. With agent flows and the Workflows Agent, agents can now own repeatable processes from end to end, automatically advancing work when required.

In other words, agents unlock new opportunities to streamline and scale how work gets done. An onboarding process no longer stalls due to a missed handoff. A request doesn’t linger in a queue waiting for manual follow-up. Agents move work along reliably with automated approvals, escalating to humans only when judgment is required. For leaders, that can mean faster cycle times and fewer hidden bottlenecks. For teams, it can translate to more time spent on decisions—not coordination.

For example, a company could use Copilot Studio to automate a multi-step process for expense submission, validation, and reimbursement. The process:

• Triggers when an employee submits a wellness or reimbursement request.
• Guides the employee through required forms and documentation in a single, user-friendly flow.
• Validates submissions against global wellness policy rules and regional guidelines.
• Routes requests across the appropriate software as a service (SaaS) tools and internal HR systems.
• Escalates exceptions to a human only when needed.

The payoff: Faster resolutions using consistent criteria, less potential for human error, and a daily pain point made smoother with an agent.

3. Power to coordinate agents for real outcomes

Often, meaningful business outcomes don’t happen in a single step or system. As soon as agents move beyond simple tasks, coordination becomes increasingly challenging. Multi-agent systems addressed this complexity head-on in 2025, allowing agents to specialize, delegate, and collaborate toward shared goals.

Instead of designing one agent to handle every step, organizations can now compose agents that mirror how teams already work. One agent might monitor signals, while another gathers or validates information, and a third prepares recommendations or takes action.

Together, these agents are designed deliver outcomes that would be difficult for any single agent to manage alone. More importantly, they remove a layer of decision-making from the stakeholder. Instead of figuring out which system or agent holds the right answer, you can simply ask your question and let the agentic system coordinate the rest. Complex workflows become easier to reason about, evolve, and scale—without adding mental overhead for the people involved.

For example, a manufacturing company might use:

• One agent grounded in internal policy and safety documentation.
• Another agent trained on equipment manuals and training materials.
• A third agent connected to supplier-provided expertise.
• A coordinating agent that evaluates each question and routes it to the right source automatically.

The payoff: More clarity around which system or agent to use—just ask, and the right expertise can come together behind the scenes. This can help keep complex work cohesive, not cobbled together.

4. Flexibility to control your agent models

As agents moved into real business workflows, one reality became clear: not every task has the same requirements or permissions. Some scenarios call for deeper reasoning. Others prioritize repeatability and efficiency at scale. Still, others must meet strict regulatory, security, or data residency standards.

In 2025, Copilot Studio expanded model choice to meet those needs. It now supports Anthropic models, chat and reasoning-specific models, access to thousands of models through Microsoft Foundry, and bring-your-own-model options. You can select the right model for each workload while IT teams maintain policy alignment and oversight. This gives your organization flexibility in how agents behave and perform, without fragmenting the experience.

For example, an organization in a regulated field might use:

• One model optimized for policy interpretation and complex reasoning.
• Another tuned for cost efficiency in high-volume, repeatable requests.
• Central governance to ensure each model is applied appropriately.

The payoff: Instead of compromising between performance and compliance, agents can be configured to match the realities of the work they support—and evolve as those requirements change.

5. Agents that can act across your systems

For years, AI has been good at suggesting what people should do, but it hasn’t been equipped to help make it happen. In 2025, capabilities like Model Context Protocol (MCP) and computer use began to close that gap. Agents can now connect to systems, navigate interfaces, and take action across tools—not just give recommendations.

This addresses one of the biggest gaps in early AI adoption by reducing the handoffs that drastically slow work. When agents can act across environments to update records, trigger workflows, and interact with real systems (like clicking around a website and filling out form fields), work moves forward automatically, at any time of day. This can help reduce delays, manual errors, and the risk that important follow-ups get lost between tools or teams.

For example, an operations agent could autonomously:

• Identify a supply issue based on predefined signals.
• Update the system of record with the latest status.
• Fill out and file a ticket to initiate remediation.
• Notify relevant stakeholders with context and next steps.

The payoff: Faster response times, fewer handoffs, and agents that operate across real-world systems, not just chat windows.

6. Capability to scale agents without sacrificing control

Widespread agent adoption raises a familiar concern: How do you prevent innovation from outpacing governance? Leaders want to move quickly, but not at the expense of visibility, security, or cost control. In 2025, Copilot Studio addressed that gap by bringing lifecycle management, agent evaluations, and enterprise controls directly into the agent experience.

Organizations can now understand which agents are in use, how they’re performing, and what they cost across environments. Admin controls are designed to align agent behavior with intended use, while agent evaluations support ongoing quality and improvement. Paired with Microsoft Agent 365, organizations get a unified view of agents across Microsoft 365 Copilot and Copilot Studio, giving business and IT leaders the clarity needed to scale with confidence.

For example, IT leaders can:

• See which agents are used, by whom, and at what cost.
• Evaluate agent quality and performance over time.
• Communicate performance insights to business leaders to help increase buy-in, investment, and adoption.
• Apply consistent governance without slowing innovation.

The payoff: Agents can move from pilots to production faster, with fewer surprises and clearer business impact.

How to turn agentic momentum into results

The question for 2026 isn’t whether agents will be used—it’s how deliberately they’ll be put to work. Over the past year, the foundations for scalable agent adoption came together. The opportunity now is to move from experimentation to widespread execution.

We believe organizations that’ll get the most value in the year ahead will do three things consistently:

1. Broaden who builds by empowering business teams to create and refine agents in partnership with IT teams, who provide guardrails without stifling creativity.
2. Standardize how agents are shared and reused, so successful patterns move beyond individual productivity into team and enterprise workflows.
3. Measure what matters as a matter of course, using visibility into usage, quality, and cost to guide where agents are expanded, improved, or retired.

When business and IT teams operate from the same foundation, agents stop being side projects and start becoming part of how work happens. That’s how teams move faster, reduce rework, and work together with AI and automation to create true business transformation.

Where to start—and how to go further

Your best agentic year isn’t defined by how many agents you build, but by how many people rely on them to get work done. Copilot Studio gives you the foundation to do exactly that. Now, 2026 is about building out, driving adoption, and scaling up.

Try this three-step plan for building and scaling your agent strategy with Copilot Studio:

1. Get quick wins. Start by focusing on business-to-employee (B2E) assistive agents. Try downloading the Employee Self-Service Agent from the Agent Store.
2. Create a Center of Excellence (COE). Set up a central team that can help triage cross-team needs and get the broader organization comfortable with agents. This could be a representative from every department, or made up of agent champions (regardless of where they sit in their org). A great COE can help reduce geographic silos and bring consistency to an AI strategy.
3. Measure and reward adoption. What gets measured gets focus and investment. Compare the situation today with the situation post-agent adoption. Did the agent provide value? Has it improved what you set out to change? Prove the progress, and then you can move onto the next process.

Get started today and turn agent curiosity into capability, confidence, and commitment this year.

The post 6 core capabilities to scale agent adoption in 2026 appeared first on Microsoft Copilot Blog.

November 2025 was a busy month for Microsoft Copilot Studio, marked by major announcements at Microsoft Ignite 2025 and a wave of new features now rolling out to makers. It’s clear that organizations are moving beyond traditional automation and into a new era of agent-driven work. In this month’s roundup, we’re spotlighting our most significant Ignite updates and introducing powerful new capabilities you can start using today.

Copilot Studio enhancements and new features

From automation to outcomes: Ignite 2025 highlights

Microsoft Ignite 2025 underscored a clear trend: organizations are accelerating their shift toward agentic business transformation. Copilot Studio is the fully managed platform that enables them to build, govern, and scale AI agents across the enterprise. At Ignite 2025, we introduced new capabilities that create a more robust, secure agent creation experience for every user—from makers to professional developers to IT administrators.

Highlights included a redesigned conversational authoring experience, natural language file generation, and a seamless one-click upgrade path from Agent Builder in Microsoft 365 Copilot to Copilot Studio. That means business users can turn ideas into working agents faster, without waiting on development cycles and then expand when ready. This changes the game on how teams use technology to make a step change within a business process.

Makers now have even more flexibility with model choice across GPT-5 and leading third-party models, built-in agent evaluations, expanded computer use automation, and deep integration with more than 1,400 systems through Model Context Protocol (MCP), Power Platform connectors, and Microsoft Graph. In real-world terms, this removes the “user tax” of context switching and managing data silos. Whether you’re looking for help with invoice processing or supplier discovery, these agents bring collective insights to help drive a process forward.

For administrators, Ignite 2025 delivered major governance updates. These included expanded analytics and insights, real-time protection powered by Microsoft Defender, and new oversight capabilities through Microsoft Entra Agent ID that gives IT teams the confidence to scale AI safely.

We also introduced Microsoft Agent 365, the unified control plane for enterprise agents. Agent 365 centralizes governance, policy management, and monitoring. This includes new MCP servers that allow agents to schedule meetings, generate documents, send emails, and update CRM records with full compliance and audit support.

To dive deeper into all the announcements, see our full Ignite 2025 recap: Why Microsoft Copilot Studio is the foundation for agentic business transformation.

GPT-5 Chat: Ready for production in Copilot Studio

GPT-5 Chat is now generally available in the European Union and United States. This means makers can confidently use this model in production scenarios for workloads that could benefit from GPT-5 Chat’s improved responsiveness, accuracy, and instruction-following.  This means makers can confidently use this model in production scenarios for workloads that could benefit from GPT-5 Chat’s improved responsiveness, accuracy, and instruction-following.

You can enable GPT-5 Chat directly from an agent’s overview page. You can even set it as the primary model for scenarios like high-volume employee support or step-by-step process guidance.

We’ve also started rolling out the GPT-5.2 series as experimental models for U.S. customers in early release environments. These models improve performance across the board, including coding and multilingual use cases. This replaces the GPT-5.1 series, including in any agents created using GPT-5.1 models. Since these models are experimental, they’re best suited for test scenarios rather than production—but they give you an exciting preview of what’s coming next. 

You can read more about model choice and how to test them out in Copilot Studio.

Combine autonomous workflows with human judgment

One of the most important evolutions this month is human-in-the-loop (HITL), now in preview. This capability lets agents pause and ask for human input before moving forward. That may sound simple, but it fundamentally changes what organizations can trust agents to do.

With this feature, an agent can send a structured request (delivered as an Outlook form) to designated reviewers. Once the reviewer responds, the agent resumes and uses the submitted values as parameters. This provides real-time human judgment without disrupting the overall workflow.

HITL is especially useful when an agent needs clarification, additional context, or explicit approval to proceed. It supports scenarios such as confirming project updates, confirming procurement orders, validating financial reports, escalating complex customer support cases, resolving ambiguous data, or gathering information that only a person can provide. The result is more flexible and reliable automation that adapts to real-world conditions.

To use HITL, open the agent-building experience and select Add tool. Choose the request for information in Copilot Studio agent flows (preview) action under the Human-in-the-loop connector, then configure fields such as the title, message, assignee, and inputs. The agent will automatically trigger the request whenever the workflow calls for it. Learn more about request for information.

Add curated Outlook and SharePoint tool groups to agents for faster setup

Makers can now streamline agent configuration by adding curated Action Groups from Outlook and SharePoint connectors, now in preview. Instead of identifying and configuring individual actions one by one, teams can bring in complete sets of related tools, such as “manage emails” or “manage files,” with a single selection. This makes it easier to equip agents with the capabilities they need to support common workflows across communication and content management.

Each Action Group contains the most relevant and reliable tools for its scenario. Shared inputs automatically apply across the group to reduce setup time and improve consistency. Makers can either specify their own values or opt to have AI dynamically fill inputs based on context. Try it both ways—each action is fully editable even after it’s added. This flexibility helps ensure agents behave predictably while still allowing customization for unique business processes.

To use Action Groups, open an agent’s Tools section, select Add tool, choose Outlook or SharePoint, and pick the tool group you want to add. This provides a faster, clearer, and more guided way to build workflow-ready agents.

SharePoint grounding: Turning content chaos into decision clarity

Any team that uses SharePoint knows that it can sometimes be tough to find exactly the nugget of information you need among all your content. Fortunately, if you’re using SharePoint as a knowledge source, your agents just got a lot smarter. We shipped an upgraded tenant graph grounding architecture that improves how agents retrieve and rank information across your organization. This translates into more precise, more context-aware responses, especially in content-heavy environments. 

On top of that, you can now filter SharePoint content using metadata like filename, owner, and last modified date. That gives you much tighter control over which documents your agents rely on when answering questions. 

Learn more about these features and using SharePoint as a knowledge source.

Agent Builder enhancements and new features

Use the latest GPT-5 Chat capabilities in Agent Builder

Microsoft 365 Copilot now uses GPT-5 Chat when responding to prompts in agents created with Agent Builder. This brings immediate improvements to speed, quality, and accuracy in carrying out instructions. Organizations relying on agents built in Microsoft 365 Copilot will see immediate quality improvements in employee support, decision guidance, and informational use cases. No additional configuration or opt-in is required where GPT-5 Chat is available.

GPT-5.2 is also now available to use in Microsoft 365 Copilot with both web and work data. This new model series brings improved code generation and multilingual capabilities. Users with a Microsoft 365 Copilot license received priority access to GPT-5.2 on December 11, 2025, and the series is expected to be available to all users in the coming weeks.

Extend your agent seamlessly from Agent Builder to Copilot Studio

Makers can now seamlessly move agents built in Agent Builder (the lightweight agent-building experience inside Microsoft 365 Copilot) into the full Copilot Studio application using the new “Copy to Copilot Studio” action. This capability is generally available everywhere Agent Builder is supported.

This feature allows makers to start prototypes quickly in Microsoft 365 Copilot and then expand them into fully governed, enterprise-ready Copilot Studio agents without rebuilding from scratch. The copy operation creates a version of the agent in the selected environment while preserving the original in Agent Builder. In addition to providing peace of mind, this means your users can still partake in the existing experience while the enhanced version is developed.

Once an Agent gets copied into Copilot Studio, makers gain access to a suite of richer capabilities. This includes lifecycle management, analytics, more third-party connectors, and publishing options that give agents access to channels such as the Teams app store. This helps create a healthy innovation cycle: fast at the edges, controlled at the core. Learn more about copying agents to Copilot Studio.

Streamline employee support with the Employee Self-Service Agent

The Employee Self-Service Agent in the Microsoft 365 Copilot agent building experience is now generally available. This agent provides a centralized AI-powered experience for common employee support scenarios, including HR- and IT-related needs. The Employee Self-Service Agent helps employees quickly get answers and complete tasks such as checking leave balances, reviewing benefits, or submitting IT tickets. This agent provides a centralized AI-powered experience for common employee support scenarios, including HR-related and IT-related needs. The Employee Self-Service Agent helps employees quickly get answers and complete tasks such as checking leave balances, reviewing benefits, or submitting IT tickets. 

Built for makers to configure and extend in Copilot Studio, the agent includes prebuilt connectors and workflows for systems like Workday, ServiceNow, and SAP SuccessFactors. It’s fully customizable and extensible. This allows teams to tailor responses, logic, and integrations to their own organizational processes.  

To keep employees in their flow of work, the agent can also hand off to Workday or ServiceNow agents when deeper actions are required. This means that instead of employees navigating portals or emailing multiple teams, they can simply ask for what they need. From a business lens, this reduces ticket backlogs, shortens resolution times, and improves employee sentiment. 

The Employee Self-Service Agent is designed to work within your existing Microsoft 365 security, privacy, and compliance boundaries. Expanded support for Facilities and other verticals is coming soon. Learn more in the Employee Self-Service Agent announcement blog.

Unlock organizational intelligence: People as a knowledge source

Makers can now add People as a knowledge source in Agent Builder for declarative agents. Agents can reference live directory information, including employees’ roles, reporting relationships, team memberships, and profile details, to answer questions such as “Who is the manager for X?” or “Who is on Y team?” with current, accurate details. 

This feature, now generally available, promotes richer organizational insight across internal workflows, approvals, and employee support experiences. It’s especially valuable for onboarding, internal support, approvals, escalation paths, or any workflow where it can be difficult, but critical, to identify the correct person. By grounding agents in live directory data, makers can deliver more accurate, context-aware responses without manual upkeep or duplicated lists.

To enable People as a knowledge source, open Agent Builder, navigate to Knowledge sources, and select “Reference people in organization.” Learn more about People as a knowledge source.

Generate polished documents, spreadsheets, and presentations

This is where AI shifts from “assistant” to “producer.” Agents built inside Microsoft 365 Copilot can now create high-quality Word documents, Excel worksheets, and PowerPoint presentations using the “Generate documents, charts, and code” skillset (formerly known as Cope Interpreter). This capability is generally available everywhere Agent Builder is supported.

These enhanced Office skills bring richer creation and formatting tools directly into your custom agents. Agents can generate structured documents, well-designed slides, and Excel files that incorporate charts, visuals, layouts, and other professional elements. This makes it easier for teams to create reports, summaries, plans, proposals, and analysis as part of an automated workflow. You can do all this using natural language.

To try out this feature, open Agent Builder and toggle on Generate documents, charts, and code. If Code Interpreter was previously enabled, the new capabilities are automatically available.

Use OneNote pages as living knowledge

Makers can now add OneNote pages as knowledge sources in Agent Builder. Many teams rely on OneNote to capture meeting notes, brainstorming sessions, project plans, research summaries, and personal workstreams. This update, now in preview and due to roll out worldwide in December, brings all that information directly into your agents’ grounding experience.

By selecting specific OneNote pages, makers can empower agents to provide responses that reflect real project context and decision history. This is especially helpful for roles that depend on ongoing notes, such as customer success, project management, operations, or research, where critical details often live outside traditional documents.

OneNote support also reduces the need to copy content into files or recreate notes elsewhere. Makers can simply choose the pages they want to include and let Microsoft 365 Copilot agents draw from them automatically during conversations and workflows.

To add this capability: Open Agent Builder, go to Knowledge sources, choose OneNote from the file picker, and select the pages you want to include. Learn more about knowledge sources in Agent Builder.

The bigger takeaway

The story of November 2025 isn’t just new features. It’s a shift in how work gets designed.

We’re moving toward a world where organizations don’t just automate steps—they design intelligent systems of work, where AI agents handle complexity, people apply judgment, and businesses operate with more speed, clarity, and resilience.

And we’re just getting started.

Stay up to date on all things Copilot Studio

Check out all the updates as we ship them, as well as new features releasing in the next few months here: What’s new in Microsoft Copilot Studio.

To learn more about Microsoft Copilot Studio and how it can transform productivity within your organization, visit the Copilot Studio website or sign up for our free trial today.

The post What’s new in Microsoft Copilot Studio: November 2025 appeared first on Microsoft Copilot Blog.

This model becomes even more powerful when applied to work. In Microsoft 365 Copilot, it connects to Work IQ to unlock insights, market research, and strategic planning—reasoning across your meetings, emails, docs, and more.  

Microsoft 365 Copilot: Your AI assistant

GPT-5.2 is accessible in the model selector in both Copilot Chat and Copilot Studio, so you have the latest innovation to solve your unique business challenges and create more compelling agent experiences.

Want to see GPT-5.2 in Copilot in action? Select GPT-5.2 in the model menu in Copilot, and try one of these prompts:

• “Based on prior interactions with [person], give me 5 things that will be top of mind for our next meeting.”
• “Create side-by-side tables of the top 10 companies by market cap in 2000 and 2025. Then analyze the shifts in industry dominance, innovation cycles, and geopolitical trends—and connect any insight to implications for our 2025 strategic planning.”
• “Give me the top 3 strategic insights from today’s meeting, and show how they connect to our objectives and key results and upcoming milestones.”

Today’s launch of GPT-5.2 is just the latest in our continued commitment to offer model choice in Microsoft 365 Copilot—so our customers have access to the best models from a variety of model makers and can pick the model that’s best for the job at hand. Copilot delivers cutting-edge AI innovation, tuned for work and tailored to your business needs—with the security, compliance, and privacy that you expect from Microsoft.

Discover more with Microsoft 365 Copilot

Get started today

We’re excited to get you secure access to this innovative technology on the day of its release. GPT-5.2 will begin rolling out to users with a Microsoft 365 Copilot license today and is expected to reach all users in the coming weeks. Rollout to Microsoft 365 Premium subscribers will begin early next year.

GPT-5.2 in Copilot Studio is available starting today in early release cycle environments. Agents running currently with GPT-5.1 will automatically move to GPT-5.2. 

Our team will continue to refine the experience based on your feedback as we build the future of work together.

Learn more about Microsoft 365 Copilot and Microsoft Copilot Studio and start transforming work with Copilot today. Learn more about GPT-5.2 from OpenAI here. For the latest research insights on the future of work and generative AI, visit WorkLab. 

The post Available today: GPT-5.2 in Microsoft 365 Copilot appeared first on Microsoft Copilot Blog.

Today’s leading organizations are going through an agentic business transformation. This change takes AI from concept to measurable impact, by automating existing workflows and using agents to enhance productivity and reinvent entire functions. Copilot Studio, Copilot’s agent platform, provides a fully managed solution for accomplishing this.

Using Copilot Studio, organizations around the world can quickly bring the benefits of AI to their business. Copilot Studio empowers companies to streamline and automate their processes with agentic workflows, create single-purpose agents to solve specific problems, and develop multi-agent solutions that drive measurable business outcomes at scale. The result: a scalable, secure, and governable foundation that supports the needs of IT administrators and business owners measuring return on investment (ROI). This system accelerates agentic transformation by delivering speed-to-value without sacrificing quality or control.

At the same time, with Microsoft 365 Copilot, users can easily use AI to improve their personal and team productivity. This tailored experience for Microsoft 365 Copilot users offers a fast, guided way to set up agents to support your work and automate everyday tasks, removing them from your plate.

Today, we’re excited to share new capabilities in Copilot Studio that support all of these scenarios and groups that use our product, making it easier for makers and administrators to shape agent behavior, enforce organizational standards, and extend functionality with AI.

End-user improvements

Our Copilot Studio experience for building agents and workflows, as well as our agent building capabilities in Microsoft 365 Copilot, continue to support agent creation for all users, from professional makers and IT administrators doing enterprise AI transformation, to employees building agents and workflows for their personal use. Recent updates focus on making the process simpler and more efficient.

What’s new in Microsoft 365 Copilot

• Redesigned creation experience: Build and refine agents through an improved conversational interface that guides users and taps into an expanded set of work-related knowledge sources.
• File generation with natural language: Agents built in Microsoft 365 Copilot, can now create Word, Excel, and PowerPoint files in seconds using natural language commands.
• Seamless upgrade path: Copy agents from Microsoft 365 Copilot to Copilot Studio in one click, unlocking advanced AI agent customization.
• Workflows agent in Microsoft 365 Copilot: Create, build, and manage workflows using natural language in chat. Boost productivity with quick scenarios like daily triage, weekly digests, and lightweight approvals—all directly within Copilot.

Maker improvements

IT application developers and other professional makers in the business can already build sophisticated agents in Copilot Studio without needing to code. Copilot Studio includes capabilities such as connecting and acting across more than 1,400 systems of record via Model Context Protocol (MCP), Power Platform connectors, and the Microsoft Graph. It also includes broad and deep tooling like autonomously writing and executing code, delivering rich out-of-the-box agent analytics and ROI measurement, and more, all built on the Microsoft governance and security platform. We’re excited to share new capabilities that give makers even more flexibility and control to design enterprise agents tailored to their unique organizational needs.

• Choose your own model: Select from leading options like OpenAI’s GPT‑5, Anthropic’s Sonnet 4.5, and Opus 4.1 to power your agents. This empowers you to tailor agent intelligence to fit your specific business scenario, optimize performance, experiment with new capabilities, and deliver agents that meet your organization’s unique needs.
• Ensure agents are ready for launch, and don’t regress over time, with Evaluations: Built-in evaluation tools help you test agents against real-world scenarios, compare versions, and track performance with clear metrics. Evaluations can give teams greater confidence that their investments are performing as expected.
• Computer use: Agents can now automate tasks across apps and websites, using secure Windows 365 experiences—from hosted browsers for quick web automation to IT-managed Cloud PC pools for rapid scalability.

Admin improvements

As agents become central to automating work and transforming workflows, Copilot Studio is introducing new governance and protection capabilities designed to help organizations maintain strong oversight.

• Expanded agent analytics: Clear insights into connected and child agent performance, detailed visibility into Copilot Credits consumption and limits, AI-generated summaries of top analytics insights, and interrogating analytics using natural language.
• Real-time protection: Copilot Studio integrates with Microsoft Defender and other trusted security platforms, providing continuous monitoring and protection against threats like prompt injection—helping every agent run more safely.
• Microsoft Entra Agent ID: Every agent made in Copilot Studio now gets a unique Microsoft Entra Agent ID, making it simple to register, manage, and govern your entire agent fleet.

Agent 365 and Copilot Studio: Unified control for agents

Agents are handling more responsibilities across enterprise operations and Copilot Studio is your launchpad for building them. With the introduction of Agent 365—the control plane for agents, the rich governance and management capabilities we offer today including sharing controls, advanced connector policies, agent inventory, zoned environment management, and more, will also be surfaced in the Agent 365 platform when using agents built in Copilot Studio.

Additionally, in Copilot Studio, makers can now build agents that use the new Agent 365 MCP servers. These servers allow agents to schedule meetings in Microsoft Teams, draft documents in Word, send emails in Outlook, and update customer relationship management (CRM) records in Microsoft Dynamics 365. This supports delivery of intelligent, compliant workflows and agents with built-in audit trails and granular policy enforcement—all from one platform.

Agent 365 is available starting today in Microsoft 365 Admin Center with Frontier, Microsoft’s early access program for the latest AI innovations.

Scale to the Frontier Firm with control

True transformation happens when agents are built for scale, governed for compliance, and measured for impact. Copilot Studio delivers that foundation, so organizations can build enterprise multi-agent systems, automate workflows with precision, and reimagine processes while minimizing risk.

EY’s results show what’s possible when you invest in a comprehensive agent platform, built on Microsoft. They are just one of many enterprise organizations implementing agents with Copilot Studio. In this case, their PowerPost Agent built on Copilot Studio led to major improvements in journal processing:

• 95% reduction in lead time
• 37% cost savings¹

Implementing the PowerPost Agent with Microsoft Copilot Studio has fundamentally transformed our journal processing. What once took minutes now happens in seconds—streamlining workflows and improving accuracy.

—Paula Korczak, Product Manager for General Ledger, EY

That’s the difference between cobbling together siloed agent platforms versus investing in a managed scalable agent platform like Copilot Studio: agents and agented process design that is repeatable, auditable, and scalable.

Get started today

To learn more about Copilot Studio and how it can transform your organization’s productivity, visit the Copilot Studio website and sign up for a free trial today. Take the Agent Readiness Assessment to benchmark your organization’s agent maturity across five critical areas—strategy, data, process, culture, and security—and get a personalized report to accelerate scalable agent adoption and drive agentic business transformation.

Want to explore all of Copilot Studio’s adoption content? Visit the Copilot Studio adoption page.

¹ EY redesigns its global finance process with Microsoft Power Platform

The post Why Microsoft Copilot Studio is the foundation for agentic business transformation appeared first on Microsoft Copilot Blog.

In this edition of our monthly roundup, we’re recapping the most exciting new features Microsoft Copilot Studio released in October 2025.

Build and optimize agents

Validate agents at scale with evaluations for automated testing

Agent quality just became significantly easier to measure and improve. With the automated agent evaluation experience, now available in public preview, makers can systematically test and validate their Copilot Studio agents at scale. Instead of running scenarios one by one, they can build and execute evaluation sets directly from the agent or the Test Pane, delivering structured, repeatable insights both before and after publishing.

This new experience offers flexibility in how evaluation sets are created. Makers can upload files with predefined questions and answers, reuse recent Test Pane queries, add cases manually, or instantly generate queries using AI. This approach ensures that test coverage spans organization-specific scenarios while also incorporating AI-suggested questions based on agent metadata and topics, providing a comprehensive view of performance.

Evaluations are powered by a robust grader framework that gives makers control over how accuracy is measured. Options range from strict checks such as Exact Match and Partial/Contains, to semantic comparisons like Similarity and Intent Match, and even AI-powered metrics including relevance, completeness, and groundedness. Each test delivers clear pass/fail results, detailed scores, and drill-down views into the knowledge and topics used.

For cases where reference answers are critical, makers can define expected responses manually or upload them in bulk, ensuring evaluations remain precise, transparent, and aligned with business expectations. AI further the Analytics tab in Copilot Studio accelerates validation by automatically generating test sets that can be executed immediately with AI metrics graders or combined with manual and uploaded sets for broader coverage.

These capabilities introduce a scalable, repeatable framework for agent quality, helping teams identify gaps early, reduce surprises in production, and track improvements over time. While multi-turn testing and additional graders are on the roadmap, this public preview represents a major leap forward in automated validation. 

Evaluations are available now in public preview. You can access them from the agent or test pane by selecting Evaluation.

Build with the latest OpenAI models in Copilot Studio

Copilot Studio continues to evolve with new model updates that improve performance and expand flexibility for makers. Depending on use case and application, different models may provide better responses to users. We’re committed to providing model choices that work for your business processes.

Starting October 27, 2025, GPT-4.1 became the default model for all newly created agents, replacing GPT-4o. Testing shows meaningful gains in both latency and response quality, helping agents deliver faster, more consistent results. GPT-4o will remain available through November 26, 2025, and agents in production will continue to leverage this model until then. However, you can update the model and opt in to GPT-4.1 today through the model-selection experience.

In addition, Copilot Studio is expanding availability of the GPT-5 family of models, first introduced in August 2025. Makers can now use GPT-5 Auto, GPT-5 Chat, and GPT-5 Reasoning not only in test environments but also in deployed agents. These models bring enhanced reasoning, richer dialogue capabilities, and more flexible problem-solving for complex scenarios. Please note that GPT-5 models remain in public preview and are not yet recommended for production use.

Together, these updates give makers access to the latest OpenAI advancements while maintaining continuity for existing agents. You continue to have top model choice at your fingertips to help create and deploy more accurate and effective agents at scale.

Speed up agent flow execution with express mode

Flow execution just got faster in Copilot Studio. Express mode, now in preview, optimizes agent flows to increase the likelihood that they’ll finish the flow within two minutes. This avoids agents or apps timing out while they wait for a response.

Express mode works best in flows that are logic-heavy but data-light. It limits flows to under 100 actions and smaller payloads so that the entire execution is more streamlined. For scenarios where large data sets needs to be moved or loops occur to iterate over large arrays, makers should test both with and without express mode.

This feature is in public preview and on by default. You can find the express mode toggle located on the flow’s Overview page in the editor.

Enable file uploads in omnichannel conversations

Copilot Studio now supports file uploads for custom agents in omnichannel scenarios. This means users can share images, documents, and other supported file types directly during agent interactions. This enhancement makes conversations more dynamic and context-rich by letting customers provide relevant files like receipts, forms, or photos right in the chat.

By enabling end user file uploads, agents can analyze attachments in real-time and deliver more accurate, personalized responses. This is a critical capability for customer service and contact center scenarios, where exchanging documents or screenshots is often key to resolving issues quickly. The feature also unlocks richer use cases for image analysis and document-based reasoning, improving both response quality and customer satisfaction.

File upload support is enabled by default for omnichannel custom agents, with optional controls available for agent makers to restrict supported file types in the agent manifest. All file types supported by Microsoft 365 Copilot are allowed up to 5MB (unless admins add restrictions).

This update enhances both the maker and end-user experience, and brings a richer more comprehensive level of service for end users relying on the agent for support.

Access external files and data with Model Context Protocol resources

Copilot Studio now supports Model Context Protocol (MCP) resources, expanding what agents can do with existing MCP connections. Makers have been able to use MCP tools to trigger actions and retrieve information. Now with resources support in preview, agents can read external content like files, API responses, or database records directly through MCP. This brings richer, real-time context into every interaction.

MCP resources act as file-like data objects that agents can query and reference during conversations. This allows agents to access customer-specific or system-specific content dynamically, without manual updates or re-training. For example, an agent could read the latest policy document stored in an MCP resource, summarize an uploaded file, or use current data from an API—securely and in context.

This enhancement builds upon the existing MCP integration in Copilot Studio, supporting deeper connections between agents and the systems they support. MCP resources are available now in public preview and are on by default for supported environments.

Measure and improve performance

Measure the return on investment (ROI) for conversational agents

Organizations can now view the ROI of conversational agents in Copilot Studio to calculate how much time and money the agent saves compared to other methods. Already available for autonomous agents, this enhancement, now generally available, gives teams a unified view of how all agent types drive direct business impact.

From the Analytics tab, makers can configure savings settings for each agent. This is where you define how much time or cost is saved per interaction or workflow. Copilot Studio then aggregates these metrics automatically. The resulting ongoing view helps quantify the business value agents deliver through reduced manual effort, faster resolutions, or process efficiencies.

By expanding savings analytics to include conversational agents, Copilot Studio helps organizations evaluate agent performance and impact consistently across their agent portfolio. With this capability, right inside the Analytics tab in Copilot Studio, makers can make data-driven decisions about where to invest and improve.

Analyze user questions by theme

Copilot Studio now helps makers understand agent performance by intelligently and automatically grouping user questions into themes. The themes give you category-level insights into customer intent and frequent topics, with a more manageable number of groups.

In the Themes list, you can see key metrics such as question volume, response rate, and user satisfaction. This at-a-glance overview makes it easier to see which topics your agent handles well and focus on areas where it may need refinement. Makers with the appropriate permissions can also drill down into each theme to review specific user questions, agent responses, and related metrics. This deeper visibility helps identify patterns in user intent, uncover gaps in coverage, and guide targeted improvements to knowledge and content.

The feature is automatically available for agents that use generative answers and have received at least 50 user questions within the past seven days. Once enabled, insights appear directly in the analytics dashboard, no further setup is required.

By organizing user questions into themes, Copilot Studio gives makers a clearer view of what customers are asking for and how effectively agents are responding. This helps the team continuously improve agent responses for their customers by making data backed improvements to their knowledge sources.

Test and debug faster with an improved activity map

Test and troubleshoot Copilot Studio agents faster and more intuitively, thanks to a series of updates to the activity map and testing experience. These enhancements create a more cohesive view of how agents reason over data and user queries to respond. That, in turn, helps makers debug efficiently and refine performance with less context switching.

Makers can now view the transcript and activity details together, eliminating the need to toggle between separate views. This unified view provides a clearer picture of how each session unfolds, drawing from user input through the agent’s reasoning and response generation. The updated layout also lets makers pin sessions, adjust visible columns, and submit feedback on session details directly to Microsoft—improving collaboration and visibility.

It is now easier then ever to navigate activity data, understand the agent’s chain of thought, and connect analytics insights to individual sessions for deeper evaluation. These enhancements are generally available, with continued refinements releasing progressively across environments.

Manage and govern at scale

Control org-wide sharing of agents in Copilot Studio lite

A new admin control in the Microsoft 365 Admin Center, now generally available, gives organizations stronger governance over how agents created in Microsoft 365 Copilot are shared across the tenant. Admins can now restrict or disable organization-wide sharing of agents built in Copilot Studio lite (formerly known as the agent builder). This ability helps prevent oversharing while supporting safe adoption at scale.

From within the Microsoft 365 Admin Center go to Copilot > Settings > Data Access > Agents page, admins can choose who is allowed to share agents with the entire organization: all users (default), no users, or specific users and groups. When you place restrictions on sharing, the “Anyone in your organization” option in the agent-sharing dialog is disabled. Makers can see a tooltip explaining the policy. Existing access remains unchanged, but makers must comply with the defined settings before updating or broadening sharing.

This control helps ensure that agent collaboration aligns with organizational policies and regulatory requirements. This is particularly important for organizations in spaces like finance, healthcare, and government. By bringing this configuration directly into the Microsoft 365 Admin Center, admins can manage agent governance alongside other Microsoft Copilot and AI settings, simplifying oversight and reducing risk.

Stay up to date on all things Copilot Studio  

Check out all the updates live as we ship them, as well as new features releasing in the next few months here: What’s new in Microsoft Copilot Studio. 

To learn more about Microsoft Copilot Studio and how it can transform your organization’s productivity, visit the Copilot Studio website or sign up for our free trial today.

The post What’s new in Copilot Studio: October 2025 appeared first on Microsoft Copilot Blog.

Start building apps and workflows with Copilot today

Imagine you’re preparing for a product launch. With a few multi-turn interactions, Copilot helps you build what you need for success:

• Apps: Create an app for a product launch process where teams can track launch milestones, assign tasks, and view campaign progress in a dashboard.
• Flows: Send a Teams update every Monday with upcoming launch deadlines and key tasks from Planner. Post reminders for approval deadlines in Teams channels.
• Agents: Build an agent that answers product launch questions—like what the next milestone is, how to submit creative assets, or when the launch event is—using SharePoint resources and Teams conversations.

Build working apps in minutes

Copilot now includes App Builder, making it easy to create and deploy apps in minutes, no database setup required. Work with App Builder to create and refine dashboards, charts, calculators, lists, and any other interactive element you can dream up. You can preview and refine your app, over multiple edits and comments, without leaving Copilot.

The experience is grounded in your Microsoft 365 content, including documents, presentations, spreadsheets, and notes, and can even generate and store new data using Microsoft Lists as a backend. Sharing is just as simple: Distribute your app with a link, just like you would share a document.

Learn more from the people who built App Builder.

Turn your idea into an app with Copilot

Automate workflows in seconds

With the new Workflows agent, Copilot can help you automate tasks like sending emails and reminders, managing calendars, and sharing team updates. Just describe what you want, and Copilot converts your words into automated flows across Outlook, Teams, SharePoint, Planner, and services like Approvals.

As the flow builds, you’ll see each step in real time, making it easy to follow and understand the workflow. If you want to add more steps, or adjust behaviors, you can make requests in the same conversation with Copilot.

Workflows is optimized for end users but built on the same infrastructure that powers Agent Flows in the full Copilot Studio experience. This shared foundation delivers enterprise-grade reliability to personal automation.

Learn more from the people who built Workflows.

Create your ideal workflow with Copilot

Create personalized, work-grounded agents

Built into Copilot, the lightweight Copilot Studio experience makes it easy to create productivity-focused agents grounded in your work. Copilot Studio turns your words into a fully functional agent with structured logic and clear instructions. Earlier this year, we enhanced Copilot Studio to connect agents more deeply to your work, pulling from SharePoint, meeting transcripts, chats, emails, and external systems like ServiceNow and Jira.

When you’re ready to scale, the full Copilot Studio experience unlocks advanced workflows, model selection, collaborative multi-agent systems, and more—taking you from productivity agents to IT-led, enterprise-wide solutions.

Learn more from the people who built Copilot Studio.

Secure, governed, and integrated with Microsoft 365 Copilot

Microsoft 365 Copilot is built on enterprise-grade security, compliance, and reliability. App Builder, Workflows, and Copilot Studio lite are built on these same principles. These agents respect user context, enforcing individual permissions and role-based access to support governance. They are available exclusively through Microsoft 365 which helps ensure all activity stays secure, compliant, and aligned with organizational policies.

For admins, management is streamlined with unified permissions, visibility, and controls across the organization. Access to these conversational AI building tools can be managed in the agent inventory section of the Microsoft 365 admin center, so there’s no need for one-by-one guardrails. This allows for granular control at the group level, helping to ensure that only approved individuals can create, use, or share apps, flows, and agents, while maintaining compliance with organizational policies.

Build with Copilot today

App Builder and Workflows are now available in the Agent Store for customers in the Frontier program, and you can easily create your own personalized agent by selecting “Create agent” in Copilot. Microsoft 365 Copilot makes it easy to build what you need, whether it’s an app, a workflow, or an agent.

Learn more about Microsoft 365 Copilot, Workflows, App Builder, and Copilot Studio. For the latest research insights on AI and the future of work, visit WorkLab.

The post Microsoft 365 Copilot now enables you to build apps and workflows appeared first on Microsoft Copilot Blog.