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)