Data agents in Microsoft Fabric let users ask questions about data in plain language. As a creator, you connect an agent to supported sources—including SQL databases, lakehouses, Power BI semantic models, and eventhouses—add the business context it needs, and share it with users across Fabric, Teams, Microsoft 365 Copilot, Copilot Studio, and Microsoft Foundry. The data agent can then respond like a domain expert that understands what your tables mean, how your metrics are defined, and which source can answer a question.
The usefulness of a data agent ultimately depends on a simple question: can it translate what a user asks into the right query? That is harder than it sounds.
Enterprise schemas are rarely intuitive. Several tables, columns, measures, or join paths may appear to answer the same question, so a query can be technically valid but still return the wrong result. Advanced NL2SQL and advanced DAX generation help address this problem by allowing the agent to explore the schema and data, validate assumptions, and refine its approach before generating a query.
Both capabilities are available today, and we'll begin rolling the core improvements out to the standard runtime on November 2, with the rollout expected to complete by November 10. In this post, we'll look at how they work, what our internal benchmarks show, the new configurations available for shaping how the agent behaves, and what to consider as you re-test and evaluate your data agents.
Why conversational analytics gets harder with enterprise data
Turning a plain-language question into a correct query is a complicated problem, both for SQL and DAX, requiring the agent to resolve several challenges at once:
- Schemas are large. Enterprise sources can contain hundreds of tables, columns, and measures, and the names alone may not explain when or how they should be used.
- Business context exists outside the data. Definitions such as “revenue” or “active customer” often live in documentation, previous queries, or analysts’ knowledge rather than in the source schema.
- Filter values must match the way data is stored. Users describe concepts naturally, but those concepts must map to the values in the data. For example, a user may ask about “California” when the relevant column stores the value “CA.”
- Questions are ambiguous. More than one column, calculation, or join may appear to satisfy a request.
Individually, each of these can be managed with enough hand-written guidance. The difficulty is that they compound: a single-pass generator has to resolve all of them at once — your schema, your definitions, your filter values — committing to an interpretation before it has any evidence that interpretation is right. When it guesses wrong, the query still runs, and the answer looks no different from a correct one.
Advanced NL2SQL and advanced DAX generation are built around that problem. Rather than generating a single pass, the agent gathers evidence first.
Advanced NL2SQL: the agent explores before it writes
The shift is architectural. Instead of one-shot generation, the agent has sub-tools to explore schema, test joins, and look up real filter values before it writes SQL. Under the hood, you can inspect each step the agent took, and the assumptions and reasoning behind it.
It operates in three modes, each backed by its own sub-tools:
|
Mode |
What it does |
|
Example query following |
Finds a relevant example query and answers by making approved modifications, such as literal filter or parameter substitutions. |
|
Clarifying questions |
Determines it can’t answer reliably without more information and asks targeted clarifying questions before generating SQL. |
|
Data exploration |
When no example directly applies, learns from existing example queries to infer business logic, explores the data to validate assumptions, and iteratively refines its approach. |
What you get as a creator:
- Advanced NL2SQL explores the SQL source schema, tests joins, and looks up real filter values before generating SQL, helping it choose the appropriate tables, columns, relationships, and filters.
- Schema descriptions and topics that teach the agent what your data means, so you get better answers with fewer instructions.
- Better example-following and filter-value substitution for novel questions.
- Handles large schemas far better and runs faster end to end, with more reasoning detail for debugging.
New configurations: schema descriptions and topics
Two new configurations give the agent more of the context it needs. Both are available for SQL data sources on the preview runtime.
Schema descriptions
Schema descriptions attach business context to the objects in your data source — what a table holds, what a column represents, and how each should be used. The agent uses them to interpret large or ambiguous schemas and generate a more accurate query. They matter most where object names don’t carry meaning on their own, or where several tables and columns look interchangeable.
Figure: Schema descriptions add business context to schema objects, helping the data agent interpret your data.
Topics
Topics help you give the agent detailed guidance without sending every instruction with every question. The agent searches your topic content and uses only the sections relevant to the current request. Use data source instructions for rules that must always apply, and use topics for deeper guidance that applies only to a specific subject. You can write topics in Markdown, import multiple files, and review the run steps to see which topics the agent selected.
Figure: Topics organize subject-specific instructions in Markdown to guide the data agent’s query generation.
Internal benchmark testing: Advanced NL2SQL on Preview Runtime vs NL2SQL on Standard Runtime
Better reasoning matters only if it produces better answers without making users wait substantially longer. In an internal benchmark set evaluating answer quality and end-to-end latency, the preview runtime delivered the stronger outcome, answering more questions correctly than the standard runtime while reducing both median and tail latency. Smart-answer accuracy increased from 78.8% to 90.9%.
Latency improved at the same time:
- P50: 28.4 seconds to 26.0 seconds
- P95: 46.8 seconds to 32.9 seconds
Figure: Smart answer accuracy and end-to-end latency, standard runtime versus the Advanced NL2SQL preview, on an internal benchmark set. Accuracy rises 12.1 points to 90.9%, while P50 latency falls 8.3% and P95 falls 29.8%.
*Performance results are based on Microsoft internal testing conducted in 2026 using an internal evaluation set comparing standard NL2SQL to the advanced NL2SQL preview in Microsoft Fabric. Actual results may vary depending on workload, data model, and configuration.
The P95 result shows the largest latency improvement in this benchmark, with latency decreasing from 46.8 seconds to 32.9 seconds. This improvement is most relevant to the slower, more complex queries represented at the tail of the distribution.
Advanced DAX generation: agentic reasoning over semantic models
The agent calls tools, inspects results, and refines its approach to answer harder questions. Instance value indexing searches real column values, so filters match your data. And you get consistent results across Data Agent, Power BI, and M365 Copilot.
For users, this means the agent is more likely to resolve filter terms to the values stored in the semantic model and return consistent answers across supported Microsoft experiences.
Internal benchmark testing: Advanced DAX generation improves accuracy while cutting latency
Our internal Advanced NL2DAX evaluation showed improvements in both answer accuracy and latency. Smart-answer accuracy increased from 89.15% to 91.86%.
At the same time:
- P50 latency: 39.1 seconds to 20.4 seconds
- P95 latency: 97.5 seconds to 34.7 seconds
This represents an approximately 48% reduction in P50 latency and a 64% reduction in P95 latency, along with a 2.7 percentage-point increase in smart-answer accuracy.
Figure: Smart answer accuracy and end-to-end latency, standard runtime versus the advanced DAX generation preview, on an internal DAX generation evaluation set. Accuracy rises 2.7 points to 91.86%, while P50 latency falls 48% and P95 falls 64%.*Performance results are based on Microsoft internal testing conducted in 2026 using an internal DAX generation evaluation set comparing the baseline to the advanced DAX generation preview in Microsoft Fabric. Actual results may vary depending on workload, semantic model, and configuration.
Rolling out the runtime improvements
We'll begin rolling the core Advanced NL2SQL and advanced DAX generation improvements out to the standard runtime on November 2, with the rollout expected to complete by November 10. As part of this rollout, the standard runtime will also move to GPT-5.6 Terra. As the rollout reaches your environment, data agents using the standard runtime will receive these improvements and the model upgrade by default, with no opt-in required.
Figure: The runtime selector lets you switch between standard and preview runtimes to test the data agent’s responses.What is moving to the standard runtime:
- Advanced NL2SQL: improved example-query following, filter-value substitution, and data exploration.
- Advanced DAX generation: the agentic tool-calling loop and instance value indexing.
- Model upgrade: The standard runtime will move to GPT-5.6 Terra for orchestration and supported data agent capabilities.
What stays in preview: Schema descriptions and topics for SQL sources.
We believe these changes deliver significantly better results, based on improvements observed in our internal evaluations. However, results can vary by data source, model, instructions, examples, and workload. Creators can re-test and evaluate their agents on the standard runtime between November 2 and November 10 as the rollout reaches their environment, or try the changes now on the preview runtime.
Moving from one-shot generation to an agent that explores data can change how existing instructions and examples are interpreted. We recommend re-testing:
- Run your existing question set against the standard runtime as the rollout reaches your environment between November 2 and November 10, or switch to the preview runtime to try the changes now.
- Rerun your evaluations with the Fabric data agent SDK and a ground-truth set. Compare the new results with your previous baseline, and use the visible reasoning steps to identify where the agent’s assumptions differ.
- Tune your example queries and instructions based on what the evaluation shows. The agent now explores your data and adapts examples through substitution, so guidance written to work around the previous behavior may no longer be needed.
Re-testing and evaluating your agents will help you confirm the expected quality improvements for your own data and scenarios.
Next steps
If you build data agents in Microsoft Fabric, re-test your agents on the standard runtime as the rollout reaches your environment between November 2 and November 10, or try the changes now on the preview runtime.
For more details:
- Fabric data agent runtime: Learn what the standard and preview runtimes each contain, how to switch between them, and what’s in the preview runtime today.
- SQL sources in Fabric data agent: Learn how NL2SQL and Advanced NL2SQL generate queries over Lakehouse, Data Warehouse, SQL Database and Mirrored Database sources, and which configurations each one can use.
- Semantic model best practices for data agent: Semantic model best practices for data agent: Learn about advanced DAX generation and how to prepare a semantic model so the agent can answer questions accurately.
Microsoft Employee