Wave 1 2026 Highlights Overview
Power Automate's 2026 Wave 1 release is the most significant architectural shift since the product was renamed from Microsoft Flow. The headline change is that flows can now be published as MCP-compatible AI agents — making them callable by any AI orchestrator that speaks the Model Context Protocol, including Microsoft Copilot Studio, Azure AI Foundry, and third-party agents.
Beyond MCP compatibility, Wave 1 introduces five connected improvements: a new Agent Flow flow type that runs autonomously without a fixed trigger schedule, AI reasoning steps built directly into the flow canvas using AI Builder GPT, deeper Microsoft Graph integration so agents can take real M365 actions, an updated DLP and governance framework for agentic scenarios, and a simplified getting-started path through the Power Automate portal's new Agent Studio experience.
Classic cloud flows (automated, scheduled, instant) continue to work exactly as before. Wave 1 does not deprecate anything — it adds new capabilities on top. You migrate to agent flows when the business scenario calls for autonomous decision-making, not as a blanket upgrade.
What Is MCP and Why It Matters for Automation
The Model Context Protocol (MCP) is an open standard, originally developed by Anthropic and now adopted broadly across the AI ecosystem, that defines how AI models communicate with external tools and data sources. Think of it as a universal API contract for AI agents: an MCP server exposes a list of typed tools with JSON Schema definitions, and any MCP-compatible AI client can discover and call those tools without bespoke integration work.
By making Power Automate flows publishable as MCP servers, Microsoft enables Copilot agents, Azure AI agents, and any standards-compliant orchestrator to invoke your automation logic as a named tool call — passing structured arguments and receiving structured results. Your existing approval workflow becomes a reusable capability in any agent's toolbox.
{
"name": "submit_purchase_order_approval",
"description": "Submit a purchase order for manager approval and return the decision.",
"inputSchema": {
"type": "object",
"properties": {
"poNumber": { "type": "string", "description": "Purchase order number" },
"amount": { "type": "number", "description": "Order value in USD" },
"vendor": { "type": "string", "description": "Vendor display name" },
"requestorUPN":{ "type": "string", "description": "UPN of the requestor" }
},
"required": ["poNumber", "amount", "vendor", "requestorUPN"]
},
"outputSchema": {
"type": "object",
"properties": {
"decision": { "type": "string", "enum": ["approved", "rejected"] },
"approver": { "type": "string" },
"comments": { "type": "string" }
}
}
}Power Automate generates this MCP tool manifest automatically when you publish an Agent Flow. You provide the description and parameter names; the platform handles the JSON Schema serialisation and the MCP endpoint hosting.
The New Agent Flow Type
The Agent Flow is a new flow type alongside Automated, Scheduled, and Instant flows. Instead of a fixed trigger, an Agent Flow is invoked by an AI orchestrator via MCP or by a Copilot Studio agent. Once invoked, it can run for minutes or hours, make its own decisions at AI reasoning steps, call other flows, query data sources, and adapt its path based on intermediate results.
import { PowerAutomateAgentClient } from "@microsoft/power-automate-agent"; const client = new PowerAutomateAgentClient({ tenantId: process.env.TENANT_ID!, clientId: process.env.CLIENT_ID!, clientSecret: process.env.CLIENT_SECRET!, }); // Invoke the Agent Flow as an MCP tool call const result = await client.invokeTool("submit_purchase_order_approval", { poNumber: "PO-2026-04192", amount: 14750, vendor: "Contoso Supplies Ltd", requestorUPN:"[email protected]", }); console.log(`Decision: ${result.decision} — by ${result.approver}`); // Decision: approved — by [email protected]
An Agent Flow can also invoke other Agent Flows as sub-agents, enabling multi-agent orchestration within the Power Platform — for example, a master procurement agent that calls separate vendor-lookup, budget-check, and approval sub-agents in sequence.
AI Reasoning Steps Inside Flows
Wave 1 adds a first-class AI Reasoning action to the flow canvas. Drop it anywhere in your flow, write a natural-language prompt, bind flow variables as context, and the step uses a hosted model (GPT-4o by default) to produce structured output you can route on. This eliminates the custom connector boilerplate previously needed to call Azure OpenAI from a flow.
{
"type": "AIReasoning",
"inputs": {
"prompt": "Analyse the invoice description: '@{triggerBody()?[''description'']}'. Is it a capital expense or operating expense? Reply with JSON: {\"classification\": \"capex|opex\", \"confidence\": 0-1, \"reason\": \"...\"}",
"model": "gpt-4o",
"outputSchema": {
"classification": "string",
"confidence": "number",
"reason": "string"
}
}
}The AI Reasoning step's structured output is directly available as dynamic content in subsequent actions — no JSON parse step required. Branch on classification to route capex invoices to the CFO approval path and opex invoices to the department manager path.
AI Builder GPT Integration
AI Builder's GPT model action has been substantially upgraded in Wave 1. It now supports grounding with SharePoint and Dataverse — meaning the model can retrieve relevant documents from a SharePoint library or Dataverse table before generating its response, without you needing to build a separate retrieval pipeline.
Configure grounding by pointing the AI Builder GPT action at a SharePoint site or Dataverse table. The platform handles chunking, embedding, and retrieval at query time. Use this for scenario such as: an HR agent that answers policy questions grounded in the company's SharePoint HR policy library, or a procurement agent that checks vendor contracts stored in Dataverse before recommending a supplier.
AI Builder GPT steps consume AI Builder credits. Each GPT action run deducts credits based on the number of tokens processed. For high-volume agent flows (thousands of runs per day), model the credit consumption before going to production and ensure your environment has sufficient AI Builder capacity allocated.
Microsoft Graph Integration for Agent Actions
The most impactful Wave 1 capability for enterprise automation is the new Microsoft Graph Agent Actions connector. Unlike the existing Graph HTTP connector (which requires you to construct REST calls manually), the Graph Agent Actions connector exposes named, semantically described actions that an AI orchestrator can select and invoke based on natural-language instructions.
// Actions the agent can select at runtime: "Create Teams channel for project" → POST /teams/{id}/channels "Send approval email with adaptive card" → POST /me/sendMail "Add user to SharePoint group" → POST /sites/{id}/groups/{id}/members "Create Planner task and assign to user" → POST /planner/tasks "Update SharePoint list item status" → PATCH /sites/{id}/lists/{id}/items/{id} "Get user's manager from AAD" → GET /users/{id}/manager
The agent selects which Graph actions to use based on the task description and available context. An onboarding agent, for example, can autonomously create the Teams channel, assign the Planner onboarding tasks, add the new hire to the correct SharePoint groups, and send a welcome email — all in a single Agent Flow run, with no hardcoded step sequence.
Rearchitecting Existing Approval Workflows as Agent Flows
Most organisations have approval workflows built as classic Automated flows — email arrives, parse subject, send approval, update SharePoint list, notify requester. These work fine but are brittle: exceptions (missing data, wrong approver, policy change) require manual intervention or escalation sub-flows.
Rearchitecting as an Agent Flow adds an AI reasoning layer that handles exceptions gracefully. The agent can look up the correct approver from AAD if the submitted one is on leave, identify missing required fields and ask the requester to resubmit, detect policy violations (amount exceeds limit for this cost centre) before routing, and choose between fast-track and standard approval paths based on risk scoring.
// Classic flow (rigid, exception-prone) Trigger: "New item in SharePoint list" Step 1: Get manager from AAD Step 2: Start and wait for approval Step 3: Update SharePoint item Step 4: Send notification email // Agent Flow (resilient, context-aware) Trigger: MCP invocation from Copilot Studio agent Step 1: AI Reasoning — validate inputs, classify request, identify approver Step 2: if (validation fails) → request missing info from requester via Graph Step 3: Graph Agent Action — send adaptive card approval to correct approver Step 4: AI Reasoning — assess approval response, check policy compliance Step 5: Graph Agent Action — update SharePoint + create Planner follow-up task Step 6: Return structured result to calling agent
Agent flows that take actions in M365 (sending emails, modifying SharePoint, creating Teams channels) must have explicit human-in-the-loop checkpoints for high-impact decisions. Microsoft's DLP policies for agent flows enforce connection restrictions, but your design must also include approval gates for any action that is irreversible or has compliance implications. Never let an agent autonomously approve its own requests — the approver must always be a different identity from the requestor.
Getting Started Checklist
Use this checklist to move from a classic approval flow to a Wave 1 Agent Flow in your environment:
- Check environment version. Agent Flows require a Power Platform environment running on the March 2026 or later service update. Verify in the Power Platform Admin Center under Environment > Version.
- Enable AI Builder. Ensure your environment has AI Builder enabled and has sufficient credits allocated for GPT steps (minimum 5,000 credits for a pilot).
- Review DLP policies. Add the Microsoft Graph Agent Actions connector to your DLP policy's Business data group so agent flows can use it.
- Create a service principal. Agent flows calling Graph need an app registration with the required Graph permissions (delegated or application, depending on scenario). Use Certificate credentials, not client secrets.
- Build the Agent Flow in Agent Studio. Open Power Automate > Agent Studio > New Agent Flow. Use the guided setup to define MCP tool inputs and outputs first, then build the flow logic.
- Publish as an MCP server. In Agent Studio, click Publish > MCP Server. Copy the MCP endpoint URL and add it to Copilot Studio or your Azure AI agent's tool registry.
- Set run history retention. Agent flows can run for hours. Set run history retention to at least 30 days and enable detailed logging for the pilot period.
- Establish a rollback plan. Keep the original classic flow active (but set to off) during the pilot. If the agent flow produces unexpected results, re-enable the classic flow immediately.
Key Takeaways
Power Automate Wave 1 2026 lets you publish flows as MCP-compatible AI agent tools — callable by Copilot Studio, Azure AI, and any MCP client without bespoke integration.
The new Agent Flow type runs autonomously on AI orchestrator invocation — no fixed trigger required — and supports multi-step AI reasoning between actions.
AI Reasoning steps expose GPT-4o reasoning directly on the flow canvas with structured output — no Azure OpenAI custom connector needed.
Graph Agent Actions let agents autonomously create Teams channels, send approvals, update SharePoint, and manage Planner tasks without hardcoded step sequences.
Always include human-in-the-loop checkpoints for irreversible or compliance-sensitive actions — governance policies restrict connections, but approval gates are your design responsibility.
Keep the original classic flow available during the agent flow pilot period — a rapid rollback path is essential for production confidence.
Ready to build AI agent workflows?
Our Power Platform team helps organisations migrate classic flows to Wave 1 Agent Flows, design MCP-compatible automation, and implement human-in-the-loop governance — all production-ready.