Weekly ML Roundup: Fabric Agents, MCP, and Warehouse Tuning

by TechHub

This week's ML roundup focuses on making agent experiences more governed and repeatable in Microsoft Fabric, from the new Fabric Data Warehouse MCP Server preview to tighter routing controls for Fabric data agents. On the data platform side, Fabric Data Warehouse added new tuning and cost tools, including GPU-powered Query Acceleration and Custom SQL Pools, plus practical guidance for Bronze-Silver-Gold layering. Security and operations also moved forward with CMK REST APIs, identity-based Event Hubs connections for Eventstream, and more production-friendly monitoring and dashboard KPIs to help teams run streaming workloads with clearer controls.

This Week's Overview

Agentic SQL for Fabric and beyond with MCP

Building on last week's agent-building guidance around Microsoft IQ MCP endpoints across web, work, Fabric, and Foundry, Microsoft is leaning harder into the Model Context Protocol (MCP) as a standard way to let AI agents work with governed enterprise data, and Fabric Data Warehouse is now part of that story. The new Fabric Data Warehouse MCP Server (remote) is in preview and lets MCP-compatible agents execute T-SQL directly against Fabric Warehouses, while “Skills for Fabric” provide Fabric-specific guidance for authoring, querying, and operational diagnostics.

For developers, this is a shift from ad-hoc prompt-to-SQL patterns toward a more structured integration where an agent can call well-defined tools and operate under workspace identity and policies. The preview calls out Microsoft Entra ID OAuth 2.0 for authentication, which matters if you need to align agent access with existing identity, Conditional Access, and audit requirements.

In parallel, the SQL MCP Server approach (built on Data API Builder (DAB)) positions MCP as a governed gateway for AI tools like GitHub Copilot to query SQL Server, Azure SQL, and Fabric SQL Database without handing the model direct raw SQL access. If you are evaluating agent access, the practical comparison is: Fabric's MCP server targets warehouse workflows (T-SQL plus Fabric operational conventions), while SQL MCP Server leans into a broader “API-shaped” access pattern where RBAC and API surface design limit what an agent can do by default.

Fabric Data Warehouse performance, cost, and architecture choices

Fabric Data Warehouse updates this week clustered around a familiar set of concerns: faster queries under concurrency, keeping billing predictable, and maintaining clean layer boundaries as workloads grow (a practical follow-on to last week's medallion pattern discussion for Fabric Data Warehouse). Taken together, they point to Fabric DW maturing from “it works” into “you can tune and govern it”.

GPU-powered Query Acceleration (Preview)

Query Acceleration (Preview) introduces GPU offload for eligible parts of SQL query plans, including operations like scans, joins, filters, and aggregations. The goal is better throughput and lower latency when concurrency increases, and the post ties the design to SIGMOD '26 research and the underlying Tensor Query Processor (TQP) work.

Operationally, the preview emphasizes that this is something you validate and monitor, not just “turn on and hope”. It calls out SSMS execution plans plus Fabric Query Insights as the places to confirm when GPU acceleration kicks in and to compare before/after behavior, which is important if you need to explain performance shifts to stakeholders or justify capacity changes.

Custom SQL Pools for workload isolation and allocation control (Preview)

Custom SQL Pools in Fabric Data Warehouse are positioned as a way to isolate workloads and add governance controls, with a cost angle that is hard to ignore under allocation-based billing. The guidance focuses on limiting vNode scaling to reduce billed allocation peaks, which is a practical lever if you are seeing short-lived spikes from ETL, BI refreshes, or ad-hoc exploration.

The post is explicit about fit and limits: SQL Pools are not a generic fix for every performance issue, and you should treat them as a tool for shaping and governing concurrency rather than as a magic “make queries faster” toggle. It also hints at upcoming identity-based and configurable workload governance features, which suggests this area will become more policy-driven over time.

Medallion layering in Fabric DW (Bronze → Silver → Gold)

Following last week's coverage of medallion pattern choices, a separate guide this week focused on implementing the Bronze/Silver/Gold (medallion) pattern inside Fabric Data Warehouse, with concrete ingestion and transformation options. It highlights COPY INTO for ingestion, then CTAS (create table as select) and MERGE as core transformation tools, with an emphasis on keeping each layer's responsibilities clean.

For teams standardizing pipelines, the useful takeaway is that the medallion model is less about file formats and more about predictable contracts: Bronze captures raw or lightly structured data, Silver applies cleansing and conforming, and Gold serves analytics-ready schemas. The patterns described map cleanly to common “incremental load + upsert” warehouse workflows, which can help reduce the temptation to do everything in a single ever-growing table.

Fabric data agents: better routing and more readable outputs

Fabric's data agent work this week combined a generally available control (routing) with a preview UX improvement (visuals), both aimed at making natural-language query (NLQ) workflows more predictable, which fits the same “governed context for agents” direction we highlighted last week with IQ endpoints. The common theme is tightening the gap between “ask a question” and “trust the answer”.

Data source routing (Generally Available)

Data source routing for Fabric data agents is now generally available, giving you control over which sources an agent should query when answering questions. That matters if your workspace has overlapping representations of the same domain (lakehouse tables, warehouse tables, Power BI semantic models) and you want to avoid inconsistent answers that depend on whichever source the agent picks first.

In practice, routing becomes part of your governance story for agent experiences: you can steer the agent toward curated models for business users, while still allowing engineers to point it at raw sources for diagnostics. If you are rolling out agents broadly, this feature is the difference between “cool demo” and “repeatable behavior”.

Fabric Visuals in agent responses (Preview)

In preview, chart responses generated inside data agent conversations now render using Fabric Visuals, improving consistency with the rest of the Fabric experience. The update explains when visuals appear, which chart types are supported, and which backends can feed them (including lakehouses, warehouses, and Power BI semantic models).

This is not just UI polish: standard visuals reduce the “is this chart trustworthy?” friction because users see familiar formatting and interaction patterns. For teams building internal analytics copilots, consistent rendering is part of adoption, especially when you need to compare an agent-produced chart with a dashboard tile and spot discrepancies quickly.

Security and governance in Fabric: CMK APIs and identity-based connections

Several updates this week improved how you secure and audit Fabric environments, especially around encryption ownership and removing secrets from connection strings, extending last week's operational hardening theme (recovery defaults, gateway evaluation, and scheduled functions). The practical thread is “make security programmable and identity-driven” so controls scale with platform adoption.

Customer-Managed Key (CMK) REST APIs for workspaces (Generally Available)

Customer-Managed Key (CMK) REST APIs for Fabric workspaces are now generally available, enabling programmatic assignment and rotation, inspection, reset, and tenant-wide reporting of workspace encryption state. The keys are backed by Azure Key Vault, which helps teams align Fabric encryption with existing key management policies and separation-of-duties requirements.

For platform engineers, the key win is automation: you can fold CMK state checks and key rotation into CI/CD or compliance jobs instead of treating them as one-off portal tasks. Tenant-wide reporting is particularly useful for proving coverage during audits, and for catching newly created workspaces that defaulted to platform-managed keys.

Workspace identity for Azure Event Hubs sources in Eventstream (Preview)

Building on last week's Change Event Streaming direction (with Event Hubs as a key sink option), Eventstream (preview) added workspace identity authentication for Azure Event Hubs sources, letting connections use Microsoft Entra ID tokens and Azure RBAC instead of shared access keys embedded in connection strings. This is a concrete reduction in secret sprawl and an easier alignment with standard enterprise access controls.

The change matters most for teams that treat Event Hubs as a shared ingestion backbone, where connection-string leakage is a recurring risk. With identity-based auth, you can manage access using RBAC roles and rotate credentials implicitly via Entra, which simplifies incident response and reduces manual key rotation work.

Streaming and observability: more control for Eventstreams, plus dashboard KPIs

Streaming and event operations stayed in focus after last week's end-to-end “capture → route → analyze” Fabric event story, with updates that make it easier to run production pipelines without treating monitoring and dashboards as afterthoughts. Fabric's real-time and streaming surface area continued to fill in the “operability” gaps: better at-a-glance health indicators for stakeholders, and more granular control over what telemetry you emit. Both changes help teams run production workloads without turning monitoring into an all-or-nothing decision.

Per-Eventstream monitoring controls in Workspace Monitoring (Preview)

Workspace Monitoring for Eventstreams now supports per-eventstream enablement and is default-off in the preview update. The post details the KQL tables emitted for metrics, errors, and node status, and it explains how to query that data and build dashboards (typically in an Eventhouse-backed monitoring flow).

For developers running multiple pipelines, per-eventstream control is a cost and noise management tool: you can enable deep monitoring for critical streams while leaving low-risk ones off until they are promoted. It also makes it easier to test new pipelines without polluting shared monitoring views.

KPI visualization in Real-Time Dashboards (Generally Available)

A KPI visualization for Fabric Real-Time Dashboards is now generally available, targeting the common “single number + context” use case. It supports multiple display modes, configurable scales and status ranges, value formatting, and reference lines for targets (for example, SLA thresholds) driven by Kusto Query Language (KQL) results.

This is a practical building block for teams that want operational dashboards that do not require custom visuals. Reference lines and conditional status ranges reduce the need for separate “is this OK?” logic in the query layer, and they make it easier to standardize how different squads present latency, error rates, and throughput metrics.

Other Machine Learning News

Fabric Planning in Fabric IQ refined billing personas for PowerTable, with dynamic Viewer/Stakeholder/Planner role assignment and 30-day session metering (including per-role CU rates and attribution in the Capacity Metrics app). If you manage shared capacities, this is the kind of change that can alter chargeback models and make it easier to explain where consumption came from.

A separate connectivity guide compared VNet data gateway, On-premises Data Gateway (standard mode), and direct cloud connections for Data Factory runtime workloads, framing the choice around data location and private network boundaries (including Private Endpoint and ExpressRoute). These decisions have downstream impact on reliability, latency, and which security controls you can enforce at the network layer.

Microsoft also published several developer-oriented walkthroughs: a demo of building AI apps securely with SQL data across Azure and Fabric, a vector search tutorial focused on DiskANN in SQL Server (including hybrid queries that combine vector similarity with metadata filters and full-text search), and a broader 2026 recap of SQL and developer tooling trends (including AI, vectors, drivers, containers, CI/CD, and security). These are useful for teams trying to connect the platform announcements to concrete patterns and code.