Databricks Targets $90,000 AI Bills With Automated Model Routing

How Agent Bricks gives developers choice, context and control (with demo) — Databricks

Databricks

Internal data revealed that 90% of developer sessions needlessly burn top-tier models on simple tasks, prompting Databricks to deploy dynamic routing and sandboxes to halt runaway corporate AI spending.

AI-assisted summary of How Agent Bricks gives developers choice, context and control (with demo) — original source. Check the original for full context.

Source published:

Key ideas

  • Databricks reported significant traction for Agent Bricks since launch, logging over 100,000 custom enterprise agents built, 1 quadrillion tokens routed through its AI gateway, and 1 billion downloads of MLflow GenAI experimentation tools. (0:00)
  • Enterprise AI adoption is triggering steep infrastructure costs, with top 1% power users spending up to $90,000 per seat annually, primarily driven by default routing to expensive frontier models where 90% of sessions represent compute overkill. (15:00)
  • Databricks introduced Databricks Sandbox, delivering isolated, ephemeral virtual machines that spin up and down in milliseconds to let agents execute arbitrary code safely against enterprise data using downscoped OnBehalfOf permissions. (8:04)
  • Unity AI Gateway now incorporates centralized smart budgeting, contextual data taint tracking, cross-cloud failover, and multi-model dynamic routing that orchestrates complex tasks across specialized cheap and frontier models concurrently. (10:48)

Detailed notes

## Background Published on YouTube by Databricks on June 24, 2026, this presentation introduces the latest updates to Agent Bricks, an enterprise agent developer platform centered on choice, context, and control. According to the page description, the session explores how developers can focus on building AI agents rather than infrastructure scaffolding, supported by a live demo of the Unity Catalog AI Gateway for governance and cost optimization.

## TL;DR Databricks presenters Kasey Uhlenhuth and Ankit Mathur address the "99% problem" of agent development, showing that the core reasoning loop is easy compared to the massive infrastructure required for enterprise authentication, context routing, and security. They present Agent Bricks as a unified solution built across three pillars: model and framework choice, deep context grounding via Unity Catalog and Agent Memory Services, and execution control through isolated Databricks Sandboxes. The session features a live terminal demo of the Unity AI Gateway, illustrating how single-sign-on MCP access, dynamic cost caps, and OmniAgent intelligent routing prevent runaway budget consumption. By capturing end-to-end telemetry into governed Unity Catalog trace tables, organizations can audit model overkill with Databricks Genie and transition engineering culture from "tokenmaxxing" to "valuemaxxing."

## Atmosphere & style The presentation blends the crisp, high-level polish of an enterprise product keynote with the gritty, relatable pragmatism of terminal-level engineering. Kasey Uhlenhuth sets an authoritative, validating tone by diagnosing developer exhaustion with brittle proof-of-concept plumbing, while Ankit Mathur brings casual humor and direct command-line honesty to the live demonstration. The pacing moves smoothly from systemic architectural dilemmas to tactical cost-cutting strategies, creating an atmosphere that feels urgent, technically grounded, and focused on operational sanity over AI hype.

## Bulletin - [00:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=0s) Databricks reported significant traction for Agent Bricks since launch, logging over 100,000 custom enterprise agents built, 1 quadrillion tokens routed through its AI gateway, and 1 billion downloads of MLflow GenAI experimentation tools. - [15:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=900s) Enterprise AI adoption is triggering steep infrastructure costs, with top 1% power users spending up to $90,000 per seat annually, primarily driven by default routing to expensive frontier models where 90% of sessions represent compute overkill. - [08:04](https://www.youtube.com/watch?v=GezX9a_9bwI&t=484s) Databricks introduced Databricks Sandbox, delivering isolated, ephemeral virtual machines that spin up and down in milliseconds to let agents execute arbitrary code safely against enterprise data using downscoped OnBehalfOf permissions. - [10:48](https://www.youtube.com/watch?v=GezX9a_9bwI&t=648s) Unity AI Gateway now incorporates centralized smart budgeting, contextual data taint tracking, cross-cloud failover, and multi-model dynamic routing that orchestrates complex tasks across specialized cheap and frontier models concurrently.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=0s) The agent reasoning loop accounts for only 1% of enterprise development effort, while the remaining 99% involves addressing authentication, MCP connectivity, identity management, and long-running execution stability. - [02:30](https://www.youtube.com/watch?v=GezX9a_9bwI&t=150s) Enterprise agent development commonly encounters three major blockers: rapidly shifting frontier model architectures, fragmented enterprise data, and the high-privilege write capabilities granted to autonomous systems. - [03:56](https://www.youtube.com/watch?v=GezX9a_9bwI&t=236s) Agent Bricks provides native integration for top frontier models (including GPT, Claude Opus, Gemini, and Grok via a partnership with xAI) alongside RL training workflows that outperform generalized models on specialized tasks. - [03:56](https://www.youtube.com/watch?v=GezX9a_9bwI&t=236s) The platform abstracts agent frameworks including Omnigent, LangGraph, and the OpenAI Agents SDK behind a unified interface, preventing costly re-platforming cycles as architectures evolve. - [05:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=300s) Context is unified within Unity Catalog and guided by the Genie Ontology metadata layer to help agents determine which tables, operational dashboards, and MCP-connected APIs to invoke. - [05:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=300s) Agent Memory Services provide managed APIs for storing cross-interaction user preferences, conversation trails, and session histories without requiring dedicated per-user agent deployments. - [10:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=600s) Databricks Sandbox solves the risk of autonomous code execution by providing ephemeral VMs that spin up in milliseconds and enforce downscoped OnBehalfOf permissions to shield production data. - [10:48](https://www.youtube.com/watch?v=GezX9a_9bwI&t=648s) Unity AI Gateway establishes a centralized registry and system of record for all enterprise agents, MCPs, and skills across internal builds and third-party tools. - [10:48](https://www.youtube.com/watch?v=GezX9a_9bwI&t=648s) Contextual security policies inside Unity AI Gateway track data taint statefully, automatically restricting an agent from broadcasting externally once sensitive customer PII is accessed in a session. - [15:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=900s) Centralized smart budgeting within the gateway introduces graduated adaptive thresholds that steer developers toward token-efficient models before applying hard enforcement caps. - [15:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=900s) Developers can wrap local developer CLI tools like Codex through the Unity AI Gateway to centralize authentication and enforce governance without altering engineering workflows. - [20:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1200s) OmniAgent acts as a meta-harness capable of breaking compound engineering tasks into parallel subtasks routed to specialized cost-effective models like Kimi and Flash or high-end frontier models. - [22:15](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1335s) Every prompt, reasoning step, and tool call logs directly into a customer-owned Unity Catalog table governed by ABAC and searchable using Databricks Genie or LakeWatch SIEM. - [22:15](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1335s) Analyzing centralized coding traces revealed that 90% of internal developer sessions previously defaulted to premium models for simple tasks, demonstrating the need to transition from 'tokenmaxxing' to 'valuemaxxing.'

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=0s) Agent Bricks and AI's 99% Infrastructure Problem

Kasey Uhlenhuth, Director of Product Management at Databricks, opens by contrasting consumer AI with developer needs. While the previous day focused on consuming AI through Genie to provide automated answers to knowledge workers, developer teams face the burden of building custom enterprise agents that drive core operations and customer experiences. Databricks launched its Agent Bricks developer platform a year prior, achieving significant scale across global enterprises: 7-Eleven accelerates maintenance repairs, Mastercard identifies fraud across billions of transactions, and AstraZeneca provides rapid commercial insights to drug discovery teams.

Yet, as Uhlenhuth emphasizes, flashy public demos obscure the true engineering burden of production systems. A typical proof-of-concept showcases only the agent reasoning loop, ignoring the mounting architectural hurdles required to sustain it in an enterprise environment. As Uhlenhuth puts it: “When you see agent demos and agent pilots, you're usually just seeing the agent loop. but the agent loop is only 1% of the work that you have to do. It's the other 99% that's going to get you.” Developers find themselves wrestling with authentication, wiring up connections to external Model Context Protocol (MCP) servers, orchestrating identity across disparate services, and guarding against crashes or timeouts during long-running tasks. Multiplying that overhead across thousands of intended organizational agents leaves teams completely bogged down in infrastructure scaffolding rather than delivering functional agent behavior.

- Over 100,000 custom agents built on Agent Bricks since launch - More than 1 quadrillion tokens routed through the platform's AI gateway - Over 1 billion downloads recorded for MLflow Gen AI experimentation and tracing tools

```mermaid flowchart TD accTitle: The Reality of Enterprise Agent Development accDescr: Diagram illustrating the 1 percent agent loop versus the 99 percent infrastructure overhead.

subgraph Visible["The Demo (1%)"] Loop["Agent Reasoning Loop"] end

subgraph Overhead["The Enterprise Reality (99%)"] direction TB Auth["Authentication & Identity"] MCP["External MCP Connections"] State["Long-running Execution & Timeouts"] Scale["Multiplying Across Thousands of Agents"] end

Loop -.->|"Obscures"| Overhead ```

[02:30](https://www.youtube.com/watch?v=GezX9a_9bwI&t=150s) Developer Pain Points: Choice, Context, and Control

Through conversations with enterprise developer teams, Databricks identified three recurring structural pain points that stall AI adoption: shifting model frontiers, fragmented enterprise data, and unchecked agent authority. First, model architectures evolve so rapidly that solutions built six months prior fall multiple generations behind, frequently forcing teams into disruptive platform rewrites just to adopt new frontier releases or agent harnesses. Second, enterprise competitive advantage resides within proprietary data, but that data remains heavily siloed across formats ranging from unstructured PDFs to external REST APIs, making accurate context discovery and retrieval remarkably difficult.

Third, agents operate as the most privileged entities inside corporate networks. Unlike read-only dashboards, autonomous agents possess broad access to customer records and the authority to execute real-world write actions. Uhlenhuth warns that without guardrails, worst-case headlines become reality: agents accidentally purge production databases, exfiltrate private data, or run runaway query loops that drain enterprise budgets before projects ever reach production. To solve these friction points, Databricks structured Agent Bricks around three pillars: choice, context, and control.

[03:56](https://www.youtube.com/watch?v=GezX9a_9bwI&t=236s) The Agent Bricks Difference: Model and Framework Choice

Addressing the first pillar, choice, Agent Bricks exposes a unified model platform providing native access to top-tier frontier models—including Claude Opus, OpenAI GPT, Google Gemini, Qwen, and Moonshot AI's Kimi. Uhlenhuth announces an expanded partnership with xAI to integrate the Grok model family directly into the ecosystem. Recognizing that public frontier models cannot solve every specialized proprietary task, the platform also offers end-to-end reinforcement learning (RL) training workflows. Uhlenhuth notes that Databricks' internal Genie research team used this custom RL infrastructure to train specialized models that successfully outperformed Claude Opus on their domain-specific workloads.

Framework flexibility receives the same unified treatment. Developers can run and deploy Omnigent agents directly within Databricks or integrate their preferred tools, such as LangGraph or the OpenAI Agents SDK. By abstracting models and deployment harnesses behind a unified interface, teams retain the freedom to iterate on the bleeding edge without facing massive platform overhauls. As Uhlenhuth explains: “So we believe choice is about giving you the flexibility to stay at the cutting edge without having to replatform your solution every time.”

```mermaid flowchart LR accTitle: Agent Bricks Unified Choice Architecture accDescr: Diagram showing unified model access and framework deployments in Agent Bricks.

subgraph Models["Unified Model Layer"] Frontier["Frontier Models<br>(GPT, Opus, Gemini, Grok, Kimi)"] CustomRL["Custom RL Models<br>(Task-Specific Optimization)"] end

subgraph Frameworks["Flexible Agent Harnesses"] Omni["Omnigent"] OpenAI["OpenAI Agents SDK"] LG["LangGraph"] end

subgraph Gateway["Agent Bricks Unified Interface"] API["Single Standardized Endpoint"] end

Models --> API Frameworks --> API ```

[05:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=300s) Grounding with Context: Unity Catalog, Document Intelligence, and Agent Memory

A capable model fails without precise business context. In Agent Bricks, context is treated as data, centralized and cataloged within Unity Catalog. Everything from internal tables and analytics dashboards to external APIs is registered as callable tools discoverable by agents. To solve the challenge of context selection, Databricks leverages the Genie Ontology—a metadata layer spanning enterprise agentic assets that helps agents determine which data sources to invoke. For unstructured data, the platform provides Document Intelligence, using specialized parsing, extraction, and classification models engineered to process millions of complex invoices and PDF contracts without exorbitant inference costs.

To extend context beyond Databricks' storage boundary, managed external Model Context Protocol (MCP) servers connect agents to third-party endpoints with automated authentication handling out of the box. Uhlenhuth also tackles personalization, arguing that enterprises should not have to instantiate separate dedicated agents for every employee or customer. Instead, Databricks introduces Agent Memory Services. Through managed APIs, custom agents seamlessly store and retrieve session histories, conversation trails, and granular user preferences across interactions. Dedicated Databricks research teams continuously feed breakthroughs in memory, retrieval, and search into both Agent Bricks and Genie to keep retrieval state-of-the-art.

- Centralized tool and data discovery via Unity Catalog, including operational dashboards - Genie Ontology metadata layer for accurate context retrieval and tool selection - High-efficiency Document Intelligence models optimized along the enterprise quality-cost curve - Out-of-the-box managed MCP connections for external API authentication - Agent Memory Services managed APIs to store user preferences, session histories, and conversations

[08:04](https://www.youtube.com/watch?v=GezX9a_9bwI&t=484s) Transitioning to Control: Announcing Databricks Sandbox

With agents grounded in enterprise knowledge and granted execution capabilities, the final pillar is control. Unchecked agents executing arbitrary code pose severe operational hazards, yet restricting them to static scripts neutralizes their creative reasoning potential. Developers want to give agents free rein to write and test code on the fly, but cannot risk catastrophic consequences such as drops or truncations in production datastores.

To resolve this dilemma, Uhlenhuth introduces Databricks Sandbox. Databricks Sandbox delivers secure, ephemeral virtual machines designed specifically for agent execution, offering isolated computing environments where autonomous workflows can inspect data, run complex code, and test actions without exposing production infrastructure to downtime or data loss.

> “You kind of want these agents to run code. They can do like amazingly creative things if you just kind of let them cook. But you don't want them to take down production.” — Kasey Uhlenhuth

[10:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=600s) Databricks Sandbox: Secure, Low-Latency Execution

Kasey Uhlenhuth emphasizes that the Databricks Sandbox is fundamentally distinct from generic virtual machine offerings. Standard VMs lack native connectivity to enterprise data stores, whereas the Databricks Sandbox provides immediate, out-of-the-box data access. Security is handled natively through downscoped permissions executed on behalf of the user, allowing autonomous agents to query, manipulate, and experiment with data in complete isolation so their operations never jeopardize or corrupt the surrounding system.

Beyond security isolation, the execution layer is engineered for extreme responsiveness. Instances spin up and tear down in milliseconds, keeping pace with an agent's iterative thought and execution loops without introducing latency bottlenecks.

- Provides out-of-the-box access to enterprise data using downscoped `OnBehalfOf` permissions. - Sandboxes instantiate and terminate in milliseconds, aligning execution speed with rapid agent iterations. - Fully isolates agent runtime environments, ensuring creative data tasks cannot negatively impact production systems.

---

[10:48](https://www.youtube.com/watch?v=GezX9a_9bwI&t=648s) Unity AI Gateway: Unified Governance, Contextual Policies, and Intelligent Routing

Moving to what Uhlenhuth calls the *pièce de résistance*, she introduces Unity AI Gateway as a unified governance, security, and cost-control plane. As organizations face an explosion of internal and third-party agents, MCPs (Model Context Protocols), skills, and foundational models, Unity AI Gateway serves as the centralized system of record. Its agent registry inventories every agent asset across the enterprise, regardless of whether it was authored directly in Databricks or imported from third-party tools.

```mermaid flowchart TD accTitle: Unity AI Gateway Architecture accDescr: Flow diagram showing how Unity AI Gateway centralizes governance, security, routing, and tracing across diverse agent assets.

subgraph Inputs["Agentic Assets"] A["External / Internal Agents"] B["MCPs & Custom Skills"] C["Foundation Models"] end

subgraph Gateway["Unity AI Gateway"] direction TB REG["Central Agent Registry"] POL["Contextual & Dynamic Security Policies"] ROUT["Intelligent Routing & Multi-Cloud Fallbacks"] BUD["Budgeting & Cost Controls"] end

subgraph StorageObservability["Storage & Observability"] UC["MLflow Traces in Unity Catalog Table"] GENIE["Databricks Genie Debugging"] LW["LakeWatch Real-Time SIEM"] end

Inputs --> Gateway Gateway --> UC UC --> GENIE UC --> LW ```

Security within the gateway operates dynamically rather than through static rules. Uhlenhuth illustrates this with an agent workflow: if an agent interacts with sensitive customer PII during an active session, its state transitions to "tainted." The gateway dynamically restricts downstream actions, permitting an internal email to a team member while blocking public-facing web transmissions. If another session handles only public data, external publication is permitted. Because the agent runtime is integrated directly with the underlying data platform, security policies evaluate state at every single step.

Uhlenhuth turns to cost management and "tokenmaxxing," pointing out that runaway consumption routinely exhausts project budgets prematurely. The gateway counters this with granular user and group budgets, paired with intelligent routing. The router inspects incoming task complexity, dispatching simple prompts to fast, cost-effective models while reserving premier, expensive LLMs for intricate reasoning. It also acts as an abstraction layer across multiple clouds and model providers, enabling automated cross-cloud failover to ensure high availability.

Tracing completes the gateway stack. Through native MLflow integration, every single prompt, completion, tool invocation, and intermediate reasoning step writes directly into a customer-owned Unity Catalog table. Because the data resides natively within Unity Catalog, enterprise developers can query and troubleshoot traces using Databricks Genie or route security anomalies into their SIEM infrastructure using LakeWatch to capture real-time leaks.

> “And this is the best illustration of what a dynamic and stateful policy can do that's contextual to your data.” — Kasey Uhlenhuth

- **Agent Registry**: Centralized catalog tracking external agents, native Databricks builds, MCPs, and skills. - **Contextual Security Policies**: Stateful permission adjustments triggered when an agent touches sensitive or regulated data. - **Security Guardrails**: Integration with external cybersecurity ecosystem partners to constrain model behavior. - **Smart Routing & Multi-Cloud Resilience**: Automatic model triage based on query complexity, coupled with automated cross-cloud provider fallbacks. - **MLflow Enterprise Tracing**: Comprehensive session logging to proprietary Unity Catalog tables, queryable through Genie and monitored via LakeWatch.

---

[15:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=900s) The Enterprise Cost Crisis and Live Terminal Demo

Ankit Mathur takes the stage, joking about his recent return from vacation before focusing on the exponential cost curves driven by enterprise AI adoption. He notes that AI coding assistants and agent runtimes are no longer confined to small engineering teams; non-technical employees run dozens of parallel background agents continuously. Because modern models can self-correct and execute uninterrupted, unmonitored compute bills escalate rapidly. Mathur points out that top-tier enterprise power users are now driving annual expenditures of $90,000 per user.

> “The top 1% of spenders are spending $90,000 per user per year, and that exponential isn't showing signs of slowing down.” — Ankit Mathur

To demonstrate how the Unity AI Gateway reins in these expenditures, Mathur shares his command-line workflow, highlighting three core capabilities: centralized smart budgeting, intelligent routing, and unified agent tracing.

Developers connect their local terminal tools directly to the platform by prefixing their typical CLI tools with the gateway command (e.g., executing `gateway codex`). Once launched, the developer interface looks identical to a standard Codex terminal, but model inferences and MCP connections now pass through the centralized gateway choke point. Centralized MCP access eliminates repetitive individual authentications by allowing engineers to authenticate once through the shared registry.

``` +--------------------------------------------------------------------------------+ | TERMINAL / CODEX SESSION | +--------------------------------------------------------------------------------+ | $ gateway codex | | Codex initialized [Routed via Unity AI Gateway] | | | | > Find me a coffee shop near Moscone Center. | | Query dispatched via MCP Registry (Single Sign-On verified). | | | | [WARNING: Smart Budget Limit Approaching] | | User Spend: $42.50 / $50.00 daily allowance (85%) | | Policy Action: Guiding downstream tasks to token-efficient models | | (e.g., Databricks Qwen / upcoming releases). Hard caps preserved for active. | +--------------------------------------------------------------------------------+ ```

Mathur showcases the budget dashboard tracking his daily $50 limit. Rather than terminating developer sessions abruptly with hard errors, the gateway uses graduated, adaptive thresholding:

1. **Unconstrained Phase**: At the start of the workday, engineers retain unrestricted access to top-tier frontier models across any integrated coding tool. 2. **Threshold Warning & Soft Guidance**: As cumulative daily consumption nears capacity, the CLI prompts the user with inline warnings. The gateway automatically steers subsequent low-complexity interactions toward token-efficient models, such as Databricks' newly releasing models that deliver lower inference costs. 3. **Adaptive Enforcement**: Active tasks are allowed to conclude uninterrupted to prevent disruption to in-flight development workflows. However, newly initialized sessions register the real-time budget depletion, enforcing routing restrictions and model fallbacks from the start.

- Top 1% enterprise AI users consume up to $90,000 annually per seat. - Developers route local terminal clients through Unity AI Gateway using simple CLI wrappers (e.g., `gateway codex`). - Centralized MCP routing provides single sign-on authentication across local workflows. - Dynamic budget policies transition from soft alerts and efficient-model steering to enforced restrictions without abruptly terminating active sessions.

[20:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1200s) Intelligent Model Routing and Databricks Sandbox Execution

Ankit Mathur transitions from basic token-efficiency recommendations to dynamic, real-time workload orchestration by connecting OmniAgent into the Unity AI Gateway. Operating as a meta-harness, OmniAgent can reason about incoming requests at an architectural level that sits far above any individual subtask, unlocking intelligent, granular model routing. When passed a basic query, the gateway detects that the prompt requires only simple local context and routes it to a low-cost model, yielding immediate latency benefits.

```mermaid flowchart TD accTitle: OmniAgent Meta-Harness Intelligent Routing Workflow accDescr: OmniAgent breaks a complex request into subtasks and routes each to specialized models running in parallel inside the Databricks Sandbox.

Client["Developer Prompt<br/>('Find top 4 bugs')"] --> Harness["OmniAgent Meta-Harness<br/>(Medium-Quality Coordinator)"]

subgraph Sandbox["Databricks Sandbox (Parallel Execution & Isolation)"] Harness -->|"Token-Heavy Scan"| Kimi["Databricks Kimi<br/>(Cheap & Fast)"] Harness -->|"Edge Case Review"| Gemini["Gemini Flash<br/>(Smart & Cost-Effective)"] Harness -->|"Core Logic & Deep Audits"| Frontier["Frontier Models<br/>(High Quality & Expensive)"] end ```

The real power appears when handling compound software engineering workloads. For a complex instruction—such as identifying the top four bugs in an open-source repository—OmniAgent delegates the overarching coordination to a medium-tier model, and then assigns specialized models to individual subtasks based on their exact compute and accuracy profiles: - A token-intensive top-level repository surface scan is routed to an economical model like Databricks Kimi, optimizing for fast throughput and reduced cost. - An edge-case review is handed to Gemini 1.5 Flash, blending lower cost with high contextual intelligence. - Core logic verification and deep audits are routed to premium, higher-cost frontier models where quality and verification accuracy cannot be compromised.

Every one of these delegated sub-agents is spun up concurrently inside the Databricks Sandbox, isolating execution to maintain enterprise-grade security while parallelizing tasks. Drilling into an active surface scan, Ankit underscores how rapidly Kimi returns results, emphasizing that picking a cheaper model delivers a double win: dramatically cut costs and faster execution that frees engineers from waiting on slow inference loops.

[22:15](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1335s) Tracing, Governance, and Analyzing Overkill with Genie

Intelligent routing requires empirical visibility to verify whether cost-saving policies actually hold up in production. Connecting coding tools through Unity AI Gateway centralizes session traces directly into Unity Catalog. Because developer prompts, agent traces, and code context frequently contain highly confidential organizational information—such as executive-level context—they require the exact same granular governance applied to foundational data assets. Databricks accomplishes this by enforcing Attribute-Based Access Control (ABAC) policies and governed tags over a unified trace table in Unity Catalog.

```mermaid flowchart LR accTitle: Trace Collection and Governance Flow in Unity Catalog accDescr: Agent traces stream through the Unity AI Gateway into a centralized Unity Catalog trace table, governed by ABAC and analyzed using Genie.

A["Agent Session Traces"] --> B["Unity AI Gateway"] B --> C[("Unity Catalog<br/>Central Trace Table")]

subgraph Governance["Governance & Analysis"] C --- D["ABAC & Governed Tags"] C --- E["Genie AI Analysis"] end ```

Consolidating telemetry into a single catalog table allows teams to run deep analytics using tools like Databricks Genie. Ankit shares a real-world internal discovery from Databricks' own engineering organization prior to implementing the intelligent router:

> “Before we rolled out the router, for example, within our own engineering team, I was able to take a look at a sample of our coding traces and assess that actually because our default model was the most expensive one, like Opus, 90% of our sessions were overkill.”

Without centralized telemetry, engineering leaders are forced to guess. Traces reveal whether developers are burning high-end tokens on greetings or straightforward, paved-path workflows. Teams can translate those learnings into reusable, custom skills managed directly within Unity Catalog's AI Gateway. Ankit emphasizes that pairing budget policies, intelligent routing, and tracing gives enterprises the leverage to “bend that exponential curve” and shift internal engineering culture away from careless token consumption:

> “And so hopefully we can take the world from the old world of token maxing to something a little bit more like value maxing with the Unity AI gateway.”

[24:45](https://www.youtube.com/watch?v=GezX9a_9bwI&t=1485s) The Agent Bricks Vision: Choice, Context, and Control

Kasey Uhlenhuth takes over to close the presentation, framing Agent Bricks as an end-to-end agent developer platform engineered directly on top of Databricks' unified data layer. Rather than treating agents as disconnected chatbots, the platform anchors development on three core operational pillars:

- **Choice:** Complete flexibility to switch underlying models and frameworks as state-of-the-art architectures shift, preventing costly re-platforming cycles. - **Context:** Native metadata integration, allowing agents to accurately discover, access, and reason over enterprise data sources for any given task. - **Control:** Enterprise safeguards encompassing the Unity AI Gateway for intelligent routing and cost caps, Databricks Sandbox for running code on downscoped data, and contextual security policies.

Kasey notes that while the session highlighted new releases like intelligent gateway routing and sandboxed execution, it represents only a fraction of the capabilities rolled out over the past year. Because Agent Bricks is tightly woven into the underlying Databricks data platform, it delivers security, governance, and routing integrations that standalone orchestration layers cannot match. She closes by thanking the developer community for the feedback driving the product's roadmap and inviting teams to build their next production agent deployments on Agent Bricks.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=0s) When you see agent demos and agent pilots, you're usually just seeing the agent loop. but the agent loop is only 1% of the work that you have to do. It's the other 99% that's going to get you. — Kasey Uhlenhuth

> [08:04](https://www.youtube.com/watch?v=GezX9a_9bwI&t=484s) You kind of want these agents to run code. They can do like amazingly creative things if you just kind of let them cook. But you don't want them to take down production. — Kasey Uhlenhuth

> [15:00](https://www.youtube.com/watch?v=GezX9a_9bwI&t=900s) The top 1% of spenders are spending $90,000 per user per year, and that exponential isn't showing signs of slowing down. — Ankit Mathur

## Mentioned Databricks, Kasey Uhlenhuth, Ankit Mathur, Agent Bricks, Unity Catalog, Unity AI Gateway, Databricks Sandbox, Databricks Genie, Document Intelligence, Agent Memory Services, Genie Ontology, MLflow, LakeWatch, OmniAgent, LangGraph, OpenAI Agents SDK, Model Context Protocol (MCP), Codex, Claude Opus, OpenAI GPT, Google Gemini, Qwen, Moonshot AI Kimi, xAI Grok, 7-Eleven, Mastercard, AstraZeneca

## Video description Explore what's new in Agent Bricks, the enterprise agent platform that gives choice, context, and control so developers can focus on building AI agents, not infrastructure.

Plus, see a live demo of Unity Catalog AI Gateway for governance and cost-control, so you can go from "tokenmaxxing to valuemaxxing."

Learn more about Agent Bricks: https://www.databricks.com/product/artificial-intelligence/agent-bricks

00:00 — Agent Bricks, the enterprise agent platform for developers 01:11 — How 7-Eleven, Mastercard, and AstraZeneca use Agent Bricks 01:32 — AI's 99% problem 02:30 — Developer pain points: choice, context, and control 03:56 — The Agent Bricks difference 08:04 — Introducing Agent Memory Services 09:13 — Introducing Databricks Sandbox 10:48 — Unity AI Gateway's new capablities 16:24 — Live demo: Unity AI Gateway 24:45 — Get started with Agent Bricks

Presenters: Kasey Uhlenhuth, Director, Product Management, Databricks Ankit Mathur, Sr. Staff Software Engineer, Databricks

[Source](https://www.youtube.com/watch?v=GezX9a_9bwI)

Reading summary

Databricks presents Agent Bricks as an end-to-end developer platform designed to solve the infrastructure, context, and governance challenges of enterprise AI agents. Director of Product Management Kasey Uhlenhuth argues that the visible agent reasoning loop accounts for only 1% of deployment effort, while the remaining 99% consists of complex infrastructure, security, and cost management. The Enterprise Infrastructure and Cost Bottleneck (0:00) According to Uhlenhuth, public prototypes mask the substantial engineering hurdles required to run autonomous agents in production. Teams frequently face authentication hurdles, connection maintenance for Model Context Protocol (MCP) servers, state persistence, and guardrails against system crashes. Because agents possess privileged read-and-write permissions across enterprise networks, unconstrained workflows create acute risks of accidental database drops, data exfiltration, or infinite query loops. Simultaneously, autonomous tools drive exponential compute consumption. Ankit Mathur reports that top-tier enterprise AI power users now accumulate up to $90,000 annually per user in compute expenses. In an internal audit of Databricks' own engineering traces, Mathur found that roughly 90% of developer sessions suffered from compute overkill by defaulting to expensive frontier models like Claude Opus for routine, straightforward coding tasks. Model Choice and Enterprise Context Integration (3:56) To prevent rapid model turnover from requiring complete system redesigns, Agent Bricks exposes a unified model layer supporting frontier engines—including OpenAI GPT, Claude Opus, Google Gemini, Moonshot AI's Kimi, and an expanded integration with xAI's Grok. It also supports custom reinforcement learning pipelines, which Databricks used internally to build task-specific Genie models that outperformed Claude Opus on specialized workloads. Developers can orchestrate these models using native tools like Omnigent or third-party harnesses including LangGraph and OpenAI Agents SDK. To ground models without extensive manual scaffolding, context is managed within Unity Catalog. Internal tables, dashboards, and external APIs are cataloged alongside the Genie Ontology metadata layer to direct tool selection. For unstructured data, high-throughput Document Intelligence models process contracts and invoices. Managed external MCP servers handle third-party authentication, while Agent Memory Services provide managed APIs to track conversation history and user preferences across sessions. Isolated Code Execution via Databricks Sandbox (8:04) Permitting agents to write and execute code dynamically unlocks substantive problem-solving abilities, but Uhlenhuth warns it risks taking down production databases if run without strict boundaries. Databricks introduced Databricks Sandbox to resolve this friction by supplying secure, isolated virtual machine runtimes tailored for autonomous agent execution. Unlike general-purpose cloud VMs, Sandbox instances spin up and terminate in milliseconds to align with iterative agent thought loops without adding latency. The runtime provides direct connectivity to enterprise datastores using downscoped, user-delegated permissions, enabling agents to inspect, manipulate, and execute code safely without the risk of corrupting external production environments. Governance, Routing, and Tracing in Unity AI Gateway (10:48) The Unity AI Gateway acts as a central control and security plane across internal and external agent assets, foundational models, and MCP tools. Security policies operate contextually: if an agent interacts with sensitive customer PII during a workflow, its session state transitions to 'tainted,' dynamically blocking external public transmissions while permitting designated internal communications. To curb runaway spend, the gateway applies intelligent model routing and graduated budgeting. Rather than terminating in-flight workflows, it issues warnings as budget limits near and steers low-complexity requests toward cost-efficient models. Complex instructions orchestrated by meta-harnesses like OmniAgent decompose tasks across models—routing repository surface scans to low-cost engines like Kimi while reserving frontier models for deep code verification. All intermediate reasoning, prompts, and tool calls are captured in Unity Catalog tables via MLflow, allowing teams to audit sessions using Databricks Genie or export security anomalies into SIEM tools like LakeWatch. Databricks argues that treating models, context, and security as tightly integrated layers of an enterprise data catalog solves governance and reliability barriers that standalone agent frameworks cannot address. However, fully realizing these efficiency and cost gains requires organizations to centralize their tooling, trace telemetry, and identity controls within the Unity Catalog architecture.

Source quotes

[0:00] Kasey Uhlenhuth: When you see agent demos and agent pilots, you're usually just seeing the agent loop. but the agent loop is only 1% of the work that you have to do. It's the other 99% that's going to get you. [8:04] Kasey Uhlenhuth: You kind of want these agents to run code. They can do like amazingly creative things if you just kind of let them cook. But you don't want them to take down production. [15:00] Ankit Mathur: The top 1% of spenders are spending $90,000 per user per year, and that exponential isn't showing signs of slowing down.

Original transcript

[0:00] - Welcome to the stage, Databricks Director of Product Management, Kasey Uhlenhut. - Hi everyone. So yesterday was about consuming AI. You saw how Genie allows you to get AI-powered answers to all of your knowledge workers. but today is about developers. Developers are the teams who are building agents that run your business and provide amazing customer experiences in your products. and Agent Bricks was built for them. Agent Bricks is our agent developer platform. We launched it a year ago and we've seen amazing success so far. Over 100,000 custom agents have been built on AgentRank since we launched. We've had over a quadrillion tokens... go through our AI gateway. And our MLflow solution, which provides Gen AI experimentation and tracing, has had over a billion downloads. And our customers are seeing a lot of value from this solution as well. or 7-Eleven is able to repair maintenance fixes faster. MasterCard is able to detect fraud across millions and billions of transactions. And AstraZeneca is able to help their drug discovery team get commercial insights faster. This is all amazing, but it's only one piece of the picture, and we're only just beginning. And When you see agent demos and agent pilots, you're usually just seeing the agent loop. but the agent loop is only 1% of the work that you have to do. It's the other 99% that's going to get you. where you have to figure out authentication. You have to figure out how to connect to MCPs, how you're going to manage identity, how you're going to have this run for a long time without breaking or hitting timeouts. Yes. And You have to do all this work? for just one agent. but you're trying to build thousands of agents in your company. So it's no wonder that we find that developer teams end up stuck building infrastructure rather than building agents. And as we've talked to developer teams, there's really three problems that start to emerge for them. The first is that the frontier seems to change every week. A new model comes out, a new agent harness comes out like you just saw with Omnigent, and now the solution that you built six months ago is at least one generation behind, if not more. And if you want to be able to change to be on the cutting edge, you might have to actually change sacks. which then means you have to replatform your entire solution. The next problem that you have is that your competitive advantage is in your data. But your data can be fragmented across many different sources, and your data can come in many different formats, all the way from PDFs to external APIs. And it's really hard to help your agent select the right context from all this data. And lastly, agents are the most privileged actor in your enterprise. where they have access to sensitive customer data, and they can take real actions. And that's why you're seeing the headlines emerge with tons of these different scary headlines where agents are... deleting production databases, they're leaking sensitive data, And to make it even worse, these agents can spend a lot of money and not a lot of time. So as a developer, you could end up blowing through your budget before you even got to production. These are the challenges that we keep hearing over and over again, which is why we believe an agent developer platform must provide choice, context, and control. Agent Bricks is our developer platform where we provide answers to all of these so that developers can focus on building agents, rather than on building infrastructure. So now we're going to go through how Agent Bricks provides each of these values. So we'll start with choice. Agent Bricks provides native model access in integration with all of the frontier models. So you get Opus, you get GPT, you get Gemini, you get Quen, and even recently you get Kimi. And today we're excited to announce in partnership with SpaceX that you now get access to the Grok model family as well. Thank you. But sometimes the frontier models aren't enough. You might have a very specific task that you need to accomplish, and it turns out you're going to need to build [5:00] a custom reinforcement learning model. So we also provide an entire model platform for you to use reinforcement learning and build custom models that are trained for your specific task. In fact, our own Genie research team recently used RL and was able to actually outperform Opus on their tasks in there. And you're able to serve and deploy these models alongside all the rest on the Agent Bricks platform. But choice isn't just about models. When you're building custom agents, you want to use your own framework or build your own. And so today we're excited to announce the Omnigent that you just saw with Matei. You can now build and deploy all of those agents inside of Databricks. And of course, you can continue to work with your agent framework of choice, whether it's the OpenAI, Agent SDK, LANGraph, or many more. So we believe choice is about giving you the flexibility to stay at the cutting edge without having to replatform your solution every time. and we're able to do this by giving you a unified interface across all of your models so that you can easily switch amongst them. The best model in the world, though, is only as good as the information you give it which takes us to context Context is how your agent understands about your users and your business And as we mentioned before context is just data So what we do in Agent Bricks is we allow all of your context to be centrally managed inside Unity Catalog. So you can connect your external data there and all of your other data is accessible in there. And all of this is callable as tools by your agent, so your agent can discover all of them, including dashboards. But discovering context isn't enough. You also need to make sure their agent pulls the right context, and that's why the Genie Ontology announcement we made yesterday is such a big deal. Genie Ontology provides the metadata layer over all of your agentic assets so that your agents can effectively and efficiently retrieve and select context. So now that we have this foundation set up, the next hard part is sometimes your context comes in complex formats. You might have millions of PDF contracts and invoices that you wish you could feed to your agent, but you can't. And that's why we built Document Intelligence. Our Document Intelligence solution provides custom models for parsing extraction and classification and our solution is the best on the quality cost curve out there because we know you have millions such of these documents, and we don't want you to break the bank just so that your data or your agents can get access to that valuable data. And of course, we know that not all of your data is inside Databricks. So we allow you to securely connect to all of your external APIs with our managed external MCPs. And we'll provide some of them out of the box for you, so you don't even have to worry about all those authentication issues. The last part about context is sometimes, when you're building these custom agents, you want to personalize them per user. But you don't want to build an agent per user. That's way too much. And so instead, you want something that's like agent memory. So today we're excited to announce our agent memory services, where you can connect your custom agents to our managed APIs, and we will store user preferences, conversation history, and sessions for you so that you can personalize your content to your users. Context is probably the most difficult problem that exists in the agent space today which is why we have an entire research team dedicated to just solving the hardest problems here. So our research team is working to solve agent memory, agent retrieval, and agent search. And all of the solutions and techniques that they come up with are then baked into all of our Agent Brick services that we provide for developers, as well as they're integrated into Genie. So now that you have connected your agents to all of your knowledge, now you want to act on it, but safely. And so that takes us to control. There are two main products that we want to discuss in this control section. So as we mentioned earlier, agents can run wild out there and go rogue in your enterprise and even delete a production database. But you kind of want these agents to run code. They can do like amazingly creative things if you just kind of let them cook. But you don't want them to take down production. So you want to give them some kind of walled environment that they can operate in. And that's why today I'm excited to announce Databricks Sandbox. Databricks Sandbox provides VMs that you can have your agents [10:00] execute code in. But this isn't just your generic VM solution. We are the only VM out here that provides you out-of-the-box access to your data. So we will allow you to have downscoped access using OnBehalf of permissions, to your data so that your agent can get creative with your data inside that VM. that won't affect the rest of your system. Thank you. Also, these sandboxes are incredibly fast. They take just milliseconds to launch, so you can create and destroy these sandboxes just as fast as your agent can work. which makes this extremely exciting for being able to work and play with your context securely in your agents. And now, for the piece de resistance. Unity AI Gateway. Unity AI Gateway is our centralized governance, security, and cost control solution that allows you to unify governance across models agents, MCPs, and skills. And this is probably the most exciting product that we have that's really going to be a game-changer, that allows you to run your agents autonomously in your enterprise. There are five new capabilities that we've added to AI Gateway that we need to go through. So I need you all to buckle up because we're going to dive right in. So the first, remember those thousands of agents? that your team is building? Well, they're all going to probably build them with different tools and platforms in there, and that's okay. But wouldn't it be great if you just had like one inventory of all the agents that were built in your enterprise? Well, now that's possible with our agent registry that's part of Unity AI Gateway. You can register all of your external agents, all your agents built on Databricks, all of all your MCPs, all your skills. So you have one system of record of all of the agentic assets in your organization. The next capability that we have is related to security. We provide contextual security policies. This one's best explained through an example. Imagine you have an agent that touches sensitive customer data with PII. You want to change the state. of that agent to now say, "Hey, it's been tainted because now it has access to sensitive data." So when it takes its next action, you probably want to change what it can actually do. So you may allow it to still send an email to a coworker. but now you absolutely do not want to allow it to publicly post. that data. However, If in a different agent session with that same agent, it only touched public information, then it's totally okay for it to then access and publish things to the public account. web. And this is the best illustration of what a dynamic and stateful policy can do that's contextual to your data. And this is only possible on Agent Bricks because our agent platform is built and integrated into our data platform. And so this is the kind of security policy that then is going to allow you to bound your agent to safely run autonomously. Because at every action and every step your agent takes... we can change how the policies are run. On the same hand with security, we have now partnered with many security organizations to allow you to have security guardrails that you can use to further control security. your agent behavior. Now that we've covered security, let's go into the thing that we're all thinking about, token maxing. Cost controls are a huge issue for many developers today and their organizations, where you can end up deleting your budget before you really even got that far ahead in your projects. So now with AI Gateway, we support budgets, where you can set spend limits for different users and user groups in there. But what you really probably want is not just to know how much you've spent. You would actually rather there be some intelligence system out there that kind of helps you control your spend automatically, so you don't have to really think about it. And that's where intelligent routing comes in. With intelligent routing, we can figure out what the best model is for the task based on the complexity. So we can route trivial questions to cheap, fast models, and we can route complex questions to expensive and powerful models. The other thing that we provide with Smart Routing is because we are multi-cloud and multi-AI, you can have the most highly available agent out there where you can set up fallbacks across your model providers as well as across your clouds. And the last major capability that we've added to Unity AI Gateway is agent tracing. Using MLflow tracing-- [15:00] We can log every input, every output, and everything that happened in the middle of your agents, and centrally store them all in a Unity catalog table. and you own that table and all of that data, because it is super sensitive to your enterprise. Once all of those traces are in Unity Catalog, you can then use Genie to analyze them to debug what's going wrong with your agent. or you can connect it to our SIM system with LakeWatch and get real-time incident alerts when data leakage happens. So this is what AI governance should look like in the enterprise, where all of your assets can be centrally managed. You can have contextual policies to enforce security. You have an open ecosystem where you can connect to partners, and you can have the cost controls that you need. All of this will allow you to run your agents autonomously. It also works really well for admins in your enterprise, where now you can actually safely and responsibly democratize AI across your organization. So on that note, I'm very excited to welcome to the stage my colleague, Ankit Mathur, who's going to show a demo of how you can use Unity AI Gateway to democratize access to coding agents across your developer org. With that, please help me welcome to the stage Ankit. Thank you. Thank you. Hi everyone, my name is Ankit and I'm a software engineer at Databricks and yes I am back from vacation. Today I'm going to show you how our Unity AI Gateway will help you roll out AI at your company while keeping costs in control. Now, as a software engineer, I myself use AI every single day. And what we're seeing is that leaning on AI is starting to become incredibly expensive as costs are growing exponentially. The top 1% of spenders are spending $90,000 per user per year, and that exponential isn't showing signs of slowing down. What started happening is that we don't just have engineers writing code anymore. Every single person at your company is using agents They're using them in parallel, and the models are good enough now that they're going to keep working uninterrupted for as long as we let them. So it's no surprise-- that costs are growing out of control. But are we using AI responsibly? And what's going on inside of that bucket of spend? that's what the unity ai gateway can help you answer and so in today's demo i'm going to demo three of the six things that casey talked about The first will be budgets, the second will be smart routing, and the third will be agent tracing. So let's jump right in and we'll start our day exactly where every other developer starts their day, which is inside of the terminal. And so with the Unity AI Gateway, you can easily point the coding tools that you already use towards the gateway. So all I need to do is something like this. Thank you. Thank you. And boom. Codex starts just as it normally would with a couple differences. It's now pointed at the UnityA gateway. inference and MCPs are tracked through a central choke point. and I can continue to see exactly the same codex UI that I was using before, So I can ask a very simple question like, Find me a coffee shop near Moscone Center. And it'll work just as normal. Except this time, your MCPs are getting routed through a central registry, so you only need to authenticate once. and your inference is being tracked. Now on the right here, you'll see something interesting. which is that because all of our coding tools can point at the same gateway, we're able to specify and define a budget that spans all of the tools that we're using. So I, as an engineer, I have a budget of $50 a day. And the policies are a lot more subtle. So here you can see that Codex actually was able to warn me that I'm nearing a limit on my smart budget policy. So what does that look like? These are not as simple as hard caps. Instead, they're far more subtle. Since your developers are being extremely productive with AI, you probably don't want to stop them. And so when they start their day... you can use any coding tool and any model that's available to you, because all of these are available through the gateway. But as you get closer to the top of your limit, we might start guiding you towards a more token-efficient model like Databricks Kimmy. which comes out this week and is significantly cheaper than all the other models. So that's great, but then I can also go, when I get to 100%, I might actually start enforcing that that happens. Now, my session here continues just as normal, because I don't want to get in the way of active work. But if I was to, for example, start something new, I can type the same thing, gateway codex, And this time, what would happen is that it's aware of our real-time budgets, because our budgets are burning down in real-time [20:00] time. And so we can take a look at this and it's automatically recommending that we switch the more token efficient model. So this is awesome, and it's a lot better than what we've already got, but can we do any better? And the answer is yes, because we have Omnigint. And when Omnigint can connect to the Unity AI gateway, we can do a lot more sophisticated stuff. Specifically, when you have a meta harness, you can make decisions at the higher level than an individual task which allows you to make intelligent routing decisions. So here we see the intelligent router when Omnigint connects through the gateway. And for that same query that I had before, which was relatively simple, I would What happens is that when I start running it, the intelligent model router makes a decision. And it's like, hey, this is actually a pretty simple local recommendation. I can use a cheap model for this. And it has this great advantage that it has really great latency when it answers my question. But if I was to do something slightly more complex, like in the Omnigine open source repo, Find the top four bugs in the repo. Now because Omnigen is a meta-harness, it's able to take a look at that work and distribute it to other coding agents. And so for that distribution task, it actually picked a simpler medium quality model. But for each of the individual things it's doing, it's able to make a more sophisticated decision. So for example, for a top-level scan of the repository, which is very token expensive, It picked a cheaper model like Databricks Kimmy For an edge case review, it picked something like Gemini 3.5 Flash, which is extremely intelligent but cheap. And for core logic reviews and deep audits, it picked medium and expensive models because their quality is extremely important. Now all of these things get kicked off in the Databricks sandbox so they can work in parallel while still maintaining enterprise-grade security. So I can click into any individual one of these agents, like for example, the surface scan, And look at how fast Kimi is running. Latency is another great advantage of being able to pick a cheaper model for the task. And so this kind of work can get done much faster, which frees you up to continue your work and work on something else. All right, so that's cool, and I'm glad that we were able to do this. It's important to have a system like this in place so that you're having those intelligent routing decisions being made. But how do you know if that system is working? Well, this is where agent tracing is incredibly impactful. Because without data, we can't be data-driven. And today, coding agent sessions aren't centralized to a single place. And so that's where, again, the Unity AI gateway, when you connect a coding tool to it, can automatically route those traces to Unity Catalog. Now, this is some of the most sensitive data in your organization. because it is extremely sensitive. Your CEO might have access to context that you don't have access to, so you don't want just anyone to be looking at it. That's why when it's in Unity Catalog, you can use the same tools to govern that data as you already do for your most sensitive data in Databricks. Things like ABAC policies and governed tags mean that only the right folks have access to it. All of this goes into a central trace table that's available in the Unity AI gateway. But another advantage of data being in a central place is that you can use Genie 1 to analyze it. So before we rolled out the router, for example, within our own engineering team, I was able to take a look at a sample of our coding traces and assess that actually because our default model was the most expensive one, like Opus, 90% of our sessions were overkill. That's already way more data than I would have had otherwise. Otherwise, I would have just been guessing. And the nice thing about that data being in one place is I can also then look at what kinds of things are going on in there. Why was it overkill? Well, for example, was it just people saying hi or hello? Was it paved path tasks that are actually not so complex? This can help you guide what skills you need to build as well Those skills can also be put in Unity Catalog's AI gateway And that will allow you to be more token efficient with the things that your developers and engineers are doing on a day to day basis. And it also gives you that full level of observability. So where does this leave us? We hope that with the Unity AI gateways, budget policies, intelligent model router, and tracing, we can start to bend that exponential curve. and still be aggressive about deploying AI within our organizations, but be more mindful about exactly which models we're using. Because intelligence is one of the most precious resources that we have in the ecosystem. And so hopefully we can take the world from the old world of token maxing to something a little bit more like value maxing with the Unity AI gateway. That's all I have. Thank you very much. And back to Casey to wrap up Agent Bricks. Thank you. Thank you Ankit for the amazing demo. So as you can see, Agent Bricks is our complete end-to-end agent developer platform. [25:00] for him. We believe it's important to provide choice, so you have flexibility to always remain at the cutting edge without having to replatform your solutions. We provide you context so that your agents have access to the right metadata to grab the right data for all of your agent tasks. And as you saw with Unity AI Gateway, we provide controls so that you can run these agents autonomously in your enterprise and also that Databricks sandbox so that you can have it on downscoped data. While I did show you a lot of features today, we didn't go through everything that we've launched in the last year, and so here's a list of all the many other features that we've implemented on Agent Bricks today. Again, Agent Bricks is our agent developer platform. It is uniquely integrated into our data platform, which allows us to provide capabilities that no one else can. You saw some of that with our intelligent routing with Unity AI Gateway. You'll see it with Databricks Sandbox when you get to play with that, and you'll see it with our contextual security policies as well. Thank you for all the things that you have built on Agent Brick so far and all the feedback that you've given us has really helped us build an amazing solution here. And we can't wait for what you build next.