Your organization already owns the most valuable layer in AI: the context that defines what your data means. This guide shows how Genie One becomes the front door for governed data questions, how Genie Code builds the assets behind it, and how MCP delivers those answers into Teams, Microsoft 365, and the AI tools your teams already use.
Not just a place to read answers — a place to ask questions, get answers grounded in your business context, and take action on what you learn. Business users work in plain language while Genie One handles the data, the documents, and the follow-through, all within your existing Unity Catalog permissions.
Ask, analyze, then act. Schedule recurring tasks, set alerts, save a workflow as a reusable skill, and turn any conversation into a polished document to share by link, email, or PDF.
A self-improving knowledge graph built on your data, documents, and definitions — so Genie knows your business as well as your teams do, and gets better as they use it.
One permission and audit model spanning data, documents, and every connected tool, governed by Unity Catalog and Unity Gateway.
Behind the coworker: anyone can turn a Genie One conversation into a Genie Agent scoped to one use case, with its own instructions, skills, and sources. Genie Code is where analysts and engineers deepen the governed context over time. MCP carries that same context into Slack, Teams, Microsoft 365, Claude, and your own applications. Unity Gateway governs and meters all of it.
Separating them clarifies where your investment actually compounds.
The reasoning, generation, and conversational capability of a frontier model. This is the primary product of Claude, Copilot, and most general-purpose AI assistants.
Your tables, permissions, lineage, metric definitions, semantic rules, and curated Genie Agents — governed in Unity Catalog and attached to real data assets.
Genie One and Genie Code are built to operate directly on the context layer.
Claude and Copilot remain useful for their own strengths — and through MCP they can draw on the same governed definitions rather than relying on context pasted into each conversation.
An illustrative scenario: “What is our same-store NOI this quarter?”
| Approach | Likely outcome | Why | Result |
|---|---|---|---|
Copilot |
Surfaces 118% from a board deck or spreadsheet circulated in a previous quarter. | The retrieval target is a document rather than the governed dataset. The figure may have been accurate when written, but the document has no refresh cycle. | Point-in-time |
Claude no data connection |
Asks you to supply the data and clarify how your organization defines same-store NOI. | No route to the warehouse, and no visibility into your approved metric logic, exclusions, or cohort policy. | Needs input |
Claude connected via MCP |
Calls the Genie MCP endpoint, which runs your approved logic and returns +3.4%. | The model itself is unchanged. What changed is that it now draws on the governed context layer you maintain. | Governed |
Genie One |
Returns +3.4% along with the SQL behind it, a segment breakdown, and the reviewed dashboard that already tracks the metric. | Purpose-built for this pattern. It searches existing governed assets first, applies the curated Agent definition, and runs read-only SQL within Unity Catalog permissions. | Governed + context |
Genie Code |
Reaches the same answer, then builds or refines the dashboard, adjusts the metric logic, and publishes a reusable asset for the team. | The analysis becomes a governed artifact. Next quarter, Genie One surfaces it directly rather than reconstructing the work. | Reusable asset |
The model is identical in both cases. The intelligence did not improve — the context layer beneath it did. This is the practical case for investing in governed context: it raises the quality ceiling for every AI surface you connect, including the ones you have already purchased.
Outcomes above are illustrative and depend on how each tool is configured in your environment, what data it can reach, and whether your metric definitions have been documented.
Row three above is only possible because something sits underneath it. This is that something — the same question, followed down through the layer, picking up at each step what it did not arrive with.
Open connectivity to any catalog, database, app, or MCP — 50+ connectors. Three paths into the layer, three different scopes: saving something for yourself is not the same as publishing a company definition, and inferred context is not certified context.
noi_actuals
underwriting_targets
OntoRank scores both by authority, relevance, and the asker’s permissions, then passes only what the question needs. One term was defined on purpose; the other was learned from work already done. Neither reaches the model unless this person is entitled to it.
The architecture above is a snapshot. The reason to build here is what accumulates inside it, because the durable asset is the business meaning — not the last answer.
How Genie One, Genie Code, and MCP work together rather than overlapping.
Ask, answer, act
Most of your organization asks questions in plain language, then acts — scheduling tasks, setting alerts, saving skills, and producing documents.
Deepen the context
Analysts and engineers enrich the ontology — metric views, certified assets, pipelines — while any user can turn a conversation into a Genie Agent.
Distribute
The same governed context reaches Slack, Teams, Microsoft 365, Google Sheets, Claude, OpenAI, and your own applications.
Most organizations need far more consumers than creators.
| Group | Primary surface | Usage pattern | Why it fits |
|---|---|---|---|
| Executives and senior leaders | Genie One, or Microsoft Teams via MCP | Occasional, high-stakes | They need trusted answers, not an authoring environment. Delivering into Teams removes the need to change tools. |
| Business teams and managers | Genie One | Regular question-asking | Governed exploration without needing to understand compute, SQL, or notebooks. |
| Analysts and power users | Genie One and Genie Code | Both consume and create | They ask questions and also build the governed assets that answer them next time. |
| Data engineers and platform teams | Genie Code | Sustained authoring | They own pipelines, definitions, shared assets, and the quality of the governed layer. |
| Existing AI assistants | Connected via MCP | Complementary | Claude and Copilot keep their own strengths while drawing governed figures from a single source. |
Genie learns from work your teams have already done. Certify your existing high-quality Genie Agents, dashboards, queries, and notebooks, and enable ontology snippets — Genie draws on them directly, provided your users have access to those assets so the relevant snippets can surface. Genie Code is how you deepen and maintain that context over time, not a prerequisite for turning Genie One on.
Genie One is a discovery and conversation layer over the assets you already have — it searches your published dashboards and queries before generating anything new. Tools such as Power BI remain valuable for standardized reporting; connecting them to the same Unity Catalog data means the figure in a report and the figure in a Genie answer reconcile to the same source.
A self-improving knowledge graph that connects your sources into one shared understanding of the business.
Far more than a glossary. It connects approved datasets, metric views, semantic rules, join logic, filters, fiscal calendars, exclusions, certified assets, and learned snippets into one graph — working off a shared vocabulary so every agent and every surface resolves a term the same way.
Revenue, occupancy, yield on cost, and same-store NOI are ordinary phrases with organization-specific meanings. No model can infer your Finance policy from vocabulary alone.
Definitions live beside the governed data, permissions, lineage, and audit trail in Unity Catalog — and the graph improves as teams use it, certify assets, and correct answers. It is a managed system of record for meaning, not a collection of prompt conventions.
Connectors and MCP servers expose context where it already lives, rather than copying it into prompts.
Six kinds, each carrying the permissions of wherever it came from.
Built automatically, but governed deliberately — administrators curate all three through the semantics glossary.
Claude also supports persistent context and reusable outputs — projects, instructions, files, and memory. So the useful question is not whether an assistant can remember. It is where the meaning lives, who is entitled to reuse it, which governance applies, and how it becomes an organizational asset. That is where a governed context layer tied to your data differs from context held inside a conversation.
Examples above are illustrative. Genie Ontology is documented as Public Preview — confirm availability and configuration for your own environment.
A conceptual view of how ambiguous terms become consistent answers.
The ontology is the shared layer. A Genie Agent is a scoped view of it — a conversation narrowed to one use case, with its own instructions, skills, and sources, deployable in Genie One, Slack, Teams, or a custom application. Anyone can create one by turning a chat into an agent. Where a domain needs tighter oversight, a subject-matter expert curates the agent, and its context feeds back into the shared ontology so everyone else’s answers improve too.
Models are rented and replaced. The ontology describing your business is owned and compounds — which makes it the part of the stack most worth building deliberately.
Adoption improves when the governed answer appears in the tool that is already open.
The same governed figure — +3.4% — delivered across four different surfaces your teams already use.
| A | B | C | |
|---|---|---|---|
| 1 | Portfolio | SS NOI | NOI Δ |
| 2 | Multifamily | +4.6% | +$2.4M |
| 3 | Student housing | +3.1% | +$310K |
| 4 | Hospitality | −1.2% | −$84K |
| 5 | Total | +3.4% | +$2.6M |
Illustrative representations of the interaction pattern across four surfaces, not product screenshots. Each surface renders results in its own native style, and every one enforces the same Unity Catalog permissions.
The same three guarantees hold on every surface above, whether the question starts in Genie One or arrives through MCP.
Metric logic is encoded once in the governed layer rather than restated in each conversation. Whoever asks, and wherever they ask from, the same approved definition, filters, and fiscal calendar apply.
The generated SQL, the lineage behind it, and the access boundaries that applied are all inspectable. You can show not only the figure but exactly how it was produced.
Every request is authorized against your Unity Catalog permissions, whether it reads a governed table or searches SharePoint. Unity Gateway applies policies and approval requirements, and records usage and audit logs in system tables.
Genie One covers more ground than a data tool alone. Alongside governed metrics it drafts shareable documents in a canvas beside the chat, and connects to SharePoint, Outlook, Google Drive, Slack, Jira, and Confluence through Databricks-provided connectors, each authorized against your Unity Catalog permissions. Where teams would rather stay in Microsoft 365 or another assistant, MCP delivers the same governed figure into that surface. Either way, the definition behind the number does not change.
MCP does not bypass governance. It exposes approved tools and governed context through a controlled interface, and Unity Catalog permissions continue to determine what the underlying layer can access. The decision that remains is which clients your security team approves to reach that endpoint — worth scoping early, since it typically involves the same review process as any other data integration.
It is easy to assume a data assistant only handles questions about numbers. The native experience covers considerably more of the working day — which is why it is the recommended starting point rather than something sitting behind another tool.
Confirm feature availability, connector configuration, permissions, and approval requirements for your own deployment.
If a team is already standardized on an external assistant, connect that approved client through the Genie One MCP server. The request then draws on the same governed context and answering capability, inside the same permissions.
The assistant your teams prefer is not the thing that determines whether an answer is right. Your context layer is. Here is what that looks like in practice — and why what you build becomes an asset you own.
One model, one prompt, one person asking. The only variable is whether your governed layer is reachable.
Ask it natively and you get the identical figure — deliberately identical, because it came from your layer rather than the surface. What the native experience adds is the work that follows the number.
A number answers today’s question. What makes the next one cheaper is the definition underneath it — and that is the thing you are actually building.
One question followed end to end — and the two things left over once it has been answered.
Every definition your teams certify lives in your Unity Catalog, governed by your permissions, cited in your answers. It is not held inside a vendor’s conversation history, and it is not reassembled from scratch in each person’s prompt.
That is what makes it an asset rather than a subscription feature. Models will keep changing — faster, cheaper, better — and your teams may well prefer a different assistant a year from now. The layer stays yours either way. Swapping the window does not cost you the business meaning underneath it.
Which is the real argument for building here: not that one chat interface beats another, but that the understanding of your business becomes something you accumulate and keep, instead of something every employee reconstructs on every prompt.
Two halves of one question: the costs that fall as the layer matures, and the spend you can finally see in one place.
Where premium general-purpose AI tiers were purchased because data questions exhausted message or token limits, moving that work to a purpose-built governed surface can reduce the capacity required for those users.
Each reviewed dashboard, curated Agent, and approved definition reduces future rework. As reuse replaces repeated ad hoc analysis, the effort and cost of answering a recurring question falls.
One governed MCP layer is less work to build, secure, and maintain than a separate data connector, permission design, and review cycle inside each AI tool you adopt.
Accuracy and latency are cost questions. A wrong answer gets rebuilt by hand, and a slow one blocks whoever is waiting on it. On a 28-question internal enterprise-data-analysis suite run in June 2026, Genie answered 84.5% correctly on the first attempt, in roughly eight minutes.
The strongest general-purpose coding agent evaluated alongside it — given the same Databricks SQL MCP access — reached 52.4%. The others evaluated came in at 40.5% and 25.0%, which is what makes 52.4% the strongest rather than a convenient midpoint. Runtime told a similar story — roughly 8 minutes for Genie against 15 and 24 minutes for two of the agents, though one was faster at 7 minutes while being far less accurate. Those agents run frontier models, so the gap is not reasoning quality. It is the context layer underneath, which is also why a result like this is reproducible in your environment rather than dependent on how well each person prompts.
A limited Databricks vendor benchmark on a 28-question internal suite, June 2026. Competing agents are anonymized; this is not a comparison against any named assistant, and not a customer guarantee. Your own results will depend on how your definitions and assets are curated. Published disclosure: Introducing Genie One, Genie Ontology, and Genie Agents.
A qualitative view of where effort and spend accumulate.
| Category | Without a governed Genie layer | With Genie One, Genie Code, and MCP |
|---|---|---|
| Business-user data access | General-purpose AI seats used as an informal analytics tool, often at premium tiers | Genie One provides a purpose-built front door for governed data questions |
| Analyst effort | Repeated context assembly, schema explanation, and re-answering questions already answered | Genie Code converts recurring questions into shared assets that Genie One surfaces first |
| Integration maintenance | A separate connector and review cycle inside each AI tool adopted | One governed layer exposed once through MCP |
| Governance overhead | Semantic logic distributed across prompts, spreadsheets, and individual knowledge | Definitions, permissions, and lineage centralized in Unity Catalog |
| Overall trajectory | Variable AI cost and inconsistency both tend to grow with adoption | Incremental cost for data work declines as the governed asset base matures |
Cost outcomes depend on your existing licensing, data readiness, and usage patterns, so these levers are best quantified with your own figures rather than generic benchmarks.
AI cost tends to fragment before anyone notices. Consolidation and visibility address different halves of that problem.
A team subscription for an assistant, the same model family called directly through an API in a custom application, and the same provider served again through the data platform. Three commercial relationships, one underlying model.
Two or three assistants each partially covering data questions, with none of them authoritative. Teams pay for all of them and still escalate to an analyst for the number that has to be right.
Individual and departmental AI subscriptions that never appear in a consolidated view until renewal. Without central reporting, duplicate coverage is invisible.
Separate connectors, logging, spend tracking, and security review inside each tool. The same governance work is performed repeatedly, once per vendor.
Without a governed asset to reuse, each occurrence of a recurring question consumes analyst time and AI capacity again from the beginning.
Premium tiers purchased organization-wide because a subset of users needed the headroom, leaving occasional users on capacity they rarely consume.
Because every request routes through the gateway, cost and usage questions have a single answer rather than one answer per tool.
Unity Gateway — shown as AI Gateway in workspace navigation — is the control plane for AI traffic, not only its meter. It governs which models and MCP services an agent may reach, applies guardrails, approval requirements, and rate limits, and records every request against Unity Catalog system tables. That answers the questions scattered tooling cannot: how many agents are running and who owns them, why a request was blocked, whether sensitive data reached a third-party model, and what each team actually spent.
Agent Registry · Access Control · Contextual Policies · Budgets · Smart Routing · Agent Monitoring
system.ai_gateway.usage
Per-request usage metrics including token counts, latency, and requester details for everything routed through the gateway. Also captures ai_query calls to Databricks-provided model services.
system.billing.usage
Billable consumption in DBUs. Gateway traffic is enriched with the model service name, destination model, requesting principal, and any service tags — which is what makes attribution possible.
system.billing.list_prices
List pricing, joined to consumption records to estimate spend on Databricks-hosted foundation models.
system.ai_gateway.external_model_spend
Estimated spend for requests routed to external model providers, aggregated hourly.
Each of these typically requires a separate export or vendor portal without a gateway in front of your AI traffic.
| Question | Where the answer comes from | Why it matters |
|---|---|---|
| Which models are we actually using, and at what volume? | Usage dashboard, Requests and Token Usage views | Reveals overlapping coverage and models retained but no longer used |
| What does each team or project spend on AI? | Service tags on billing records, grouped by team or cost centre | Moves AI from an unallocated central cost to an attributable one |
| Which users or service principals drive the most consumption? | Requesting principal on usage and billing records | Distinguishes genuine heavy use from a misconfigured job or runaway agent |
| Is spend trending in a way we should act on? | Cost Over Time and Cost Breakdown views | Surfaces trends early rather than at invoice or renewal |
| Are we paying an external provider for something available internally? | External model spend alongside Databricks-hosted consumption | Directly identifies duplicated model coverage |
| What exactly was sent to a model, and by whom? | Request and response logging to Unity Catalog tables | Supports audit, debugging, and review without a vendor-side export |
| How do we prevent a single workload consuming a quarter of budget? | Rate limits applied per model service | A preventive control rather than a retrospective finding |
Routing AI traffic through one governed layer reduces how many overlapping tools and integrations you pay to maintain. Gateway observability tells you which of the remaining ones earn their cost. Both are needed: consolidation without measurement is a guess, and measurement without consolidation only documents fragmentation more precisely.
Two phases, in order. Enabling Genie One is a configuration task; proving it is a short, measured pilot against a baseline you record first.
Consumer access is the least-privileged workspace entitlement and is sufficient for Genie One chat. Higher entitlements such as Databricks SQL access, Workspace access, or workspace admin also qualify, so existing users may already be covered. Assign it to groups rather than individuals so access follows your existing identity model.
Workspace-level Genie One is the path for chat today: it is scoped to a single workspace and its members, and users see only the assets explicitly shared with them or with a group they belong to. Assign the entitlement per workspace for the teams taking part in your pilot.
Genie One surfaces the AI/BI dashboards, Genie Agents, and Databricks Apps that have been shared with a user or with a group they belong to. Share at least one reviewed dashboard before opening access — an empty home page is the most common reason early adoption stalls.
Every Genie One interaction respects Unity Catalog permissions. When sharing an asset, the option to run queries using the viewer's credentials means each person sees only the data their own Unity Catalog privileges allow. Where external knowledge sources such as SharePoint or Google Drive are connected, those sources' permissions are honoured as well.
Users whose only entitlement is Consumer access land on Genie One automatically after signing in. Anyone with additional entitlements can switch using the app switcher in the upper-right corner of the workspace, or navigate directly.
https://<your-workspace-url>/one
The Genie mobile app supports iOS and Android and is enabled by default for accounts in Public Preview. If it is not already on, an account admin can enable Genie One Mobile from Previews in the account console.
With the Databricks Excel Add-in configured, users can open Genie One from the add-in pane and ask questions in plain language without leaving the workbook — answers include citations and conversation history.
When enabled, the home page offers one-click prompts tailored to recent activity, which lowers the barrier for first-time users. Currently in Beta and controlled by workspace admins from the Previews page.
Links point to Azure Databricks documentation. Equivalent pages for AWS and GCP deployments are available at docs.databricks.com. Features marked Beta or Public Preview may vary by region and account configuration.
Genie One was previously called Databricks One. Older internal documentation, training material, or release notes may still use the former name.
Start with one team and a few recurring workflows, measured against a baseline you recorded first.
That might be Legal reviewing incoming contracts, Finance producing a monthly budget, or Sales preparing account briefs. Choose work the team already does often, where a better answer or a faster process would make a real difference.
Representative questions with known-good answers — including the definitions, sources, and reasoning Genie should use. They give you a concrete way to evaluate accuracy before rollout and to track whether Genie is improving over time. Include straightforward questions, deliberately ambiguous ones, and cases where permissions should produce different answers for different users.
How accurate is the existing process? How long does it take? Where do people get stuck? Capturing this first is what later lets you show improvement rather than assert it — and it is the step most teams skip.
For a Finance workflow this is typically the FP&A lead who owns monthly reporting and knows exactly how the company defines budget and actuals. They help codify the metrics, terms, and concepts Genie needs to understand, and certify the authoritative context through metric views, pages, and domains. They are often keen to see the user feedback as it starts to arrive.
This is not a cold start. You almost certainly hold useful knowledge already — in high-quality Genie Agents, dashboards, queries, and notebooks. Certify those assets and enable ontology snippets so Genie can learn from that existing work, and make sure the users in your pilot have access to them so the relevant snippets can actually surface.
Does it need SharePoint? Gmail? Jira? Slack? Make sure people can read from and write to the third-party tools the work depends on. You can add instructions where they help, but you probably will not need many to begin with — if the underlying semantics and source material are strong, Genie can do a great deal without a long list of rules.
See where it succeeds, where it gets confused, and where the ontology needs more context. Refine the semantics and instructions as you go — and once it is working well, expand to the next workflow, the next domain, and the next team.
A pilot without known-good answers can only tell you whether people liked it. With benchmarking questions and a recorded pre-Genie baseline, you can state plainly how accuracy and cycle time changed, and show the ontology improving over successive passes. That evidence is what turns one team’s pilot into an organization-wide rollout.