Connecting Databricks to Microsoft Copilot Studio means your agents can answer questions over governed lakehouse data instead of a handful of documents. You do it one of two ways: add a Databricks Genie Agent as a tool so the agent turns natural-language questions into live SQL, or add Databricks tables as a knowledge source for grounding. Both run through the official Databricks connector for Power Platform, which reached general availability in June 2026, and both keep Unity Catalog governance intact so the agent only ever returns data the signed-in user is already allowed to see.

This guide is written for the data leaders, platform architects, and IT directors who already run Databricks and now want Copilot agents that reason over real enterprise data without copying it, leaking it, or guessing at the math. It covers the two connection patterns, what you need before you start, how the security boundary actually works, the production failures teams hit most often, and what the whole thing costs to run.

Key Takeaways

• There are two integration modes, and they solve different problems. A Genie Agent added as a tool runs natural-language-to-SQL over curated tables; Databricks as a knowledge source grounds answers in table content for retrieval-style Q&A.
• The connector is generally available, but the Genie-in-Copilot-Studio path is still Public Preview. You must enable the Managed MCP Servers preview in your Databricks workspace for the Genie tool to work.
• Governance lives in Unity Catalog, not in the agent. With end-user credentials, the agent executes as the signed-in user, so object privileges, row filters, and column masks decide every answer.
• Serverless SQL compute is the practical default. A classic warehouse will not spin up on its own when a colleague queries the agent, which is the single most common "it works for me but not for them" failure.
• This is a premium, Microsoft-commercial-cloud capability. The connector requires premium Power Platform licensing and is not available in GCC, GCC High, DoD, or the China cloud.
• The Genie tool is read-only and rate-limited. It queries data rather than writing it, keeps no conversation history on its own, and is capped at roughly five questions per minute by API limits.

The short answer: two ways to connect, and when to use each

Both patterns start from the same foundation: you create a Databricks connection on Power Platform, then consume it inside Copilot Studio. Where they differ is what the agent does with the data. Pick based on whether users need computed answers over large datasets or grounded answers over table content.

Genie Agent as a tool vs. Databricks as a knowledge source

Genie Agent as a tool (via Managed MCP)

• What it does: Turns a plain-language question into SQL, runs it against a curated Genie Agent, and returns the exact result with Unity Catalog permissions enforced on every request.
• Best for: Accurate numbers over large datasets — totals, trends, and aggregations where the answer must be computed, not guessed.
• Scope and limits: A Genie Agent covers up to 50 Unity Catalog tables, views, or metric views, and the MCP server is read-only with no conversation history of its own, per the Databricks Genie Agent MCP documentation.

Databricks as a knowledge source

• What it does: Adds selected tables from a catalog as grounding material the agent reads for context when it answers.
• Best for: Retrieval-style Q&A over structured content, following the steps in Microsoft's Copilot Studio integration guide.
• Scope and limits: Grounding is strong for lookups but less reliable for precise calculations or very large result sets, which is exactly why many teams move the compute to a Genie Agent instead.

The practical rule: if the question is "what is the number," use a Genie Agent so the SQL engine computes it; if the question is "what does this record say," a knowledge source is enough. A single agent can use both.

What do you actually need before you start?

Most failed setups trace back to a missing prerequisite rather than a wrong click. Line these up first.

• A Databricks connection on Power Platform. Create it in Power Apps or Power Automate first; the connector is then available inside Copilot Studio, per the Databricks connection setup guide.
• Premium Power Platform licensing. The Databricks connector is classed as Premium across Power Apps, Power Automate, and Copilot Studio in the Microsoft connector reference.
• The Managed MCP Servers preview enabled in your Databricks workspace, which is required to expose Genie Agents to Copilot Studio.
• A curated Genie Agent with a clear name and description. The orchestrator uses that description to decide when to call it, so vague metadata produces an agent that never fires.
• The right Unity Catalog grants for every end user: at least CAN VIEW on the Genie space, SELECT on the underlying data, and CAN USE on the SQL compute, as the Databricks enterprise OAuth guide spells out.
• Generative (AI) orchestration turned on in the agent settings — without it, the agent discovers the tools but never invokes them.

How does the security boundary actually work?

This is the part that makes the integration enterprise-grade rather than a demo. When you connect with end-user credentials, each person authenticates to Databricks with their own identity, and the agent runs every query as that user. If they lack access to a table, the agent cannot return it — no prompt wording required. The alternative, maker-provided credentials, runs everyone through a single shared identity or service principal, which is simpler but collapses per-user governance.

The deeper point is where the controls live. Databricks enforces access in Unity Catalog through object privileges, attribute-based policies, row filters, and column masks, all evaluated at query time against the user's identity. As Databricks puts it in its guidance on governed Genie Agents, the catalog, not the language model, stays your security perimeter.

If your only control is an instruction telling the model not to show restricted data, you have made the LLM your security perimeter — and that is not a boundary an auditor will accept.

That distinction is why this pattern fits regulated environments. The same OAuth identity that governs a user's access to a Databricks table now governs what a Copilot agent can say about it, and every tool call is authenticated, permission-checked, and logged against that identity rather than a shared account.

Getting this boundary configured correctly — identity passthrough, Unity Catalog policy design, and the Power Platform DLP that wraps the connector — is where most internal teams stall. BabyBots builds governed Copilot agents as fixed-fee engagements, wiring the identity and data-access model before a single agent reaches production, so the security story holds up under review instead of being retrofitted after it.

What goes wrong in production?

The setup demos cleanly and then breaks the moment a second person uses it. The failures are predictable, and nearly all are configuration rather than protocol.

• The warehouse will not wake up. A classic SQL warehouse does not auto-start when a colleague queries the agent, so the agent works for its builder and fails for everyone else. Serverless SQL compute spins up on demand and avoids this entirely.
• Sharing fails on permissions. An agent shared to a security group still returns nothing unless each member holds the Unity Catalog grants and warehouse CAN USE permission — a gap visible across multiple community troubleshooting threads.
• Tools are discovered but never invoked. If AI orchestration is missing or off, Copilot Studio lists the Genie tools yet answers from its own knowledge instead of calling them. Turning on generative orchestration is the fix.
• Answers stall or truncate under load. The Genie tool in Copilot Studio is capped at about five questions per minute by API limits, so a busy agent needs to be designed around that ceiling rather than discovering it in production.
• No memory across turns. Because the Genie Agent MCP server passes no conversation history, follow-up questions lose context unless you orchestrate state in the Copilot Studio agent itself.

None of these are reasons to avoid the pattern. They are reasons to treat it as an architecture task — identity, compute mode, orchestration, and rate design decided up front — the same discipline that applies when you connect Copilot Studio agents to your systems with MCP more broadly.

What does it cost to run?

The bill has three independent parts, and underscoping any one of them is how a "free connector" becomes a surprise line item.

• Databricks compute. Every Genie query runs on a SQL warehouse, so you pay Databricks for the compute the agent drives — which is why serverless, with its scale-to-zero behavior, is usually the right default for intermittent agent traffic.
• Power Platform licensing. The connector is premium, and Microsoft guidance indicates premium entitlement applies to the users who run or interact with the agent, not only the person who built the connection.
• Copilot Studio consumption. Building and running agents is metered in Copilot Credits on top of the above, so the agent's design — how often it grounds, calls tools, and reasons — drives the recurring cost.

One availability constraint matters for regulated buyers: the Databricks Power Platform connector does not support US government clouds (GCC, GCC High, DoD) or the China cloud, per the Microsoft connector reference. If your tenant is sovereign, this pattern is not yet an option.

Frequently Asked Questions

Can Copilot Studio connect to Databricks directly?

Yes. You create a Databricks connection on Power Platform, then either add a Genie Agent as a tool or add Databricks tables as a knowledge source inside Copilot Studio. The connector reached general availability in June 2026, though the Genie-as-a-tool path still runs as a Public Preview that requires the Managed MCP Servers preview enabled in your workspace.

What is the difference between a Genie Agent and a knowledge source?

A Genie Agent converts natural language into SQL and runs it against curated Unity Catalog tables, so it returns computed, exact results over large datasets. A knowledge source grounds the agent in table content for retrieval-style answers. Use Genie when accuracy on numbers matters; use a knowledge source for lookups over structured content.

Does connecting Databricks to Copilot Studio break data governance?

No, if you use end-user credentials. The agent executes as the signed-in user, and Unity Catalog enforces object privileges, row filters, and column masks on every query. The language model never becomes the access boundary — the catalog does — which is what makes the pattern defensible in regulated settings.

Why does my Genie-connected agent work for me but fail for colleagues?

Almost always a compute or permission gap. A classic SQL warehouse will not auto-start for other users, and each user needs CAN VIEW on the Genie space, SELECT on the data, and CAN USE on the warehouse. Switching to a serverless warehouse and granting the Unity Catalog permissions resolves the most common cases.

Do I need a premium license to use the Databricks connector?

Yes. The Databricks connector is classed as premium across Power Apps, Power Automate, and Copilot Studio, and premium entitlement generally applies to the users who run or interact with the agent, not only the maker who created the connection.

Is this available in GCC High or other government clouds?

No. The Databricks connector for Power Platform does not support GCC, GCC High, DoD, or the China cloud as of this writing. Sovereign-cloud tenants need a different approach until Microsoft and Databricks extend availability.

Where this is heading

The direction of travel is clear: governed, natural-language access to the lakehouse is moving into the tools people already use, with identity and permissions carried along rather than reinvented at each surface. Genie is already reachable from Microsoft Teams and Microsoft 365 Copilot as well as Copilot Studio, and the Managed MCP model means the same governed data layer can serve many agents at once. For enterprises, the question is shifting from "can we connect them" to "can we connect them in a way that survives an audit, scales past one builder, and holds its cost." Those are design decisions, and they are best made before the first agent ships.

Book a Databricks + Copilot Studio agent assessment

If you run Databricks and want Copilot agents that answer over your real data without weakening governance, book a BabyBots data-agent assessment. In a single working session we map your Genie or knowledge-source design, the Unity Catalog identity model, the warehouse and orchestration choices, and a cost envelope — so you leave with a governed architecture and a build plan, not a stalled proof of concept.

Sources

• Microsoft Learn — Use Azure Databricks data in Microsoft Copilot Studio
• Microsoft Learn — Azure Databricks and Microsoft Power Platform integration
• Microsoft Learn — Azure Databricks connector reference (licensing and regions)
• Databricks — Create a Databricks connection on Microsoft Power Platform
• Databricks — Genie Agent MCP server (read-only, 50-table scope)
• Databricks — Access Genie Everywhere with Enterprise OAuth
• Databricks — Grounding Genie Agents without losing governance
• Microsoft Learn — Databricks Genie on Microsoft 365 Copilot