Back to posts
Part 3 of 6 · Fabric Data Agents in Your Apps
Sep 08, 2026•9 min read

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.

Your codeVS Codeany MCP clientCopilot StudioGA in AugustAssistants-stylethreads · runs · pollingshut down Aug 26MCP endpointone tool per agentPublished agentLakehouseWarehouseModelrouting picks one per question
The summer in five steps

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:

# Every published data agent has one of these
https://api.fabric.microsoft.com/v1/mcp/workspaces/{workspaceId}/dataagents/{dataAgentId}/agent

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.

# Publish description: written for a machine that has to choose
# Weak
Sales data agent.
# Strong
Answers questions about net sales and the sales budget: totals and trends
by month, region, product and key account, gaps against budget, and
growth against last year. All amounts in USD. Does not cover open
orders, deliveries or forecasts.

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.

# Data source description: two sources that could both answer "sales"
SalesLakehouse
Invoice-level actuals, one row per invoice line, from 2019 to yesterday.
Use for net sales, returns, and anything by customer or product.
FinanceModel (semantic model)
Monthly budget and forecast by region and product line.
Use for budget, forecast, and plan-versus-actual at month grain.
Has no customer-level data.

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:

# Switch an agent to the preview runtime with the Fabric data agent SDK
from fabric.dataagent.client import FabricDataAgentManagement
agent = FabricDataAgentManagement("Sales Analyst (preview trial)")
agent.update_configuration(enable_preview_features=True)
# ...run your evaluation set against it...
agent.update_configuration(enable_preview_features=False) # back to standard

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.

## Key terminology (agent instructions)
- Net sales: invoice value of real invoices only (document group = 'Invoice'),
converted to USD at the monthly rate on the billing date.
Credit notes and returns are not sales.
- This year: 1 January to the latest billing date in the data.
- Against budget: compare complete months only.
- "Sales" and "revenue" both mean net sales.

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

Tags

Microsoft FabricAIData AgentsMCPCopilot Studio