Estimated reading time: 15 minutes

The Power Apps MCP (Model Context Protocol) Server is now in public preview. It exposes three tools — invoke_data_entry, request_assistance, and log_for_review — that let AI agents automate tasks inside model-driven apps with built-in human supervision via a redesigned agent feed. This guide covers every feature, technical detail, current limitation, and step-by-step setup path.

What Is the Power Apps MCP Server?

The Power Apps MCP Server is an open-protocol tool server that exposes Power Apps model-driven app capabilities as callable tools for AI agents. It uses the Model Context Protocol (MCP) — an open standard for connecting large language model applications to external data sources and tools — to create a standardized bridge between any MCP-compatible AI agent and your Power Apps environment.

Configured through Microsoft Copilot Studio, the Power Apps MCP Server gives your agent access to three predefined tools that interact directly with your app and its underlying Microsoft Dataverse environment — with no custom connectors, custom APIs, or bespoke integration code required.

Important: This feature replaces the earlier Copilot Studio activity-based agent feed. It is not a parallel feature — it is the successor.

Why Does the Power Apps MCP Server Matter?

Before MCP, connecting an AI agent to a Power Apps model-driven app required custom integrations that were slow to build, hard to maintain, and coupled tightly to specific app versions. The Power Apps MCP Server removes that friction by making apps reusable components in the AI ecosystem — any MCP-compatible agent can invoke your app’s capabilities using the same standardized protocol.

The underlying technology isn’t new. Microsoft first validated it as the form fill assistance feature inside Power Apps, which gained strong adoption and user feedback. The Power Apps MCP Server is that same technology promoted from a single-purpose in-app feature to an enterprise-grade platform capability available to any agent across your organization.

The Broader Microsoft MCP Strategy

Understanding this feature in isolation misses half the picture. At Microsoft Ignite 2025, Microsoft launched MCP servers across its entire business application stack simultaneously:

This is a coordinated platform bet: MCP becomes the universal interface layer between AI agents and Microsoft’s business application stack. Industry analysts have described MCP as “rapidly emerging as a universal interface to enterprise data in the AI era.” If you are building agents on any part of the Microsoft ecosystem, understanding MCP is now a core skill — not an advanced specialization.

The Three Power Apps MCP Tools: Full Technical Breakdown

This is the section most coverage gets wrong by treating the MCP Server as a single feature. In reality, it exposes exactly three discrete tools in the current preview, each with a distinct purpose, behavior, and design pattern.

Tool 1: invoke_data_entry — Automated Record Creation with Human Review

The invoke_data_entry tool is the headline capability. It extracts structured field values from unstructured inputs — emails, documents, images — and populates a Dataverse form for human review and approval before the record is saved.

How invoke_data_entry Works (End-to-End)

1. A Copilot Studio agent trigger fires — an email arrives in a monitored shared mailbox, a new file is uploaded to SharePoint, or any other configured trigger event.
2. The agent analyzes the incoming content against its natural language instructions to determine whether invoke_data_entry should be called.
3. If called, the tool receives the input content, the target Dataverse table name, and the list of column logical names to populate.
4. The tool processes the input, extracts relevant information, and populates a Dataverse form with suggested values for each mapped column.
5. A task appears in the agent feed — selecting it opens the data-entry review experience with the original source input on the left and the agent-populated form on the right.
6. The user reviews extracted values, makes any corrections, and saves the record to Dataverse

Supported Input Formats

invoke_data_entry accepts the following file formats: .pdf, .xlsx, .docx, .jpeg, .jpg, .png, .gif, .bmp

Supported Dataverse Column Types (Preview)

Currently supported: Single line of text (None format), Whole number, Decimal

Not yet supported: Choice fields, lookup fields, date/time columns, multi-line text, currency — this is the most significant current limitation for real-world deployments.

The Self-Improving Learning Loop

A critical detail buried in the documentation: the invoke_data_entry tool improves based on user corrections. When users correct the agent’s suggested field values in the review interface, those corrections feed back into improving the model’s extraction accuracy for that specific app and table. Early adopters who deploy and correct actively will have meaningfully better-performing agents than organizations that wait. There is a built-in first-mover advantage.

Writing invoke_data_entry Instructions

Always reference Dataverse columns by their logical names — not display names — in your agent instructions. Find a column’s logical name at: make.powerapps.com → Tables → [Table] → Columns → open the column. Using display names instead of logical names causes silent failures.

Sample agent instruction template:

You are the [business process] agent. Your job is to process incoming 
emails and create [record type] records in Dataverse.

When an email arrives:
1. Determine if it contains [relevant content].
2. Use the invoke_data_entry tool to create a record with the 
   following columns:
   - cr3ea_title
   - cr3ea_customername
   - cr3ea_customeremail
   - cr3ea_destinationcity
3. If information is missing, still create the record with available 
   data — leave unknown fields empty.

You are the [business process] agent. Your job is to process incoming 
emails and create [record type] records in Dataverse.

When an email arrives:
1. Determine if it contains [relevant content].
2. Use the invoke_data_entry tool to create a record with the 
   following columns:
   - cr3ea_title
   - cr3ea_customername
   - cr3ea_customeremail
   - cr3ea_destinationcity
3. If information is missing, still create the record with available 
   data — leave unknown fields empty.

Tool 2: request_assistance — Blocking Human-in-the-Loop Handoff

The request_assistance tool pauses agent execution and creates a blocking task in the agent feed that waits for a human to complete an action before the agent can continue.

How request_assistance Works

When the agent calls request_assistance:

• An “In progress” activity appears in Copilot Studio for the agent run.
• A task is created in the agent feed for the business user.
• The Copilot Studio agent remains active and waiting.
• Once the human completes the action from the agent feed, control returns to the agent via callback.
• The agent resumes and completes its task

This is a synchronous, blocking operation — the key distinction from log_for_review.

When to Use request_assistance

Use this tool when the agent cannot proceed without human input:

• Required data is missing from the source document
• Information is ambiguous and requires domain expertise to interpret
• An approval gate is required before a high-stakes action
• Human judgment is mandatory for compliance or regulatory reasons

What a request_assistance Task Includes

• A configurable title (typically prefixed with a meaningful identifier like “Assistance needed: “).
• A description with relevant context fields.
• An optional navigation link directly to the relevant Dataverse record — so the reviewer can jump to the record without searching

Sample instruction template:

When this agent is triggered by the creation of a new [trigger event], 
request human assistance. Set the title by prefixing [field value] 
with "Assistance needed: ". Include [field1], [field2], [field3] in 
the description, and add a navigation link to the Dataverse record.

When this agent is triggered by the creation of a new [trigger event], 
request human assistance. Set the title by prefixing [field value] 
with "Assistance needed: ". Include [field1], [field2], [field3] in 
the description, and add a navigation link to the Dataverse record.

Tool 3: log_for_review — Passive Audit Trail for Completed Agent Actions

The log_for_review tool records completed agent work to the agent feed for passive human oversight — without blocking agent execution. The agent has already acted; this tool creates an auditable, reviewable record of what was done.

When to Use log_for_review

Use this tool when:

• The agent has sufficient information to act autonomously.
• The result needs human validation before being considered final or trusted.
• The action is easily revised or rolled back if the reviewer disagrees

Tasks created by log_for_review appear in the agent feed’s Completed tab, not as active tasks requiring immediate action.

What a log_for_review Task Includes

• Title and description of what the agent did
• An optional link to the Dataverse record the agent created or modified (can be created via the Dataverse MCP Server or referenced from context)

The Critical Design Decision: log_for_review vs. request_assistance

Choosing the right tool is one of the most important architectural decisions when designing an agentic Power Apps workflow.

The Redesigned Agent Feed

To support the three MCP tools, Microsoft completely rebuilt the agent feed. It is no longer a simple notification panel — it is a shared collaborative workspace where humans and AI agents work together inside the same model-driven app interface.

What Makers Control

• Granular task visibility — makers decide exactly which agent tasks are surfaced in the feed, not just whether agents are “on” or “off”.
• Up to 10 agents per app — a single model-driven app supports up to 10 simultaneous autonomous agents.
• One-click Copilot Studio access — the App Designer Agents tab includes direct links to edit agents in Copilot Studio.
• Agent eligibility validation — the App Designer properties pane shows which requirements a published agent must meet before it can be added

What Business Users See

• Side-by-side comparison view for invoke_data_entry tasks — original source on the left, agent-populated form on the right.
• Direct record navigation — tasks link directly to the relevant Dataverse record, eliminating search friction.
• Agent performance metrics — operational visibility into completed tasks, tasks needing assistance, and overall agent activity.
• In-line feedback — a feedback button on each invoke_data_entry task lets users submit compliments, issue reports, or suggestions, directly improving tool accuracy

Current Governance Limitation

Only the owner of an agent can currently view and supervise that agent’s data in a model-driven app. Role-based delegation is not yet available. This is a significant constraint for enterprise deployments and is expected to be addressed before general availability.

Two Types of Agents in Power Apps Model-Driven Apps

A frequently confused distinction: model-driven apps now support two fundamentally different agent types that serve different purposes and coexist in the same app.

Autonomous agents (Copilot Studio): Perform background tasks, use the MCP tools, surface work in the agent feed, require human supervision. This is what the Power Apps MCP Server enables.

App assistant agents: Conversational agents embedded in the app’s Copilot Chat experience. They have custom topics, knowledge sources, and access to M365 Copilot intelligence. They answer user questions interactively — they do not process background work via MCP.

Both live under the Agents tab in App Designer and can coexist in the same app. The most powerful pattern combines them: the app assistant agent answers user questions about data while the autonomous agent processes incoming work in the background via MCP.

The app assistant agent is a rename of the previous “interactive agent” experience. Agents created with the previous configuration now appear as the App assistant agent.

M365 Copilot Chat Now Embedded in Model-Driven Apps

Announced in the same February 2026 wave: Microsoft 365 Copilot chat is now available directly inside Power Apps model-driven apps (public preview). Users can ask questions, reason over in-app Dataverse data, and connect insights from documents, emails, and Teams conversations — without leaving the application.

First-party agents like Researcher and Analyst are available within this experience, as well as any custom Copilot Studio agent configured as an app assistant.

The architectural pattern that emerges: autonomous agents (via MCP + agent feed) handle incoming, background work while M365 Copilot Chat handles user-initiated, conversational intelligence in the foreground. Together, they transform a model-driven app from a data entry surface into a fully AI-augmented business workspace.

M365 Copilot Chat in model-driven apps requires M365 Copilot licensing and is enabled by Power Platform administrators at the environment level, with per-app enable/disable controls for makers.

Dataverse MCP Server: The Essential Data Layer Complement

While the Power Apps MCP Server gets the headlines, the Dataverse MCP Server reached general availability in the same release wave — a detail worth paying close attention to.

What the Dataverse MCP Server Provides

• Natural language interface: Ask questions in plain language and get real-time responses from your Dataverse environment.
• Table exploration: View tables and their descriptions programmatically.
• Data read and write: Read records from tables; insert or update records directly.
• Knowledge search: Search knowledge base content stored in Dataverse.
• Prompt execution: View and execute prompts available within Dataverse

The Power Apps + Dataverse MCP Combination Pattern

A Copilot Studio agent can use both servers together for end-to-end agentic workflows:

1. Use the Dataverse MCP Server to read existing records and reason about them.
2. Use the Power Apps MCP Server to create new records via invoke_data_entry (with human review) or log actions via log_for_review

This combination creates agentic workflows that are both capable (full data access and manipulation) and governed (human supervision at every critical step).

The Dataverse MCP Server is also accessible from outside the Power Platform — GitHub Copilot, Copilot Studio, and any MCP-compatible agent can query your Dataverse environment using the standardized protocol rather than custom API integrations.

February 2026 Power Platform Release Wave: Full Context

The Power Apps MCP Server launched alongside a significant February 2026 release wave. Here is the complete picture:

Generally Available (GA)

Code Apps in Power Apps — Full code-first web apps built with React, Vue, or any framework, deployed to Power Apps with enterprise governance. Every code app automatically becomes a governed Power Platform asset. Accelerated by AI-assisted code generation.

Theme copy-paste for canvas apps — Copy and reuse canvas app themes — including colors, typography, and styling tokens — across other apps as YAML. Enables design governance at scale.

Confirm() function as Fluent dialog — Proper modal confirmation dialogs aligned with Fluent UI design principles, replacing browser-native dialogs when modern controls are enabled.

Public Preview (New This Wave)

Power Apps MCP Server + enhanced agent feed — Covered in detail throughout this article.

M365 Copilot Chat in model-driven apps — Conversational Microsoft 365 Copilot intelligence embedded directly inside Power Apps model-driven apps.

Modern Card control for canvas apps — A single layout-aware control for presenting structured information (summaries, previews, tiles). Auto-adapts to vertical or horizontal layouts. Aligned with Fluent UI design principles. Reduces layout complexity compared to composing multiple classic controls.

Move canvas apps from the default environment — Governance tooling enabling administrators to migrate canvas apps and custom SharePoint forms from the default environment to designated managed environments. Supports manual migration (Power Platform Admin Center) or automated migration via the Power Platform for Admin v2 Connector. Options include keep-as-is, quarantine, or delete the original.

The Strategic Pattern

Microsoft is advancing two parallel tracks simultaneously: the agentic layer (MCP, agent feed, Copilot Chat) and the governance and development foundation (code apps, managed environments, Fluent UI controls). Both tracks must advance together for enterprise adoption to succeed — powerful agents without governance create risk, and governance without capability creates friction.

Technical Limitations and Known Constraints

No complete guide omits the constraints. Here is a complete list of current limitations as of the February 2026 public preview:

Language support: English only. No announced timeline for additional language support.

Dataverse column types: invoke_data_entry supports only single line of text (None format), whole number, and decimal columns. Choice fields, lookup fields, date/time, multi-line text, and currency are not yet supported. This is the most significant real-world constraint.

CRUD operations: The current preview supports data creation via invoke_data_entry. Read, update, and delete operations via MCP tools are on the roadmap but not yet available.

Agent ownership: Only the agent owner can view and supervise agent data in the model-driven app. No role-based access delegation is available yet.

Environment availability: US early release cycle environments only in the initial rollout. Global rollout follows standard weekly deployment schedule.

Production use: As a preview feature, this is not supported for production workloads. Subject to supplemental terms of use and potential breaking changes before GA.

App limit: Maximum 10 autonomous agents per model-driven app.

App type: Model-driven apps only. Canvas apps do not currently support the agent feed or MCP tools.

How to Set Up the Power Apps MCP Server: Step-by-Step

Here is the practical implementation path based on the official documentation:

Step 1: Provision a US early release environment Required for the current public preview. This can be configured in the Power Platform Admin Center under environment settings.

Step 2: Build your Copilot Studio agent Create a new agent in Microsoft Copilot Studio with appropriate triggers — shared mailbox monitoring, SharePoint folder uploads, or other supported event types.

Step 3: Configure the Power Apps MCP Server in Copilot Studio Add and enable the Power Apps MCP Server tool from within your Copilot Studio agent configuration. Select which specific tools (invoke_data_entry, request_assistance, log_for_review) your agent needs.

Step 4: Write agent instructions using logical column names Write natural language instructions referencing the MCP tools by name and Dataverse columns by their logical names. Verify all logical names in make.powerapps.com → Tables → Columns.

Step 5: Publish the agent An agent must be published before it can be added to a model-driven app. Verify all eligibility requirements in the App Designer properties pane.

Step 6: Add the agent to your model-driven app In the App Designer, go to the Agents tab → under the Agent feed dropdown → In your environment → locate your agent → select Add to app.

Step 7: Save, publish, and test the app Preview of the agent feed in App Designer is not currently supported. Save and publish the app, then play it to verify the agent feed appears correctly.

Step 8: Test with real content and iterate on corrections Run the agent against sample emails or documents. Correct any extraction errors in the agent feed review interface — corrections actively improve the tool’s future accuracy.

Key Takeaways for Power Platform Practitioners

MCP is the integration standard of the agentic era. Microsoft has committed to it across Power Apps, Dataverse, Dynamics 365, and Power BI. Building agents on the Microsoft platform now means understanding MCP — full stop.

The request_assistance tool is the most underappreciated feature. Pausing an agent mid-execution, surfacing a structured human task, and resuming after a callback response is a powerful enterprise pattern. It is not “human-in-the-loop” — it is “human-as-a-participant-in-the-workflow.”

Column type support is the most important limitation to track. Most real-world Dataverse forms use choice fields, lookups, and dates. Until invoke_data_entry supports these types, production applicability is limited to simpler text-and-number scenarios.

The learning loop creates a first-mover advantage. Organizations that deploy early and correct actively will have better-performing agents than those who wait. Corrections compound over time. This is a deliberate architectural choice by Microsoft that rewards early adoption.

Agent feed UX design is a new discipline. Power Platform developers have never designed supervision interfaces before. The agent feed is a new kind of UI surface where users review AI work rather than do the work themselves. Start thinking about this design challenge now, before your first production deployment.

The Dataverse MCP Server (now GA) is the missing power multiplier. Combining the Dataverse MCP Server (read/write data) with the Power Apps MCP Server (human review, supervision) unlocks end-to-end governed agentic workflows. Use them together.

Key Resources

• Power Apps MCP Server — Microsoft Learn
• Add agents to your model-driven app — Microsoft Learn
• February 2026 Power Platform feature update — Microsoft Blog
• Microsoft Ignite 2025 session BRK323
• Power Apps Community Forum

Have you started experimenting with the Power Apps MCP Server? Share your use cases and what limitations you’re hitting — connect on LinkedIn or drop a comment