MCP is an open standard Anthropic published in 2024, since adopted by OpenAI, Microsoft and most of the AI tooling industry, and donated to the Linux Foundation’s Agentic AI Foundation in December 2025. It solves one problem, and the problem is narrow: how do you give an AI assistant access to your data and systems without building a bespoke integration for every combination of model and system. Before it, every client and every system needed its own connector. After it, both sides implement the same protocol and any client can reach any server.
That is the whole ambition. Everything else people attribute to MCP — governance, security, agent orchestration — is built on top of it, or is simply not there.
The part almost everyone has backwards
The MCP server sits on the side of the data.
That reads as wrong the first time. “Server” sounds like the big central thing, and the AI is the big central thing, so surely the model is the server. It is the other way around. Business Central runs an MCP server. Your SharePoint estate would run an MCP server. Claude Desktop, VS Code and Cursor — the tools a person actually sits in front of — are MCP clients.
Once that is the right way round the rest of the vocabulary falls into place. One client connects to several servers at once. A server has no idea which model is on the other end and does not need to know: it publishes what it can do and answers calls. Which is exactly why the same Business Central MCP server serves Claude, Copilot and Cursor without anyone writing a Claude-specific or Copilot-specific version of it.
Why there is a proxy in the middle at all
MCP defines two transports, and the difference between them explains an entire component.
stdio. The client launches the server as a local process and talks to it over standard input and output. No network, no ports, no authentication layer — the operating system’s process boundary is the boundary. This is what a desktop client uses.
Streamable HTTP. The server is a remote endpoint reached over HTTPS, with Server-Sent Events for anything that streams back. This is what a hosted server has to use, because a Microsoft datacentre cannot launch a process on your laptop.
Business Central’s MCP server is hosted, so it speaks streamable HTTP. Many clients can now reach it directly — Microsoft documents Claude Code, GitHub Copilot CLI and ChatGPT, given an Entra app registration, because Entra doesn’t support dynamic client registration. A client that only speaks stdio still can’t.
That gap, plus token refresh and cold-start handling on your own machine, is why bc-mcp-proxy exists. Seen as three links, the architecture stops being mysterious:
Your AI client speaks stdio and knows nothing about Business Central, OAuth or Entra. It sees a tool list and calls tools.
The proxy, on your machine, presents itself to that client as an ordinary stdio MCP server, and holds the OAuth token. Sign-in, silent refresh and reconnects all happen here — on your device, in a process you control.
Microsoft’s BC MCP server receives the HTTPS calls carrying that token, validates it, and executes them against your environment with the signed-in user’s permissions and the operations the configuration allows, and nothing more.
Nothing about the middle link is exotic. It is a protocol adapter with credential handling. It needs care not because it is complicated but because of where it sits: it is the one component holding a token to your finance system.
What actually crosses the wire
A tool is three things: a name, a description, and a parameter schema. The result of an invocation is the fourth thing that moves. That is the complete contract.
Notice what is not on that list. The model never sees your implementation, your tables, your business rules or your comments. When it decides whether to call one tool or another, it is reading a sentence of English and a JSON schema. Nothing else is available to it.
That has a consequence which is easy to state and easy to underestimate: a bad tool description is a bug, not a documentation shortcoming. A tool described as “Gets data” will be called when it should not be and skipped when it should have been, and the failure will look like a model failure. It is not. The model behaved correctly given the only information it was handed. The same goes for parameter schemas — a parameter typed as a free string when it is really one of four statuses will eventually be filled with a plausible-looking fifth.
If you build your own MCP tools, this is where the engineering attention goes, and it is more than the transport needs. Descriptions are interface, not commentary on it.
For Business Central’s built-in server you do not write them, which moves the lever rather than removing it. Your control is the configuration: which API pages and queries it exposes, and which operations each one allows.
What Business Central actually ships
Microsoft first shipped an MCP server inside Business Central as a preview in 2025; since version 28 (2026 release wave 1) it is generally available, and every host — Copilot Studio, VS Code, Claude, ChatGPT — connects to the same endpoint, https://mcp.businesscentral.dynamics.com, selecting tenant, environment, company and configuration through headers. No separate licence, no add-on: it is in the environment.
Out of the box, a built-in default configuration already lets agents discover and read any eligible API page or API query the signed-in user has permission for. To curate that surface, or to allow creates, edits, deletes and actions, you add an MCP Server Configuration, configure it, and then switch Active on; while it is active, the configuration itself cannot be edited — switch it off to change it. Then you choose the shape of the tool surface:
Static mode generates one tool per allowed operation on each API page or API query you add — List_Customers_PAG30009, Create_Customer_PAG30009 and so on. A bounded, predictable set. The model sees every schema, which costs prompt tokens, and it can only reach what you picked in advance.
Dynamic mode exposes three generic tools instead — bc_actions_search, bc_actions_describe, bc_actions_invoke — and the client discovers actions at runtime. Cheaper in prompt, far more flexible, and slow on the first call, because Business Central walks the metadata catalogue. With Discover Read-Only Objects switched on, we measured that walk at 50 to 60 seconds server-side on a Cronus demo environment.
Start static. Feedback is fast and you know exactly which tools exist. Move to dynamic once people start asking for things you did not preselect a tool for.
What MCP does not solve
This is the part that gets skipped, and in a business it is the part that matters most.
MCP is a transport and a tool contract. It is not an authorisation model. There is nothing in the protocol that decides who may read the general ledger. When a tool call arrives at Business Central, BC applies exactly what it would apply to that user in the client: permissions, company access, licence. The token carries an identity, and the identity carries the rights.
Restated practically: anything the AI can reach, the signed-in user could already have reached by opening the page themselves. No more, and no less. That is reassuring, and it is also the ceiling. Pointing a model at an account with broad permissions does not create a risk of the model exceeding them — it removes the friction that was quietly doing the work of a control. Someone who used to click through four pages to assemble a list can now ask for it in one sentence. The permissions were always that wide. Only the effort changed.
So the questions worth asking before you connect anything are not protocol questions. Which account signs in. What that account can already reach today. Which API objects the default configuration lets agents read — everything eligible the user can open, unless you designate a narrower default — and whether write access belongs in a separate named configuration. And whether tool-call telemetry is switched on for the environment, so the answer to “who asked what” exists before somebody needs it.
MCP handles the plumbing well and handles nothing else. That is not a criticism — a protocol that also tried to be an authorisation model would be worse at both jobs. It means the governing stays where it always was: in the systems that were already doing it, with the people who were already accountable for it.