Tag: Dataverse

  • Entra Agent ID Gives Every Dataverse Agent Its Own Identity

    Entra Agent ID Gives Every Dataverse Agent Its Own Identity

    Diagram of Entra Agent ID Dataverse identities assigning security roles to individual AI agents

    On 6 August 2026, Microsoft announced Entra Agent ID for Dataverse. Every AI agent that touches Dataverse can now get its own dedicated identity in Microsoft Entra, show up as a first-class agent user in the environment, and receive security roles like any other principal. It matters because it retires the worst pattern in agent deployments today: agents doing real work under a borrowed human or service account with broad permissions and no attributable audit trail.

    Entra Agent ID makes agents first-class users in Dataverse

    The mechanics are straightforward, which is exactly what you want from an identity feature. An agent gets an Entra Agent ID, which is a real directory object, not a tag on someone else’s account. That identity maps to an agent user inside Dataverse. From there, everything an admin already knows how to do applies. You assign security roles scoped to exactly the tables and privileges the agent needs. You see the agent’s activity in audit logs under its own name. You manage its lifecycle in the same admin surfaces where you manage users, app registrations, and service principals.

    None of this is a new concept. Service principals have existed for years. What is new is that the plumbing now reaches agents specifically, so a Copilot Studio agent writing to Dataverse does not need to impersonate anyone. The identity is the agent’s own, end to end.

    Borrowed credentials were the governance debt every agent deployment carried

    I keep hearing the same story from people at other organisations rolling out agents. The agent works. It creates records, updates statuses, closes cases. Then security or internal audit asks a simple question: who updated this record? And the answer is a human’s name attached to actions no human took. Usually the maker’s account, because that is what the connection was created with. Sometimes a shared service account with System Administrator, because someone hit a permissions error six months ago and fixed it the fast way.

    That pattern is not a small smell. It breaks least privilege, because the agent inherits everything the borrowed account can do. It breaks auditability, because the log tells you a person did something they never did. And it breaks lifecycle management, because when the maker leaves the company and their account gets disabled, the agent dies with it. Poof. Production automation down because of an HR event.

    I made a version of this mistake myself building an early internal agent. The connection ran under my account, and every record it touched carried my name. Harmless until someone asked why I had modified two hundred records at 3 AM. I had not. The agent had. Explaining that distinction to an auditor without a dedicated identity is not a conversation you want twice.

    This also completes a picture Microsoft has been assembling all year. Dataverse as the agent data platform gave agents skills, knowledge sources, and feedback loops. What it did not have was an answer to the identity question. Skills tell an agent what to do. Identity determines what it is allowed to do and who is accountable when it does it. You cannot govern the first without the second.

    Agents that write to production Dataverse should migrate first

    Not every agent needs this on day one. A read-only agent answering questions from a knowledge source under a scoped service account is a low-grade risk. The agents that should move first are the ones writing to production data. Anything creating or updating records in tables that feed reporting, billing, or compliance processes. Those are the deployments where the audit trail question is not hypothetical, it is one incident away.

    The trade-off is real work. Each agent identity needs a security role designed for it, and designing least-privilege roles takes longer than granting System Administrator and moving on. You also add lifecycle overhead: more principals to review, more roles to maintain. I think that cost is worth paying, for the same reason I argued when the Dataverse plugin for coding agents shipped that running it as System Administrator was the wrong setup. Broad permissions are always faster until the day they are catastrophically not. The same principle applies when you are running a Power Platform licensing audit before you ship: knowing exactly which identities hold which permissions is far easier to audit up front than to untangle after the fact.

    If I were planning a rollout, I would inventory every agent connection today and flag any that resolve to a human account. That list is your migration order. In my experience, the teams that treat identity as a prerequisite ship slower in week one and faster every week after, because they never hit the retrofit project. If you are also thinking about how agent tools should be scoped and named so that least-privilege roles map cleanly to actual capabilities, How to Design Tool Definitions for Copilot Studio Agents is a useful companion read.

    Identity was the last missing layer under enterprise agents, and now the interesting question is how fast admins make it mandatory.

    Source: Secured and Governed your AI Agents: Microsoft Entra Agent ID for Dataverse (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Microsoft Ships the Dataverse Plugin to OpenAI’s Codex Marketplace

    Microsoft Ships the Dataverse Plugin to OpenAI’s Codex Marketplace

    Dataverse plugin Codex marketplace expansion showing a coding agent querying live schema

    On 28 July 2026, Microsoft shipped the Dataverse plugin for coding agents to the OpenAI and Codex marketplaces. The announcement is short, but the Dataverse plugin Codex marketplace expansion means any agent built on OpenAI’s coding stack can now query live Dataverse schema, table metadata, and real data instead of guessing column names from two-year-old tutorial content in its training set.

    I wrote about the Cursor marketplace drop when it happened. That felt like a test balloon. This is the follow-through, and it tells you something about where Microsoft thinks the moat actually sits.

    What a Codex Agent Gets: Live Schema, Metadata, and Query Tools

    The plugin gives a Codex-based agent the same tool surface the Copilot and Cursor versions get. It can list tables in a connected environment, inspect column logical names, walk relationships, read option set values, and run queries against real records. That sounds mundane until you have watched a coding agent confidently generate a plugin against new_customer_id when the actual column is cr7a2_customerid. Without live metadata, the output looks correct and fails on deploy. With it, the code is diffable against reality.

    The hallucination problem I described when the plugin first shipped was never a model quality problem. It was a missing context layer at build time. Codex agents had no sanctioned way to see your schema, so they interpolated from public tutorials. This closes that gap for anyone whose org standardized on OpenAI’s tooling.

    The Codex Marketplace Expansion Signals Dataverse Is the Moat

    Think about what Microsoft is doing here. They are distributing a first-party grounding tool into a direct competitor’s agent ecosystem. GitHub Copilot competes with Codex. Microsoft shipped there anyway.

    That only makes sense if you believe the coding assistant is interchangeable and the data platform is not. Microsoft is betting that developers will switch agents every eighteen months but their organisations will keep business data in Dataverse for a decade. Agent-neutral distribution is the correct call under that assumption. Cursor was proof of concept. OpenAI and Codex confirm the pattern: follow the developers, do not try to pull them back into VS Code.

    There is a quieter governance win too. Developers were already wiring community MCP servers from random GitHub repos into their agents, and platform teams had zero visibility into any of it. A first-party plugin installed from a known marketplace leaves an auditable trail. That matters more inside a large enterprise than any individual feature. If you want to understand the protocol underneath tools like this, How MCP Actually Works Under the Hood When an Agent Calls a Tool walks through the JSON-RPC handshake and capability negotiation in detail.

    Pro-Code Teams on Non-Microsoft Agents Are the Real Audience

    This is not a citizen dev feature. The audience is teams writing Dataverse plugins, custom APIs, PCF controls, and complex flows in source control, whose org happened to standardize on OpenAI’s agent stack instead of GitHub Copilot. Those teams were previously stuck choosing between an ungrounded agent or an unsanctioned community tool. Now they get the first-party path without changing editors.

    Two honest caveats. First, the setup mistake I keep seeing has not gone away: people connect the plugin with System Administrator credentials pointed at production. The sane configuration is still a dedicated app user with a least-privilege role scoped to a dev environment. The marketplace install being one click makes the lazy setup faster too.

    Second, this closes the hallucination gap and nothing else. Environment permissions, DLP policies, and security roles behave exactly as they did before. The plugin does not grant the agent any access your app user does not have, and it does not stop you from misconfiguring that app user. In my experience, the teams that get burned are the ones who treat schema grounding as a security boundary. It is not. It is a correctness tool. Schema grounding also sits inside a broader cost and measurement story — The Model Is the Cheapest Part of Every Enterprise AI Agent makes the case that grounding data and connector governance are where the real budget and hours go.

    If your team builds against Dataverse from Codex today, install this and you get real hallucination reduction on schema-dependent code. If your governance story is not sorted, you also get one more thing to register and scope. Both are true.

    The coding agents will keep changing names. The platforms that ship their grounding everywhere are the ones planning to still be here when they do.

    Source: Dataverse Plugin for Coding Agents: OpenAI and Codex Marketplace Expansion (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • The Model Is the Cheapest Part of Every Enterprise AI Agent

    The Model Is the Cheapest Part of Every Enterprise AI Agent

    Cost breakdown diagram showing the model as the smallest layer in enterprise AI agents, beneath data grounding, governance, and measurement

    Every agent conversation I get pulled into starts with the same debate. Opus 5 or GPT. Copilot Studio’s default model or bring-your-own. Someone has a benchmark chart open before anyone has asked what the agent is supposed to do. After more than a year of building enterprise AI agents internally, I am convinced this is the least consequential decision in the entire project. Swapping the model has never taken me more than an afternoon. The data plumbing, the connector policy sprawl, the tool selection behavior, and figuring out whether the thing produces useful work per dollar have each eaten weeks. This post is my map of where the real cost centers sit, and it links out to everything I have written on each layer, so treat it as the index.

    Every Enterprise AI Agent Kickoff Starts With the Wrong Debate

    Model differences are real. I wrote about why Opus 5’s long-horizon task completion numbers matter more than coding benchmarks, and Anthropic shipping verticalized agents like Claude Finance tells you the frontier labs know where the value sits. But here is the asymmetry nobody prices in: the model is the one component you can replace without touching anything else. Copilot Studio lets you change it in a dropdown. A custom orchestration layer changes it in one config line. Meanwhile your Dataverse schema grounding, your DLP policies, your tool descriptions, and your measurement pipeline are all bespoke work that survives every model swap and cannot be bought off a pricing page.

    So when a kickoff burns two hours on model selection, I now say the same thing every time. Budget this project like 10 percent model and 90 percent platform. Every agent I have seen die in month two died in the 90 percent.

    Grounding Data Is Where the Real Engineering Hours Go

    The hardest part of an internal agent is not intelligence. It is getting the agent to behave like someone who actually works at your organisation. Org policies, naming conventions, tribal knowledge, the exception the finance team makes every quarter-end. None of that is in any model’s training data.

    The naive fix is stuffing everything into the system prompt. I learned the hard way that prompts past a few hundred tokens start degrading reliability, and a focused 400-token instruction set beats a 4000-token one every time. That is why I consider business skills in Dataverse an architectural shift rather than a feature: policy moves out of the prompt into a managed record with an owner and a version history. If you want persistent AI output that stays queryable alongside that structured data, Prompt Columns in Dataverse are worth understanding as a companion pattern — you define the prompt once and the result lives as a column rather than a one-off generation.

    Same logic applies to schema. An agent that does not know your column logical names burns tokens guessing, which is why the Dataverse MCP server’s metadata inspection tools matter, and why grounding coding agents in live environment metadata is the only reliable fix for hallucinated column names. If you want to understand what is actually happening on the wire when an agent calls one of these tools, I broke down how MCP works under the hood. It is a stateful JSON-RPC protocol, not a REST connector, and treating it like one breaks in production.

    Knowledge sources carry the same trap at a different layer. Wire the same SharePoint site into four agents four different ways and you get silent misrouting nobody can diagnose. I covered the governance side in my post on knowledge sources and agent feedback loops. None of this work goes away when you change models. All of it decides whether the agent is trustworthy.

    Connector Policies and Tool Selection Decide What Your Agent Can Actually Do

    The second cost center is everything between the agent and the systems it touches. I hit this building a GitHub integration: the connector sat in the Business data group in Dev and the Blocked group in Prod, so an agent that passed UAT would not even load its connection at go-live. The full story is in my post on enterprise environment sprawl, and the lesson generalises. The connector is never the problem. The environment strategy around it is.

    Then there is tool selection, which most teams treat as magic. It is not. In Copilot Studio, the orchestrator scores tool names, descriptions, parameter names, and enum values against the current turn. It is a retrieval problem, not a dispatch problem, and I walked through the mechanics in how Copilot Studio agent tool selection actually works. A vague operation summary like GetData on a custom connector is not lazy metadata. It is a bad prompt that makes the agent pick the wrong action.

    This is also why I push back on premature multi-agent architectures. A model that hits 95 percent tool selection accuracy with two connectors can drop to 70 percent with five, because descriptions start competing with each other. Multi-agent is a tax you pay when a single agent can no longer do the job, not an upgrade, and orchestration routing just moves the misrouting failure one layer deeper where it is harder to debug.

    If You Cannot Measure Useful Work Per Dollar, You Built a Demo

    The last cost center is the one almost everyone skips. If you cannot define what counts as useful work for your agent in one sentence, it does not have a clear enough job to be worth scaling. I documented my full approach in measuring useful work per dollar for AI agents: a single boolean per invocation, sourced from downstream behavioral signals like ticket reopens rather than thumbs-up ratings, divided into a cost stack of model tokens plus per-message consumption plus premium connector actions.

    Measurement is also your early warning system. Agents that sailed through UAT fail in production because test conversations are too clean, and the input distribution shifts the moment real users show up with messy phrasing. A workflow that completes 70 percent of the time is not a workflow, it is a demo, because the human check-in that makes it reliable eliminates the time savings it was supposed to create. Without a useful-work metric you do not find that out until someone quietly stops using the agent.

    The encouraging part: this layer is finally getting platform support. Feedback stored as queryable Dataverse rows, closed-loop learning through the Power Apps MCP server, and certified MCPs giving platform teams a trust-signal list instead of shadow adoption from random repos. The tooling is catching up to the problem.

    So here is the payoff. Next time an agent project kicks off, do not open with the model comparison. Open with four questions. Where does the org knowledge live and who owns it. Which connectors and policies apply in the environment where this will actually run. How many tools before selection accuracy degrades. And what single boolean defines useful work. In my experience, the teams that answer those four before touching a model dropdown ship agents that survive month three. The teams that start with the benchmark chart ship demos.

    Frequently Asked Questions

    What is the most expensive part of building enterprise AI agents?

    The biggest costs in enterprise AI agents are not the model itself but the surrounding layers: data grounding, governance policies, tool configuration, and measurement pipelines. These are bespoke to your organisation and cannot be swapped out the way a model can, which is why they consume the most engineering time and budget.

    How do I choose the right AI model for an enterprise agent?

    Model selection matters far less than most teams assume, since modern platforms let you swap models with minimal effort. A better approach is to spend the majority of your planning budget on data grounding, connector policies, and measurement before you finalise any model choice.

    Why does my enterprise AI agent give unreliable answers despite a strong model?

    Unreliable outputs are usually a grounding problem, not a model problem. If the agent lacks access to your organisation’s policies, naming conventions, and internal context, even a frontier model will produce generic or incorrect responses. Moving that knowledge out of long system prompts and into structured, versioned records tends to improve consistency.

    When should I move AI policy instructions out of the system prompt?

    Once your system prompt grows beyond a few hundred tokens, reliability starts to drop and maintenance becomes difficult. Migrating policy instructions into a managed data layer gives each rule a clear owner and version history, and it keeps the prompt focused on behaviour rather than organisational context.

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Prompt Columns Reach General Availability as a Dataverse Column Type

    Prompt Columns Reach General Availability as a Dataverse Column Type

    Dataverse table showing prompt columns general availability with AI-generated values persisted per row

    On 29 July 2026, Microsoft announced the general availability of Prompt Columns in Dataverse. You define a natural language prompt once on a table, and AI-generated classifications, summaries, and recommendations are computed and persisted as regular column values on every row. The insight stops being a read-time answer and becomes stored data: filterable in views, aggregable in Power BI, and triggerable in flows, with no code and no custom plumbing.

    Prompt Columns Make AI Output a Persisted Dataverse Value, Not a Read-Time Answer

    The mechanics are simple. On any Dataverse table you add a prompt column, write a natural language instruction that references other columns on the row, and Dataverse computes the result and stores it. Classify this ticket by urgency based on the description field. Summarize this feedback in one sentence. Recommend a next action based on status and history. The output lands in the column like any value a human would have typed.

    I built this exact pattern by hand last year for an internal triage table. Flow triggers on row create, calls an AI Builder custom prompt, patches the result back into a text column, handles retries when the prompt action throttles, and logs failures somewhere nobody checks. It worked. It was also four moving parts to maintain for what is conceptually one thing: a computed field whose formula happens to be a prompt. Prompt Columns deletes that entire plumbing layer. Poof.

    Storing the Insight Beats Regenerating It, With Two Caveats

    Persistence is the whole story here, and I think it is the part most coverage will skip past. Nearly every AI-in-apps pattern generates insights on demand, at read time. That has two costs people underestimate. Every consumer pays inference cost for the same question, and every consumer can get a slightly different answer. A stored value flips both. The inference runs once, then a view can sort by it, a flow can trigger on it, a Power BI report can aggregate it across a million rows without a single additional model call. I wrote before about how the data path behind the model is often the real bottleneck, and this is the same principle from the other direction: put the AI output where the data already lives.

    Two caveats before anyone switches this on across a production table. First, refresh semantics. If the description field changes after the classification was computed, when does the column recompute? A persisted AI value can go stale in a way a read-time answer never does, and you need to know the recompute triggers before you build a queue that sorts on it. Second, cost per row. One prompt execution per row sounds cheap until you enable it on a table with two million existing rows and think about backfill. Model the credit consumption before GA enthusiasm meets your capacity report. If you are already thinking about how to measure that spend against the work it produces, How to Measure Useful Work Per Dollar for Your Power Platform AI Agents is a useful starting point.

    There is a third thing that is less caveat and more governance homework. AI-generated text now sits in a column that looks exactly like human-entered data. Nothing in a view distinguishes the two. If a downstream flow or a report treats that column as ground truth, you have quietly promoted a model output to a system of record. That is fine if it is a deliberate decision with a named owner. It is not fine as an accident.

    Triage Queues and Classification Views Are the First Places This Pays Off

    The obvious first wins are the boring ones, which is a compliment. Triage queues where incoming requests get an AI-assigned category and priority, and the queue view sorts by the AI column. Summary columns on long description fields so a service agent scans a readable sentence instead of opening every record. Sentiment on feedback rows, with a flow triggering on the negative ones and routing them to an owner. Every one of these was possible before with the flow-plus-prompt pattern. Now they are a column definition, which puts them in reach of makers who were never going to build the plumbing version.

    The trade-off is worth naming. If you need per-user, per-context answers, or the insight depends on data outside the row, this is the wrong tool and read-time generation with an agent is still the right shape. That boundary also comes up when you are deciding where to store knowledge in the first place — SharePoint vs Dataverse as a Copilot Studio Knowledge Source covers how the two stores differ in ceiling, governance, and latency. In my experience, the honest split is: persist what is a property of the record, generate on demand what is a property of the question.

    AI output stored as first-class, queryable data is where this whole space is heading, and a column type is exactly the right place for it to land.

    Source: Prompt Columns in GA: Turning Business Apps Data into Persisted AI Insights (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Dataverse Plugin for Coding Agents Now Available on OpenAI and Codex Marketplaces

    Dataverse Plugin for Coding Agents Now Available on OpenAI and Codex Marketplaces

    Dataverse plugin OpenAI Codex marketplace expansion for coding agents

    Microsoft shipped the Dataverse plugin for coding agents to OpenAI and Codex marketplaces on July 28, 2026. Same plugin story we saw hit Cursor a few weeks back. The dataverse plugin openai codex marketplace expansion is the interesting signal here, not the individual drop.

    If you write Dataverse code with a coding agent, the excuse for hallucinated table and column names is gone. I want to wire this into a real internal repo this week.

    What actually shipped

    The Dataverse plugin is now installable directly from the OpenAI and Codex marketplaces. Single-click install, same as the Cursor drop earlier this month. The plugin itself is unchanged in behavior. It grounds the coding agent in live environment metadata so the model queries your actual column logical names like cr123_customerid instead of guessing based on tutorial data from training.

    Setup story is also unchanged. You point the plugin at a Dataverse environment through an app user with a scoped security role. Not System Administrator. Not production. A dedicated app user in a dev environment with least privilege. Same rule I have been repeating since the first drop.

    What is new is the reach. The plugin now lives inside three of the coding agent surfaces where pro devs actually work. Cursor, OpenAI, and Codex. That covers a real slice of the market I see on LinkedIn when people share their editor screenshots.

    Why this expansion matters more than the Cursor drop did

    The Cursor drop was the proof of concept. It showed Microsoft was willing to follow developers out of VS Code and the maker studio into competing tools. Fine. Interesting signal.

    This expansion is the follow-through. And follow-through is what tells you whether a strategy is real or a one-off gesture.

    Three marketplaces in a few weeks means Microsoft is treating the coding agent surface as a distribution channel, not a partnership. That changes the math for platform teams. When developers install Dataverse tooling from a first-party plugin in a known marketplace, you have an auditable trail. When they pull an MCP server from a random GitHub repo, you have nothing. Marketplace distribution is a governance win before it is a productivity win. The Dataverse July 2026 update actually spells out exactly where Microsoft is taking this with certified partner MCPs and enterprise MCP governance, which is worth reading alongside this drop.

    The second thing this signals is that the pro-code path into Dataverse is now considered permanent strategy. Not a side project. Not a preview experiment. Microsoft is investing in meeting devs where they already work, and that pulls the low/no-code and pro-code stories closer together than they have been in years.

    The third thing, and the one I care about most, is that hallucinated schema is officially not an acceptable failure mode anymore. If you have a coding agent generating Dataverse code and it is still inventing column names, that is a tooling choice now, not a limitation. The grounding layer exists in the tools you already use.

    What I would wire up this week

    I have a plugin project sitting in a dev environment that I want to point this at. Here is the plan.

    First, spin up a dedicated app user in the dev environment with a scoped security role. Read on the tables the plugin project actually touches. Nothing more. This is the part most people skip and regret later when the audit conversation starts.

    Second, install the plugin from the OpenAI marketplace into my coding agent. Point it at the dev environment. Verify it can read metadata. Confirm it cannot see production.

    Third, take an existing plugin file with real custom table references and ask the agent to extend it. The test is not whether the code compiles. The test is whether the generated code uses the actual logical names from my environment or hallucinates something plausible. If it grounds correctly, this becomes part of my normal flow. If it drifts, I want to know exactly where. The failure modes I am watching for here are the same ones I covered in Why Do AI Agents Fail in Production When They Worked Fine in Testing, and schema drift is near the top of that list.

    Fourth, run the same prompt against a Codex install to see if there is any behavior difference across the two marketplaces. My guess is no. The plugin is the same. But I want to confirm.

    The bigger question I am sitting with is what happens when every coding agent has grounded access to your Dataverse schema. The Power Platform pro-dev story has been fragmented for years. If the plugin holds up across three marketplaces, that fragmentation starts to close.

    I will report back on what breaks.

    Source: Dataverse Plugin for Coding Agents: OpenAI and Codex Marketplace Expansion (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Dataverse Plugin for Coding Agents Is Now in the Cursor Marketplace

    Dataverse Plugin for Coding Agents Is Now in the Cursor Marketplace

    Dataverse plugin cursor marketplace listing shown inside the Cursor editor

    Microsoft shipped the Dataverse plugin for coding agents to the Cursor Marketplace on July 21. That is the dataverse plugin cursor marketplace listing I have been waiting for since the plugin first landed for GitHub Copilot. Cursor is where a lot of developers I talk to actually spend their day, and now they can query, generate, and reason about Dataverse from inside that editor without switching windows.

    I am going to install this today. Here is what it does, why the distribution channel matters more than the feature list, and what I am pointing it at this week.

    What the dataverse plugin cursor marketplace listing actually does

    The plugin exposes Dataverse to Cursor’s agent as a tool surface. It reads live metadata from a connected environment, so when you ask the agent to generate a plugin, a custom API, a PCF control, or a complex Power Automate expression, it grounds the output in the actual table schema, column logical names, and relationships that exist in your target environment.

    That is the same grounding story I wrote about when the plugin first landed for coding agents. The model is not guessing at new_customerid versus cr123_customerid based on training data from tutorials. It is querying your environment and diffing against what is really there.

    Practically, in Cursor that means:

    • Ask the agent to scaffold a plugin registration and it uses your real entity metadata.
    • Ask it to write a fetchXML query and it validates against columns that exist.
    • Ask it to generate a TypeScript client for a custom API and the signatures match your published definitions.

    You connect it with an app user in a dev environment. Not System Administrator on prod. That was the wrong setup for the Copilot version and it is still the wrong setup here.

    Why the Cursor Marketplace channel matters

    The feature itself is not new. The distribution is. Microsoft meeting developers inside Cursor is a signal, and I think it is the more interesting story than the plugin capabilities.

    Cursor is not a Microsoft product. Two years ago I would not have expected the Power Platform team to ship a first-party plugin into a competing editor’s marketplace. That they did says the pro-code path into Dataverse is now considered strategic enough to follow developers wherever they already are, rather than trying to pull them back into VS Code or the maker studio.

    Marketplace distribution also changes the adoption math. Installing a plugin from a marketplace with a single click is a completely different friction curve than cloning a repo, running a setup script, and fighting with auth. I have watched pro devs skip the Dataverse story entirely because the tooling did not meet them where they work. This removes that excuse.

    There is a governance angle too. When your devs are pulling MCP-style tools from random community repos, your platform team has no view into what is connected. A first-party plugin in a known marketplace is auditable. It is the same trust-signal argument I made about certified MCPs in the July Dataverse update, just applied to the coding surface instead of the runtime surface.

    What I would do with it this week

    I have a dev environment with a solution I have been slowly refactoring. Custom tables, a few plugins, one custom API that needs a proper TypeScript client, and a PCF control that is still half-configured. That is my test bed.

    My plan for the week:

    • Install the plugin from the Cursor Marketplace and connect a least-privilege app user scoped only to the dev environment.
    • Point Cursor’s agent at the custom API and have it generate a typed client. Diff the output against what I would have written by hand.
    • Ask it to write a plugin that reacts to a specific message on a custom table and check whether it correctly uses my column logical names, not invented ones.
    • Try a deliberately ambiguous prompt (“add validation to the account form”) and see whether it grounds the answer in real metadata or hallucinates a JavaScript path.
    • Compare the same prompts side by side in Cursor and in the GitHub Copilot version to see if the tool responses diverge. The new Dataverse MCP server tool shape splits metadata inspection and querying into cleaner boundaries, so I am curious whether that distinction surfaces differently across editors.

    I will write up what I find. My prior from building things internally is that grounding fixes maybe 70 percent of the hallucination problem on Dataverse code, and the remaining 30 percent is prompt discipline and knowing when to stop trusting the agent. Curious to see whether Cursor’s agent loop changes that ratio in either direction. If you want a framework for thinking about where that remaining cost lands, the useful work per dollar measurement approach I laid out for Power Platform agents applies here too.

    If you live in Cursor, install it today and try it against a real solution, not a demo one.

    Source: Dataverse Plugin for Coding Agents Now Available in Cursor Marketplace (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Link to Fabric Just Got a UX Refresh and the Setup Friction Finally Drops

    Link to Fabric Just Got a UX Refresh and the Setup Friction Finally Drops

    Link to Fabric UX refresh setup screen in Power Platform

    Microsoft announced a Link to Fabric UX refresh on July 20, 2026. Same underlying capability, cleaner setup path. If you have been putting off wiring Dataverse into Fabric because the old flow felt heavy for anyone who is not a data engineer, this is the week to revisit it.

    I have set this thing up more times than I want to count. The capability was solid. The setup screens were where people bailed.

    What the Link to Fabric UX refresh actually does

    The refresh does not change what Link to Fabric is. You are still creating a managed replication of Dataverse tables into a Fabric workspace, landing them as Delta Parquet, and getting a SQL analytics endpoint on top. That plumbing is unchanged.

    What changed is the front door. The old flow had too many decision points stacked in the wrong order. You picked a workspace, then got prompted about capacity assignment, then got a table picker that dumped every table in the environment on you, then had to reason about which relationships and long-term retention flags mattered. Makers who were building a Power App and just wanted their data in Fabric for a Copilot grounding source would get halfway in and close the tab.

    The new flow collapses those decision points. Table selection is filtered and searchable by default. The workspace and capacity checks happen up front so you fail fast if permissions are wrong, instead of after you have already picked twelve tables. The confirmation screen actually tells you what will happen and roughly when.

    It is a UX pass, not a feature drop. That is fine. The feature was already there.

    Why the Link to Fabric UX refresh matters

    Setup friction is one of those things that sounds like a small thing until you count how many projects it kills. I have watched teams decide against Fabric entirely because their first attempt at Link to Fabric turned into a two-week ticket exchange with the platform team over capacity and workspace roles. By the time it was sorted, someone had already built a Power BI dataflow against the Dataverse connector and moved on.

    The other reason this matters is agents. I wrote about low-latency sync for Dataverse to Fabric going GA a while back. That closed the freshness gap. This closes the onboarding gap. If you are building agents that ground on Dataverse data through Fabric, both of those need to be easy. A capable data path that nobody sets up correctly is not a data path.

    The people who benefit most here are not the data engineers. They already had the old flow memorised. It is the Power Platform makers who own a solution end to end and need analytics or agent grounding without filing a ticket to a separate team. That is a real audience, and it has been underserved on this specific path for a while. If you are thinking about how to evaluate what that grounding work actually costs versus what it returns, measuring useful work per dollar for your Power Platform AI agents is worth reading alongside this.

    What you give up: nothing that I have found. The advanced controls are still there, they are just not in your face on step one.

    What I would do with it this week

    Three concrete things.

    First, take a Dataverse environment where you previously gave up on Link to Fabric and try it again. Time the setup. If it went from a half-day of back and forth to under thirty minutes, that is your signal to standardise on this path for future work.

    Second, wire a small agent against the resulting Fabric tables. Nothing fancy. A Copilot Studio agent with a knowledge source pointed at two or three tables you replicated. See how the answers feel with fresh data underneath. If you are still weighing whether to pull from SharePoint or Dataverse for that knowledge source, my SharePoint vs Dataverse as a Copilot Studio knowledge source comparison lays out the decision rule clearly. This is the loop I keep coming back to, and I have written more about how I think about grounding sources on my LinkedIn.

    Third, revisit your Link to Fabric documentation and admin guardrails. The easier the setup gets, the more makers will do it themselves, which means capacity governance and workspace access reviews matter more, not less. Easier onboarding without governance turns into skill sprawl’s cousin: workspace sprawl.

    The pattern here is familiar. Microsoft ships the capability, then eighteen months later ships the UX that makes people actually use the capability. That gap is where a lot of good features go to die. Glad this one did not.

    Next up on my watchlist: whether the same treatment lands on the mirroring configuration screens.

    Source: Announcing Link to Fabric UX refresh (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • How to Measure Useful Work Per Dollar for Your Power Platform AI Agents

    How to Measure Useful Work Per Dollar for Your Power Platform AI Agents

    Power BI dashboard showing useful work per dollar for AI agents in Copilot Studio

    OpenAI published a piece on managing AI investments in the agentic era and the metric they anchor on is useful work per dollar. Not tokens per second. Not model benchmarks. Useful work per dollar for AI agents, measured against the actual business outcome the agent is supposed to produce. That framing maps cleanly onto Power Platform agents if you wire up the telemetry properly. This walkthrough shows how to instrument a Copilot Studio agent so you can see cost, task success rate, and useful work per dollar per workflow, then use that to decide what to scale and what to kill.

    The working result: a Dataverse table plus a Power BI page that gives you a per-agent, per-workflow view of cost efficiency in production. No guessing, no vibes.

    Step 1: Define what counts as useful work for the agent

    This is the step everyone skips and it is the one that decides whether the whole exercise is worth anything. Useful work is not “the agent responded.” It is the outcome the workflow is supposed to produce.

    For a support triage agent, useful work might be “ticket classified correctly and routed without human correction within 24 hours.” For an invoice extraction agent, it is “line items extracted with zero manual edits before posting.” For an internal knowledge agent, it is “user did not open a follow-up ticket on the same topic within 48 hours.”

    Write this down as a single boolean per invocation: isUsefulWork = true/false. If you cannot define it in one sentence, the agent probably does not have a clear job yet.

    Step 2: Log invocations and outcomes to Dataverse

    Create a Dataverse table called AgentInvocation with these columns at minimum: InvocationId, AgentName, WorkflowName, UserId, StartTime, EndTime, InputTokens, OutputTokens, ToolCallsCount, Outcome (choice: Success/Failure/Escalated), IsUsefulWork (bool), and Notes.

    In Copilot Studio, add a Power Automate flow at the end of the agent topic that writes a row to this table on every invocation. Pass the run context so you can correlate it later. For the IsUsefulWork field, you have two options: infer it automatically from a downstream signal (was the ticket reopened, did the invoice post, did the user thumbs-down) or capture it with a lightweight feedback prompt at the end of the conversation. I prefer downstream signals because self-reported feedback is noisy.

    Microsoft has a good primer on writing to Dataverse from flows if you have not done this pattern before.

    Step 3: Pull token and action costs into the same table

    Cost is not just tokens. For a Copilot Studio agent using Power Automate flows, tool calls, and premium connectors, the cost per invocation is a stack: model tokens plus per-message consumption plus any premium connector actions triggered inside tool flows.

    Build a simple cost model as a Dataverse calculated column or a Power BI measure:

    InvocationCost = (InputTokens * InputRate) + (OutputTokens * OutputRate) + (ToolCallsCount * FlowActionCost) + MessageMeterCost

    Get the current rates from your tenant’s Power Platform licensing page and your model provider. The exact rates will drift, so store them in a separate PricingRates table with an effective date rather than hardcoding them into the measure. Trust me on this one. I learned the hard way when connector pricing shifted and every dashboard I had was quietly wrong for a month.

    Step 4: Build the useful work per dollar view in Power BI

    Connect Power BI to the AgentInvocation table. Create three core measures:

    TotalCost = SUM(AgentInvocation[InvocationCost])

    UsefulWorkCount = CALCULATE(COUNTROWS(AgentInvocation), AgentInvocation[IsUsefulWork] = TRUE)

    UsefulWorkPerDollar = DIVIDE([UsefulWorkCount], [TotalCost])

    Build one page with a matrix visual: rows are WorkflowName, columns are the three measures plus task success rate and average invocation cost. Add a line chart showing useful work per dollar trending weekly per workflow. That trend line is the one you will actually look at.

    Slice by agent, by workflow, by user segment. The interesting patterns are usually in the segments, not the overall number. One workflow can be printing money while another quietly burns budget on retries.

    Step 5: Set a scale or kill threshold and review weekly

    Numbers without a decision rule are decoration. Set a threshold before you look at the data so you do not rationalize whatever the chart shows.

    My rule of thumb: if a workflow’s useful work per dollar is at least 3x the manual baseline (what the same work would cost in human time), it is a scale candidate. If it is below 1x for four weeks running, it gets killed or redesigned. Between 1x and 3x is the improvement zone: look at where the cost concentrates, usually retries, oversized system prompts, or unnecessary tool calls. If you want to understand what is driving those unnecessary tool calls, How Copilot Studio Agent Tool Selection Actually Works Under the Hood covers the orchestrator scoring pass and how to structure tools so the agent stops reaching for the wrong one.

    Review weekly. Monthly is too slow, daily is noise.

    Final state and one pitfall

    You end up with a Dataverse table capturing every invocation, a cost model that reflects real pricing, and a Power BI page that shows useful work per dollar per workflow with a scale-or-kill threshold. That is the whole loop.

    The common pitfall: measuring useful work by proxies that are easy to log rather than the ones that actually matter. “User did not thumbs-down” is not the same as “the work was correct.” Spend the extra effort to wire up a downstream signal, even if it means waiting 24 hours to mark an invocation useful. Noisy signals produce confident wrong decisions, and this is a place where being confidently wrong is expensive. If you want to see what happens when agents that looked fine in testing start failing on real signals, Why Do AI Agents Fail in Production When They Worked Fine in Testing walks through exactly that. For more on how I think about this stuff, see my LinkedIn.

    Frequently Asked Questions

    How do I measure useful work per dollar for AI agents in Power Platform?

    Start by defining a clear, binary outcome for each agent workflow, such as whether a ticket was routed correctly or an invoice posted without edits. Then log each invocation to Dataverse with cost and outcome data, and use Power BI to calculate the ratio of successful outcomes to total spend. This gives you a per-agent, per-workflow view of cost efficiency rather than relying on vague performance indicators.

    What is useful work in the context of a Copilot Studio agent?

    Useful work refers to the specific business outcome an agent is designed to produce, not simply the fact that it generated a response. For example, a support triage agent produces useful work only if the ticket is classified and routed correctly without human correction. If you cannot define that outcome in a single sentence, the agent likely lacks a clear purpose.

    How do I track AI agent invocation costs in Dataverse?

    Create a Dataverse table that records key details for every agent run, including token counts, tool calls, timestamps, and the workflow outcome. A Power Automate flow triggered at the end of each Copilot Studio topic can write this data automatically. Over time, this log gives you the raw numbers needed to calculate cost per successful outcome.

    When should I use downstream signals instead of user feedback to measure agent success?

    Downstream signals, such as whether a ticket was reopened or an invoice posted without edits, are generally more reliable than asking users to rate the interaction directly. Self-reported feedback tends to be inconsistent and easy to ignore, while automated signals reflect actual business outcomes. Use feedback prompts only when no suitable downstream signal exists for the workflow.

    Source: How to manage AI investments in the agentic era (OpenAI).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • Dataverse July 2026 Update Extends the Agent Data Platform to More Coding Marketplaces and Certified MCPs

    Dataverse July 2026 Update Extends the Agent Data Platform to More Coding Marketplaces and Certified MCPs

    Dataverse July 2026 update expanding agent data platform with certified MCPs

    Microsoft shipped the July 2026 Dataverse update on July 6, and reading it back to back with the previous months makes the pattern obvious. The dataverse july 2026 update is not about new agent features. It is about reach and governance. The Dataverse plugin is expanding into more coding agent marketplaces, MCP tool coverage is growing, partner MCPs are getting certified, and internal MCPs are being pulled under enterprise governance.

    If you have been paying attention to the last three months of Dataverse announcements, this one fits the arc. Microsoft is turning Dataverse into the substrate every agent on the stack talks to, and now they are dealing with the mess that comes with that.

    What shipped in the July 2026 Dataverse update

    Four things landed together.

    First, the Dataverse plugin for coding agents is being pushed into more coding agent marketplaces. This is the same plugin that fixed the hallucination problem for coding agents generating Power Platform code. Wider distribution means more developers will hit it through their existing IDE and agent setups instead of having to hunt for it.

    Second, MCP tool coverage is growing. The Dataverse MCP server now exposes more of the platform surface, which continues the direction we saw when the tool shape shifted toward metadata inspection. Tighter tool boundaries, more of them, less guessing by the agent.

    Third, partner MCPs can now be certified. This is the one I think most teams will underestimate. Microsoft is publishing a certification path so third-party MCP servers can carry a trust signal. Think of it like connector certification, but for the agent tool layer.

    Fourth, internal MCPs get pulled under enterprise governance. DLP, environment scoping, audit. The plumbing you would expect from a Power Platform connector, applied to the MCP tool surface an agent can call.

    Why the certified MCP and governance angle matters

    Here is the part I keep thinking about. Every team I talk to that has been experimenting with agents in the last six months has quietly wired up MCP servers from wherever. Community repos. Vendor previews. Somebody’s GitHub. The tool surface an internal agent can reach is already sprawling, and nobody centralised the decision.

    Sound familiar? It is the same shape as the SharePoint site as a knowledge source problem I wrote about when knowledge sources and feedback loops shipped. Four makers, four wirings, no shared governance. MCP is worse because the surface is executable, not just readable.

    Certified partner MCPs are Microsoft’s answer to shadow adoption. Give platform teams a list of MCPs that carry a trust signal, register the ones that make sense, block the rest. The enterprise governance layer for internal MCPs is the other half. DLP policies that treat MCP tools like any other data movement. If you want to understand how the orchestrator evaluates tools before it ever calls them, how Copilot Studio agent tool selection actually works under the hood is worth reading alongside this update.

    The trade-off is real. Certification takes time. If your team needs a niche MCP that nobody has certified yet, you are either waiting or accepting risk. But the alternative is what I keep seeing on LinkedIn from people six months into agent projects. A tool surface nobody can inventory, and no clean way to answer the auditor when they ask what data the agent can touch. That sprawl is also one of the cleaner explanations for why AI agents fail in production when they worked fine in testing.

    What I would do with it this week

    I would not build a new agent this week. I would audit.

    Start with a simple inventory. Which MCP servers are already wired to any agent in your tenant. Where they came from. Who registered them. Whether they touch Dataverse, SharePoint, or anything with customer data. Most teams have never written this down.

    Then look at the certified partner MCP list as it lands and pick the two or three that actually match what your makers have been asking for. Register those under a governed environment. Publish the list internally. Say the quiet part out loud. If it is not on the list, it does not go into a production agent.

    Finally, get the Dataverse plugin for coding agents into the hands of the pro devs writing plugins and PCF controls. Not the citizen dev crowd. This is a pro dev tool and treating it otherwise misses the point. Scope it to a dev environment with a least-privilege app user, not System Administrator on production. I wrote about that setup in the original plugin post and it still applies.

    If you want to see how this ties back to the broader agent data platform direction, the Power Platform docs are catching up quickly and worth a scan. And if you want to compare notes on how other teams are handling MCP governance, I keep track of what people are saying on LinkedIn.

    The month the platform team gets ahead of MCP sprawl is worth more than the month you shipped one more agent.

    Source: Dataverse Is Your Agent Data Platform: Here’s What’s New in July 2026 (Microsoft Power Platform Blog).

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn

  • SharePoint vs Dataverse as a Copilot Studio Knowledge Source

    SharePoint vs Dataverse as a Copilot Studio Knowledge Source

    SharePoint vs Dataverse copilot studio knowledge sources comparison

    Every Copilot Studio agent I have built or seen built starts with the same decision. Where does the knowledge live. SharePoint or Dataverse. The copilot studio knowledge sources picker makes it look like a flat choice. It is not. The two behave very differently once real content and real users hit them, and the wrong call shows up around month three when answers start drifting.

    I have been reading a lot about this lately and talking to people at other organisations who hit the same wall. Here is how I actually compare the two now, across four dimensions that matter.

    Content ceiling and file limits

    SharePoint as a knowledge source caps out at 4 SharePoint sites per agent, and Copilot Studio indexes the documents through Graph search. That sounds generous until you realise the same site is often wired into three agents with different filters, and indexing latency on freshly uploaded files can run several minutes before the agent sees them.

    Dataverse knowledge sources let you attach tables with up to 25 columns indexed for semantic search, and you can scope to specific rows with security roles. The ceiling is higher and the control is finer. The tradeoff is you have to actually get the content into Dataverse rows in the first place, which is real work if your source of truth is a folder of PDFs.

    Governance and ownership

    This is where I keep seeing teams pick wrong. SharePoint feels easy because the content is already there. But the same SharePoint site ends up wired four different ways by four different makers with no shared governance, which I wrote about in more detail when Dataverse got knowledge sources and agent feedback loops.

    Dataverse forces ownership. Each knowledge source is a managed record with an owner, a solution layer, and environment promotion. You can audit who changed what. With SharePoint sites, the agent sees whatever a site owner decides to upload that afternoon. That is not governance, that is hoping.

    Latency and answer quality

    Dimension SharePoint Dataverse
    Indexing latency 2-10 minutes typical Near real-time on row update
    Content ceiling 4 sites per agent Multiple tables, row-level filters
    Citation quality File and page reference Row-level with column context
    Governance Site owner discretion Solution-bound, owned record
    Setup effort Low if content already in SharePoint Higher, needs data model

    Citation quality matters more than people admit. When an agent cites a 200-page PDF in SharePoint, users still have to find the answer inside the document. With Dataverse row-level citations, the agent points at the specific record, which makes hallucinations easier to spot and correct. The new Dataverse MCP server tool shape splits metadata inspection, querying, and search into cleaner boundaries that make this even more precise for agents.

    Cost and licensing

    SharePoint knowledge sources use the standard SharePoint connector, which keeps things in the base licensing envelope for most internal scenarios. Dataverse knowledge sources mean Dataverse capacity, and depending on how much you index, that adds up. If near real-time data freshness is part of your argument for Dataverse, the low-latency sync from Dataverse to Fabric hitting GA is worth factoring into the broader data architecture conversation at the same time. Do not pay for Dataverse capacity you do not need.

    Microsoft documents the current connector and capacity behaviour in the Copilot Studio docs, and it is worth checking before you commit a topology.

    Choose SharePoint if, choose Dataverse if

    Choose SharePoint as your Copilot Studio knowledge source if the content is already in SharePoint, lives as documents rather than structured data, the agent serves under a few hundred users, and you can live with multi-minute indexing latency. It is the right call for a policy lookup agent pointed at an existing HR site.

    Choose Dataverse as your knowledge source if the content is structured, ownership and auditability matter, you need row-level security, or the agent is going to be promoted across environments under ALM. It is the right call for any agent that touches process logic, business skills, or anything a regulator could ask about later.

    The decision is not which one is better. It is which one matches the shape of your content and the seriousness of the use case. I have made the wrong call on this and paid for it in debugging time. Pick deliberately.

    Frequently Asked Questions

    What are the best copilot studio knowledge sources for enterprise agents?

    The two main copilot studio knowledge sources are SharePoint and Dataverse, and the right choice depends on your governance needs and content structure. SharePoint is quicker to set up if content already exists there, but Dataverse offers better control, row-level filtering, and near real-time indexing for more demanding use cases.

    When should I use Dataverse instead of SharePoint as a knowledge source in Copilot Studio?

    Dataverse is the better choice when you need strict governance, auditable ownership, or row-level security over your content. It also suits scenarios where indexing latency matters, since Dataverse updates are reflected near real-time compared to SharePoint’s typical 2-10 minute delay.

    Why does my Copilot Studio agent not pick up newly uploaded SharePoint files immediately?

    Copilot Studio indexes SharePoint content through Graph search, which can introduce a delay of several minutes before freshly uploaded files become visible to the agent. This latency is a known tradeoff of using SharePoint as a knowledge source rather than a structured data store like Dataverse.

    How do I improve answer quality in a Copilot Studio agent?

    Switching from SharePoint to Dataverse as your knowledge source can improve citation quality, since Dataverse returns row-level references with column context rather than broad file or page links. Scoping your knowledge source to well-structured tables with relevant columns indexed for semantic search also helps the agent return more precise answers.

    About the author: Halilcan Soran is a Senior Business Analyst at Visa working on process optimization with Power Platform, RPA, and agentic AI. He previously led a 15-person team at Thomson Reuters, where the Power Automate solutions he built started his automation career. More about Halilcan · LinkedIn