What's New in Fabric Data Agents: MCP, Routing, Runtimes, and the End of the Assistants API
Over the summer, Fabric Data Agents changed in ways that matter more than any single feature: the Assistants API they were built on was shut down, every published agent became an MCP server, source routing went GA, and a preview runtime arrived. What changed, and what to do about it.
On August 26, 2026, OpenAI switched off the Assistants API. That matters to Fabric people for one reason: it was the API most early Fabric Data Agent integrations were built on, including the samples in two of my own posts. If you call a data agent from code, the way you do it just changed.
The shutdown is the loudest change, but not the only one. Over the same few months, every published data agent became an MCP server, data source routing went generally available, the Copilot Studio integration went GA on top of MCP, and agents gained a choice of runtime. None of these is a headline feature on its own. Together, they change how you should build, describe, and call an agent. This post walks through each change and the principle behind it, and closes with a checklist for agents you already have in production.
- Aug 26 assistants API shut down. Code using threads and runs against a data agent needs to move. Microsoft's guidance is to migrate to the MCP endpoint.
- 1 tool per published agent. Publishing turns an agent into an MCP server with exactly one tool. Your publish description becomes that tool's description.
- 2 runtimes to choose from. Standard for stable production behavior, preview for the newest query generation. The runtime is pinned when you publish.
The Summer in Five Steps
Before the detail, here is the shape of the change: how code reaches a data agent, from the start of the summer to now.
Where we started
Early integrations called a data agent through an Assistants-style endpoint: create a thread, post a message, start a run, poll until it finishes. It worked, and it was what the samples showed.
Every published agent became an MCP server
Publishing now exposes the agent at an MCP endpoint with exactly one tool. Your publish description becomes that tool's description: the text every client reads before deciding to call.
August: routing went GA
An agent with several sources picks one per question, using the schema, source descriptions, example queries, and your routing rules.
August: Copilot Studio, on the same rails
The Copilot Studio integration went GA as a Fabric IQ Data MCP tool, with source permissions carried through. One protocol now covers Microsoft's clients and your own code.
August 26: the old path closed
OpenAI shut down the Assistants API. Code still using threads and runs has to move to the MCP endpoint. That is the first item on the checklist at the end of this post.
1. The Integration Surface Is Now MCP
The first generation of data agent integrations used an OpenAI Assistants style endpoint: create an assistant, create a thread, post a message, start a run, poll the run, read the messages. It worked, and it was familiar, which is why the official Python client and most community samples used it. Microsoft's own client documentation now carries a warning that the Assistants API is no longer available and that integrations should migrate to the MCP endpoint.
The replacement is simpler. When you publish a data agent, it becomes a Model Context Protocol server at a predictable URL:
Any client that speaks MCP over streamable HTTP and can attach a Fabric bearer token can use it: a Python script, VS Code, Copilot Studio, or your own backend. The server exposes a single tool that represents the agent. You send it a question; it sends back an answer grounded in the data the agent can see. You can find the URL, tool name, and a ready-made mcp.json under the agent's Settings, on the Model Context Protocol tab. The endpoint only works after you publish.
The Copilot Studio integration, which went GA in August, rides the same rails: you add a data agent to a Copilot Studio agent as a Fabric IQ Data MCP tool, and the source permissions carry through. One protocol now covers the portal-adjacent tools and your own code.
The principle hiding in this change is the important part: your publish description is now an API contract. When an orchestrator, whether that is Copilot Studio, a coding assistant, or your own router, decides whether to call your agent, the tool description is all it reads. A vague description means your agent gets called for the wrong questions, or not at all.
The strong version says what the agent knows, the shape of questions it answers, the unit it answers in, and what it does not do. That last sentence is what lets a router send a forecast question somewhere else. I cover the protocol itself, the handshake, identity, and working client code in the next post in this series.
2. Data Source Routing Is GA
An agent with more than one data source has to decide, for every question, which source to query. That routing step went generally available in August. The agent picks the most relevant lakehouse, warehouse, semantic model, or KQL database using four inputs: the schema metadata, the data source descriptions, the example queries on each source, and any routing rules you write into the instructions.
Of those four, the data source description is the one most people leave blank, and it is the cheapest to fix. Treat it like the publish description, one level down: what the source contains, what questions it answers, and what distinguishes it from the source next to it.
Routing being GA does not change the advice from my five tips post: fewer sources still beat more sources. Routing makes multi-source agents viable. It does not make overlapping sources unambiguous. If two sources both have a plausible "sales" table, write the description that tells them apart, or take one away.
3. Standard and Preview Runtimes
Every data agent now runs on a runtime: the orchestration, planning, routing, and query-generation tools behind the chat box. There are two.
Standard runtime
The GA runtime and the default for new agents. Updated rarely, and only with changes that already proved themselves in preview. This is the one for production agents where predictable behavior matters more than the newest improvement.
Preview runtime
The newest query generation, ahead of GA. For SQL sources that includes an improved NL2SQL engine that follows your example queries more closely, works out implied filter values, and asks a clarifying question when a question is ambiguous, plus schema object descriptions for business context on tables and columns.
Two details are easy to miss. First, the runtime is pinned when you publish. If you publish while the agent is on preview, the published version stays on preview until you republish. Second, model upgrades apply to both runtimes, so the runtime choice controls the tooling around the model, not the model itself. You can switch runtimes from the SDK, which makes it easy to script:
My approach: keep the production agent on standard, and keep a copy on preview that runs the same evaluation set from the automated testing post. When the preview copy scores better and stays better for a few weeks, move production over and republish. A runtime is a dependency. Upgrade it the way you upgrade any other dependency: with tests.
4. Instructions Have a Recommended Shape
Microsoft now publishes a recommended structure for both layers of instructions. Agent instructions cover Objective, Data sources, Key terminology, Response guidelines, and Handling common topics. Data source instructions cover General knowledge, Table descriptions, and When asked about. If you followed my instructions post, you are already most of the way there. The value of a shared shape is that the agent, your teammates, and your future self all know where a rule lives.
The principle has not changed, and it is the single most useful idea I know for data agents: the agent cannot guess your business rules. It reads your schema literally. In nearly every agent I build, the wrong answers trace back to one of three rules nobody wrote down:
Units
Amounts stored in many local currencies get summed as if they were one. The total looks plausible and is off by a multiple. State the conversion, and show it in an example query.
What counts
Credit notes, returns, test accounts, and cancelled orders sit in the same table as real sales. Say which document types count, in the agent's terminology section.
Time
Left alone, the agent writes YEAR(GETDATE()) for "this year". If your data lags, or a period is not complete yet, define "this year", "last year", and which months count for budget comparisons.
One addition earns its place now that agents are called from code: the Response guidelines section. When a person reads the answer in the portal, format is a nicety. When an app reads it over MCP, format is an interface. A fixed shape (a one-line answer, a few key points, a table with units in the headers, a note on the assumptions applied) is what lets code turn an answer into something useful. I come back to this in the last post of the series.
5. Charts in the Portal, Text Over the Wire
In the Fabric portal, data agents can now answer with interactive charts as well as text and tables, built on the same Fabric Visuals foundation used elsewhere in the platform. Ask "show me sales by region" and you may get a column chart. You can steer this from the agent instructions, including turning visuals off.
The catch for anyone embedding agents: the rendered chart stays in the portal. Through the SDK, Copilot, or MCP, you get text and markdown tables. That is not a problem if you plan for it. It means the app that embeds the agent owns the presentation layer, which is where it belonged anyway: your app knows your brand, your chart conventions, and what the user was looking at when they asked.
6. Build a Team, Not a Monolith
Put the changes together and a design pattern falls out. Every published agent is a tool with a description. Orchestrators pick tools by description. So the natural unit is not one agent that knows everything, but a small team of narrow agents, each with its own tables, instructions, example queries, and a description that says exactly when to call it.
| Agent | Answers | Deliberately leaves out |
|---|---|---|
| Sales Analyst | Net sales, budget gaps, growth, key accounts | Orders, forecast, employees |
| Operations | Open order backlog, on-time delivery, late penalties | Budget, forecast |
| Planning | Forecast against budget, by product and territory | Orders, employees |
Each agent sees fewer tables, so it has fewer wrong joins to choose from. Each one can be evaluated, tuned, and republished on its own schedule. And because they share a protocol, combining them is somebody else's job: Copilot Studio, a coding assistant, or a few lines of routing in your own app. The "leaves out" column is as much a part of the design as the "answers" column.
A Checklist for Agents You Already Have
If you built agents earlier this year, including by following this blog's earlier series, here is what I would do this month, in order:
- Find anything that calls an agent through the Assistants API (look for
/aiassistant/openai, threads, or runs) and move it to the MCP endpoint. This one is not optional anymore. - Rewrite each publish description as a tool description: what it knows, which questions, which unit, and what it does not cover. Then republish.
- Fill in every data source description, especially on agents with more than one source.
- Copy one agent to the preview runtime and run your evaluation set against both. Let the scores decide when to move.
- Re-validate your example queries with the SDK's validator, covered in the example queries post. A runtime that follows examples more closely makes a bad example more harmful, not less.
What's Next in This Series
This post is the map. The next three are the territory. First, the MCP endpoint in depth: the four messages behind every call, why the real decision is whose identity asks, and working clients in Python and Node. Then Fabric app functions: server-side code that ships with a Fabric app and can call an agent as the app itself, with no app registration and no secret. Finally, putting it all together: an embedded analytics app where live charts and a team of agents sit side by side. Agents answer. Functions act. The rest of the series is about wiring those two ideas together.
Further Reading
- Data agent as Model Context Protocol server: Microsoft Learn on the MCP endpoint
- Fabric data agent runtime: what is in the standard and preview runtimes today
- Data agent configurations: the recommended instruction templates and data source descriptions
- Five Things That Separate Good Fabric Data Agents from Demos: the earlier series, starting from the top