Hello everyone and welcome to my blog. If you have been anywhere near the Power Platform in the last year, you know that everything is being reshaped around AI agents. And one of the most interesting pieces of that story is the Dataverse MCP Server, which lets agents talk to your Dataverse data directly. Up until recently, that mostly meant generic operations – create a row, update a row, run a query. But your real business logic does not live in generic CRUD. It lives in your Custom APIs. In today’s blog, let’s look at a genuinely exciting update from October 2026 – agents can now discover and call your own Custom APIs through the Dataverse MCP Server.
This is a big deal, and once you see how it works, you will want to make your APIs agent ready straight away. Let’s dig in.
A quick level set – MCP Server and Custom APIs
Before we get to the new bit, two quick definitions so everyone is on the same page.
- The Dataverse MCP Server lets Dataverse act as an MCP (Model Context Protocol) server. MCP is an open protocol that lets large language model applications connect to external data and tools in a standard way. In plain terms, it gives AI clients – Copilot Studio agents, GitHub Copilot in VS Code, Claude, and others – a standard doorway into your Dataverse tables and operations.
- A Custom API is your own server-side operation in Dataverse. You define it with a unique name, a set of typed input and output parameters, and a plug-in that runs your C# logic. It is how you package real business logic – validation, multi-step operations, calculations – behind one clean, callable operation.
So the obvious question was always – if the MCP Server exposes Dataverse to agents, and my business logic is sitting in Custom APIs, why can the agent not just call those? As of October 2026, it can.
What actually landed
Microsoft announced that the Dataverse MCP Server now supports Custom APIs, letting agents use your existing custom business logic. The best part – there is no new wrapper to write. The MCP Server builds everything it needs from the Dataverse metadata you already created when you defined the Custom API. In Microsoft’s own words, once your Custom API is published, it is automatically discovered by the Dataverse MCP Server. No separate registration, no hand-written tool definition.
There is a built-in MCP tool called invoke_api whose entire job is, quite literally, to “Invoke Dataverse Custom API”. But the agent does not jump straight to invoking. It follows a neat little three-step dance.
How an agent uses your Custom API: search, describe, invoke
The flow is search → describe → invoke_api, and understanding it is the key to making your APIs work well with agents.
- search – the agent takes the user’s request, pulls out keywords, and calls the search tool. The MCP Server indexes your Custom APIs right alongside tables, skills, and scopes, and returns a match – something like
api/new_CreateCaseWithFollowUp. The search tool even nudges the model to prefer calling an existing Custom API over trying to do the work itself with raw CRUD. - describe – the agent then calls describe on that operation to learn its contract. It gets back the request schema – the input names, their types, which ones are required, and their descriptions – all drawn straight from your Custom API’s metadata.
- invoke_api – finally, the agent calls invoke_api with the API’s unique name and an inputs object, and your plug-in runs server-side exactly as it always has.
Microsoft sums the pattern up nicely – search to find the operation, describe to learn its contract, invoke_api to run it.
Let’s make it concrete
Say we have a Custom API named new_CreateCaseWithFollowUp (display name “Create Case With Follow-Up”). It does one meaningful unit of work – it atomically creates a support case, attaches a note with the customer’s description, and schedules a follow-up task, all inside a single Dataverse transaction. If any step fails, the plug-in throws and Dataverse rolls everything back. This is exactly the kind of thing you want behind a Custom API rather than leaving an agent to fire off three separate creates and hope they all succeed.
Now a support rep types this into their agent (GitHub Copilot Chat, a Copilot Studio agent, whatever client you have wired up):
“Create a high-priority case for Adventure Works because their shipment arrived damaged. Add the customer’s description as a note and schedule a follow-up for Friday afternoon.”
The agent calls search, finds api/new_CreateCaseWithFollowUp, and then calls describe on it. What comes back is roughly this contract, built from your metadata:
{
"apiUniqueName": "new_CreateCaseWithFollowUp",
"displayName": "Create Case With Follow-Up",
"description": "Atomically creates a support case, an attached note, and a follow-up task for a damaged-shipment report.",
"inputs": [
{ "name": "AccountId", "type": "String", "required": true, "description": "GUID of the account the case is for." },
{ "name": "CaseTitle", "type": "String", "required": true, "description": "A short title for the case." },
{ "name": "CaseDescription", "type": "String", "required": true, "description": "The customer's description of the issue." },
{ "name": "Priority", "type": "String", "required": true, "description": "One of High, Normal, or Low." },
{ "name": "FollowUpSubject", "type": "String", "required": true, "description": "Subject line of the follow-up task." },
{ "name": "FollowUpDueDate", "type": "String", "required": true, "description": "Due date of the follow-up task, ISO 8601." }
]
}
Armed with that contract, the agent fills in the values from the conversation and calls invoke_api:
{
"apiUniqueName": "new_CreateCaseWithFollowUp",
"apiInputs": {
"AccountId": "a1b2c3d4-1111-2222-3333-444455556666",
"CaseTitle": "Damaged shipment - Adventure Works",
"CaseDescription": "Customer reports the shipment arrived damaged in transit.",
"Priority": "High",
"FollowUpSubject": "Call customer about damaged shipment",
"FollowUpDueDate": "2026-11-27T15:00:00Z"
}
}
Your plug-in runs, everything is created in one transaction, and a tidy response flows back to the agent:
{
"TicketNumber": "CAS-01003-R9Q6N9",
"Message": "Case CAS-01003-R9Q6N9 was created for Adventure Works with a follow-up task."
}
From the rep’s point of view, they asked in plain English and the right thing happened – using your validated, transactional business logic, not the agent’s improvisation.
The big takeaway – your metadata is now the agent’s instructions
Here is the point I really want you to walk away with. When the agent calls describe, every display name, every parameter name, and every description you wrote becomes the model’s only source of truth about what your API does and how to call it. There is no human in the loop re-explaining it.
That changes how you should author Custom APIs. A parameter called Param1 with a blank description was always a bit lazy, but now it actively hurts – the agent has nothing to go on. Give your Custom API a clear display name, write a one-line description of what it does, and describe every parameter in plain language including the allowed values (“One of High, Normal, or Low”). Good metadata is no longer just nice documentation. It is what makes your API usable by an agent at all.
A few things to keep in mind
- Custom APIs, not Custom Actions. This is an important distinction. Microsoft has stated that the older Custom Actions (process-based actions) are not currently supported in the Dataverse MCP Server. If you have business logic trapped in a legacy custom action that you want agents to use, plan to move it to a Custom API.
- Just publish it. There is no special “expose to MCP” switch on the Custom API itself. Build it, publish it, and it is discoverable. That simplicity is lovely, but it also means you should be deliberate about which APIs exist in an environment where the MCP Server is enabled.
- The MCP Server is enabled at the environment level. To use Dataverse as an MCP server you first enable and configure the server and its allowed clients for the environment. Treat that as a governance decision, not a flip-the-switch afterthought – and validate how the calling agent’s identity and permissions map to your operations before you let it loose on production.
- Mind the Copilot Credits. MCP tool usage is metered through Copilot Credit billing, so as agent traffic grows, keep an eye on consumption rather than being surprised by it later.
- It is brand new. This landed in October 2026 and the agent space is moving fast, so always check the current Microsoft docs for the latest on status, supported clients, and limits.
Final thoughts
I find this genuinely exciting because it respects the investment you have already made. You do not throw away your business logic and rebuild it for the AI world – you expose what you already have, and agents meet your logic on your terms, with your validation and your transactions intact. If you are starting to build agent experiences on Dataverse, go and look at your Custom APIs, tidy up their names and descriptions, and you have effectively just given your agents a set of trustworthy, purpose-built tools. Give it a try and let me know in the comments how you are using it.
For the authoritative details, the full tool list, and how to build a Custom API, refer to Microsoft’s documentation:
- Custom APIs just landed in the Dataverse MCP Server (Power Platform blog)
- Connect to Dataverse with model context protocol (MCP)
- Create and use Custom APIs (Microsoft Learn)
Hope this helped. You will also like the below posts.
Debajit Dutta
Discover more from Debajit's Power Apps & Dynamics 365 Blog
Subscribe to get the latest posts sent to your email.