If you've wanted to ask an AI agent questions about your own Business Central data, you'll have hit this wall. Out of the box an agent can read customers, items, sales documents and G/L entries. Ask it about anything else, a custom table or a field your partner added for your warehouse, and somebody first had to write an extension and deploy it. A one-off question turned into a development project.
Business Central 2026 release wave 2 removes that step. An agent can now write, check and run its own read-only query against any table the signed-in user is allowed to see, and the answer doesn't wait on a developer.
Say a finance or operations team wants to know which items haven't moved this quarter. They can now get the answer from the live system instead of adding the question to a developer's backlog. The catch is that the user's permission sets become the only fence, so check them before anyone switches it on.
Microsoft lists the feature as Run data queries with MCP Server in the update 29.0 what's new table under Copilot and agents, roadmap ID 573312. The Microsoft 365 roadmap entry gives the status as launched, general availability, October CY2026, worldwide standard multi-tenant. Inside the product the switch itself is labelled differently, and that difference matters when you plan a rollout.
What actually changed
The Business Central MCP server has been around since the 2025 wave 2 release, and its model was API pages. An agent connected, discovered the API pages and API queries the signed-in user was allowed to see, and worked through them. Read, create, modify, delete and bound OData actions all flowed through objects a developer had published. Microsoft's own documentation is blunt about the ceiling there, noting that extending APIs with additional fields isn't currently possible and that if you need it you must copy the AL code for the API and create a custom API based on it.
So the practical shape of an agent project went like this. You'd scope the questions the agent should answer, work out which tables hold the answers, find out that three of them have no API page, write the AL, get it through a deployment cycle, then start building the agent. The data access work came first and it was the slow part.
Data Query Tools turns that order round. The MCP overview describes the feature in one line. It enables agents to run queries directly against your Business Central database. The agent composes the query itself, Business Central validates it, and the result comes back. No new object, no deployment, no AL developer in the loop for a question nobody anticipated.
Turning it on
The configuration lives on the Model Context Protocol (MCP) Server Configurations page in Business Central. You need at least the MCP - Admin permission set or equivalent, per the configuration guide.
Create a configuration, give it a name and description, and leave Active switched off while you work. An active configuration is read-only and its settings aren't editable until you deactivate it, which is a small detail that will catch you out once and never again.
Then the Server Features section. There are three:
- API Tools exposes the list of API pages and API queries your agents can access, curated by an admin.
- Dynamic Tool Mode lets agents discover tools dynamically instead of requiring manual configuration. It depends on API Tools, and disabling API Tools automatically turns it off. The docs give the reason you'd want it: client tool limits, such as Copilot Studio's 70-tool limit.
- Data Query Tools (Preview) enables agents to run queries directly against your database. Select Activate to turn it on. No additional configuration needed.
That last sentence is the whole setup. There's no allow-list of tables to curate and no per-object read flag, nothing like the Allow Read, Allow Create, Allow Modify, Allow Delete and Allow Actions permissions you set on individual API objects. You activate the feature and the agent can query the database.
Be deliberate about this part. The permission model doesn't disappear. Authentication runs OAuth 2.0 authorization code flow with PKCE against Microsoft Entra ID, and all operations are performed with your user identity and permissions, so audit trails show who performed each action. The agent is the user. But the per-object gate that an admin curated by hand is replaced by whatever that user's Business Central permission sets allow. Maybe your permission sets are loose because the only things that used to read tables were pages a developer had reviewed. Once you switch this on, that assumption stops holding.
What the agent is writing
The queries are AL query objects, the same construct developers have used for years. A query object retrieves records from one or more tables and combines them into rows and columns in a single dataset, and can perform calculations such as sums or averages over a column. It's built from two main element types, dataitems, which specify the table to retrieve records from, and columns, which specify a field to include in the result.
The agent works through four documented tools (configuration guide):
bc_data_find_tablesfinds tables by keyword or semantic search.bc_data_get_table_schemareturns a table's fields, which vary by environment and installed extensions.bc_data_get_table_relationsreturns the relations an agent follows to join tables.bc_data_querycompiles and validates an AL query, and runs it only whenreturnDataistrue, withtop,skipandresultFormatfor paging.
That is the define, validate, run sequence in practice: find the tables, read their schema and relations, write the query, check it compiles, then ask for rows. A query summing each customer's balance from its detailed ledger entries has roughly this shape:
query 50100 "Customer Balances"
{
QueryType = Normal;
elements
{
dataitem(Customer; Customer)
{
column(No_; "No.") { }
column(Name; Name) { }
dataitem(DetailedEntry; "Detailed Cust. Ledg. Entry")
{
DataItemLink = "Customer No." = Customer."No.";
column(Amount; Amount)
{
Method = Sum;
}
}
}
}
}
That query object shows the structure only; the MCP tools didn't produce it. The agent produces a known, compiled, typed AL query, not free-text SQL against your tenant. Business Central compiles it, and the AL diagnostics that constrain a human developer constrain the agent too. Queries must define a top-level DataItem (AL0343), the DataItemLink property must be set for nested data items (AL0344), and the source of a Column or Filter must be a field (AL0345). A malformed query fails to compile and the agent gets an error it can act on. We'd much rather have that than a syntactically valid query returning the wrong rows.
Connecting a client
Every MCP host connects to the same endpoint, https://mcp.businesscentral.dynamics.com. Four HTTP headers select the context, TenantId, EnvironmentName, Company and the optional ConfigurationName. Which of them a host can leave out depends on the host, and Microsoft's own pages disagree on the detail. Visual Studio Code with GitHub Copilot can omit all of them in both. The overview says GitHub Copilot CLI can omit all three of TenantId, EnvironmentName and Company and Copilot Studio needs all three; the configuration guide says Copilot CLI can omit only TenantId and Company, and Copilot Studio doesn't need TenantId. Test with your host before relying on either.
One encoding rule is worth knowing before it bites you. If the Company or ConfigurationName values contain non-ASCII characters such as ø, æ or å, encode them Base64 UTF-8 in the format =?base64?<encodedvalue>?=. So CRONUS Århus A/S becomes =?base64?Q1JPTlVTIMOFcmh1cyBBL1M=?=. Microsoft's overview pairs that name with Q3JvbnVzIMOFcmh1cyBBL1M=, which decodes to Cronus Århus A/S; encode your own company name rather than copying the example. Copilot Studio handles the encoding for you.
Microsoft hosts use a preregistered application. Non-Microsoft clients, Claude and ChatGPT among the supported MCP-compliant options, require you to register your own application.
Where the limits sit
It's read-only analysis. The overview lists running read-only queries directly against your database for advanced analysis as a distinct capability from viewing and managing records or executing business processes. If you want an agent to post a document or change a status, that's still API Tools, with Unblock Edit Tools on and the Allow Actions checkbox ticked on that API object in the configuration. Data Query Tools doesn't give you writes and shouldn't.
It's a live production database. Every query the agent runs is load on the system your warehouse staff are using. An agent that reasons its way to the answer by trying six variations of a join across the item ledger is doing that against the same tenant that's trying to post shipments. Microsoft documents no throttle or cost control for this feature, and result size is only what the agent asks for through bc_data_query's top and skip paging. The only controls are the ones you impose. Think about a sandbox for development, and take a hard look at whether exploratory agent traffic belongs on production at all.
And there is the preview label. The Learn what's-new table lists the feature at general availability and the roadmap says launched, GA, October 2026. The server feature in the configuration page is called Data Query Tools (Preview). Treat the in-product label as the operative one, because that's the surface you're switching on. Preview features change. Build an internal agent on it now, and keep it out of the path of a customer-facing commitment this quarter.
Finally, it answers questions about one company in one environment at one moment. It has no history beyond what your tables retain, no data from your CRM or your warehouse management system, and no cheap way to scan three years of ledger entries for a trend.
Where the lakehouse picks up
That last limit is where we draw the line. Conversational questions about current state belong on MCP. Questions that span years, span systems, or feed a model belong somewhere the data has been landed and shaped.
Getting Business Central into Databricks takes more work than the conversational side, because there's no managed connector for it. The Lakeflow Connect Dynamics 365 connector reads data that Azure Synapse Link exports from Dataverse, and Business Central doesn't keep its data in Dataverse. Two routes work:
- The API, incrementally. A Databricks job pulls the standard API pages with a
lastModifiedDateTimefilter, so each run reads only what changed. Run it under its own account, so the reporting load doesn't spend a person's request quota. - bc2adls. It exports Business Central tables incrementally to Azure Data Lake Storage or Microsoft Fabric, where Databricks picks them up. Microsoft archived its own repository in September 2023; the community fork is the one still being released.
MCP handles the question a controller asks on a Tuesday afternoon about an open order, and the lakehouse handles the forecast, the margin trend and anything an ML model trains on. We wrote about choosing between those layers in Business Central reporting: built-in, Power BI or lakehouse, and this feature sharpens that choice. Data Query Tools makes the conversational layer useful without a developer, so the lakehouse no longer has to carry the "somebody wants to ask an odd question" workload. It can stick to the analytical work it's good at.
If you are starting this week
Stand up a Business Central sandbox on 29.0 and create a named MCP configuration instead of modifying the built-in default, which has dynamic tool mode and read-only object discovery on and is used whenever a connection doesn't specify ConfigurationName. Activate Data Query Tools there and connect Visual Studio Code with GitHub Copilot first, because it can omit all four headers and you'll find out whether the feature does what you need in minutes instead of after an app registration.
Then go and read your permission sets. The feature has no per-table configuration, so a user's permission sets are the entire access boundary. Pick the account the agent will authenticate as and enumerate what it can actually see, before you point anything at a production environment.
If you're already landing Business Central data in Databricks, nothing here replaces that; the API's request budget and the export schedule still shape that architecture. Our data integration work tends to start exactly there. What changes is that "does this table have an API page?" stops being the first thing that blocks an agent. Nobody enjoyed answering that one.
Frequently asked questions
What is Data Query Tools in the Business Central MCP server?
Data Query Tools is a server feature on the Business Central MCP server that enables agents to run queries directly against your Business Central database, letting them reach data for which no existing API page exists. It's activated per MCP server configuration from the Model Context Protocol (MCP) Server Configurations page and requires no additional configuration once turned on.
Do I still need API pages for Business Central agents?
You need API pages for anything that writes, because create, modify, delete and bound OData actions still run through API Tools with the relevant Allow permissions on each object. Data Query Tools covers read-only analysis, so the pattern is API pages for the operations an agent performs and data queries for the questions it answers.
Is Run data queries with MCP Server generally available or in preview?
Microsoft's update 29.0 what's new table lists it at general availability and the Microsoft 365 roadmap gives an October CY2026 GA date with status launched, while the server feature in the Business Central configuration page is labelled Data Query Tools (Preview). Plan against the preview label, since that's the switch you're actually enabling and preview features can change.
How do I get Business Central data into Databricks?
There's no managed connector for Business Central, so it's one of two routes: a Databricks job that reads the Business Central APIs incrementally with a lastModifiedDateTime filter, or the bc2adls extension, which exports tables to Azure Data Lake Storage or Microsoft Fabric for Databricks to read. We compare them in Business Central reporting: built-in, Power BI or lakehouse.