Databricks Agent Bricks: The Complete Enterprise AI Agent Platform Guide for Agentic Architects (2026)

A Fortune 500 pharma company needed to build an AI agent that could reason across 400,000 clinical trial documents, call external APIs for drug-interaction checks, and hand off to a human pharmacologist when confidence dropped below a threshold. They had the models. They had the data. What they didn’t have was a platform that could govern all of it — the model calls, the tool access, the data lineage, the cost controls — without duct-taping six different systems together.

That company was AstraZeneca, and the platform they landed on was Databricks Agent Bricks — a governed enterprise agent platform that went from internal tooling to the centerpiece of Databricks’ $190 billion valuation story in under 18 months (AI Magazine, 2026). With over 100,000 agents already built on the platform and more than one quadrillion tokens processed annually, Agent Bricks represents Databricks’ bet that the future of enterprise AI isn’t just models — it’s governed agent systems that inherit the same data lineage, access controls, and auditability that enterprises already enforce on their analytics.

This guide breaks down every major component of Agent Bricks — from the Supervisor Agent orchestration layer to Unity AI Gateway’s runtime governance — so you can evaluate whether it belongs in your agentic architecture stack.

What Is Databricks Agent Bricks?

Agent Bricks is Databricks’ integrated platform for building, deploying, and governing AI agents on top of enterprise data. Announced at Data + AI Summit (DAIS) 2025 and progressively reaching general availability through 2026, it bundles agent authoring, multi-model routing, retrieval-augmented generation, document parsing, agent memory, and runtime governance into a single platform tied to Unity Catalog — the same governance layer that already manages Databricks’ data assets, ML models, and feature stores (Databricks Blog).

The core thesis is simple: enterprises already trust Unity Catalog to govern their data. Agent Bricks extends that trust boundary to cover the agents that act on that data. Every tool an agent can call, every model endpoint it routes to, every document it retrieves — all registered, permissioned, and auditable through the same catalog.

The platform’s GA timeline tells you where Databricks sees the priority stack:

The Three Pillars: Choice, Context, Control

Databricks frames Agent Bricks around three architectural pillars. This isn’t just marketing taxonomy — each pillar maps to a real set of technical decisions you’ll make when building on the platform.

Pillar 1: Choice — Multi-Model, Multi-Framework

Agent Bricks is deliberately model-agnostic. Through Unity AI Gateway (formerly Mosaic AI Gateway), you can route agent requests to OpenAI, Anthropic, Google Gemini, Qwen, Kimi, Grok (via xAI/SpaceX partnership), Meta Llama, and Databricks’ own DBRX and Mosaic models — all through a unified API with consistent authentication and logging. According to Databricks, 63% of their customers already use two or more model families (DAIS 2026 keynote), and that number is climbing as teams discover that different tasks within a single agent workflow benefit from different models.

More Read

Top 10 Open-Source Agentic AI Projects Dominating GitHub: September 2026 Roundup

🔒UiPath AI Trust Layer: A New Era of Responsible AI-Powered Automation

Power Automate Self-Healing Desktop Flows: The Agentic AI Guide (2026)

The framework story is equally open. Agent Bricks supports multiple agent harnesses — the orchestration frameworks that define how agents plan, act, and loop:

• LangGraph — stateful, graph-based agent workflows (the most popular choice on the platform)
• CrewAI — role-based multi-agent collaboration
• Agno — lightweight agent framework
• Claude Code SDK / Anthropic Agent SDK — for Claude-native agent patterns
• OpenAI Agent SDK — for GPT-native patterns
• Omnigent — Databricks’ own open-source meta-harness that can orchestrate agents written in any of the above frameworks within a single workflow

Omnigent deserves special attention. It’s an open-source project that acts as a universal adapter — you can have a LangGraph agent coordinating with a CrewAI agent and an OpenAI-native agent, all managed under a single Supervisor. For teams with existing agent code across multiple frameworks, this eliminates the “rewrite everything” barrier to consolidation. That’s a meaningful unlock for enterprises where different teams adopted different frameworks independently.

Pillar 2: Context — Data, Memory, and Documents

Raw model capability means nothing without context. Agent Bricks provides four context mechanisms, each targeting a different data modality:

MCP in Unity Catalog. The Model Context Protocol (MCP) — the open standard for connecting AI agents to external tools and data — is natively integrated into Unity Catalog. This means MCP servers (databases, APIs, SaaS tools) are registered as governed catalog assets with the same access controls as tables and models. An agent calling a Salesforce MCP tool goes through the same permission check as an agent querying a Delta table. For agentic architects who’ve been manually managing tool registries, this is a significant governance simplification.

Knowledge Assistant (Instructed Retrieval). Databricks’ managed RAG system goes beyond basic vector search. “Instructed Retrieval” lets you provide natural-language instructions that guide the retrieval model’s understanding of what constitutes a relevant result for your specific domain. According to Databricks, this approach delivers 70% higher accuracy than standard RAG pipelines on enterprise document sets, with a 30% improvement on multi-step reasoning tasks (Databricks Blog). For teams already running GraphRAG or hybrid retrieval architectures, the Instructed Retrieval approach offers a managed alternative that trades customization depth for operational simplicity.

Document Intelligence. A set of SQL-native AI functions — ai_parse_document, ai_extract, ai_classify — that turn unstructured documents (PDFs, images, scanned forms) into structured, queryable data directly inside Spark SQL. You don’t need a separate IDP pipeline; the parsing happens as a SQL transformation in your existing data workflows. AstraZeneca used this to process over 400,000 clinical trial documents, building a working agent in under 60 minutes (DAIS 2026).

Genie Ontology & Agent Mode. Genie is Databricks’ natural-language-to-SQL interface. In Agent Mode (currently preview), Genie can perform multi-step reasoning over structured data — decomposing a complex business question into a sequence of SQL queries, intermediate analyses, and follow-up questions. The ontology layer lets you define business concepts (“quarterly revenue,” “active customer,” “churn risk”) that Genie maps to your actual schema, bridging the gap between how executives ask questions and how data is stored.

Lakebase (Agent Memory). Agents that need persistent state — conversation history, user preferences, intermediate reasoning artifacts — can store it in Lakebase, a managed PostgreSQL-compatible database purpose-built for agent memory and state management. This sits alongside your lakehouse data but is optimized for the low-latency read/write patterns that agents demand. For a deeper dive into how agent memory architectures compare across platforms, see our agent memory architecture guide covering Mem0, Letta, Zep, and Cognee.

Pillar 3: Control — Governance, Security, Cost

This is where Agent Bricks makes its strongest differentiation claim. While every agent platform promises “enterprise-grade governance,” Databricks backs it with a governance stack that already runs in thousands of production data environments.

Unity AI Gateway. The runtime governance layer (GA August 2026) that sits between your agents and every model endpoint. It enforces:

• Rate limiting and cost controls — per-agent, per-team, per-model spend caps with real-time tracking. For agentic architects managing token economics and agent FinOps, this is table-stakes functionality that many competing platforms still lack as a native feature.
• Guardrails — content filtering, PII detection, topic restriction, and custom safety policies applied consistently across all model providers.
• Audit logging — every model call, tool invocation, and data access is logged with full provenance, queryable through standard Databricks SQL.

OBO (On-Behalf-Of) Authentication. Agents inherit the identity and permissions of the user they’re acting for — they don’t run with a service account’s blanket permissions. If a sales rep’s agent tries to access HR data, it gets the same “access denied” the rep would get. This is a critical pattern for regulated industries where “the AI had access” isn’t an acceptable audit response.

Contextual Policies. Stateful, SQL-based security policies that can make authorization decisions based on runtime context — the conversation history, the data being accessed, the user’s role, even the time of day. This goes beyond static RBAC into the kind of dynamic, context-aware governance that NIST’s AI agent standards initiative is pushing the industry toward.

LakeWatch. Databricks’ agentic security platform for automated PII scanning, incident detection, and compliance response. LakeWatch agents continuously monitor data access patterns and can trigger automated remediation workflows when anomalies are detected.

Deep Dive: The Supervisor Agent

The Supervisor Agent, generally available since February 2026, is Agent Bricks’ orchestration layer for multi-agent systems. If you’ve built multi-agent architectures with LangGraph or CrewAI, the Supervisor fills a similar role — but with tighter integration into Databricks’ governance and deployment stack (Databricks Blog: Supervisor Agent GA).

Here’s how it works architecturally:

Dynamic routing. The Supervisor doesn’t follow a static DAG. It uses an LLM to analyze incoming requests and dynamically route them to the most appropriate sub-agent or tool. A customer service request might route to a Knowledge Assistant agent for FAQ lookups, escalate to a Genie Agent for account-specific data queries, or hand off to a human agent — all decided at runtime based on the request content and conversation state.

Agent-as-tool composition. Any deployed agent can be registered as a “tool” that other agents — including Supervisors — can call. This enables hierarchical architectures: a top-level Supervisor routes to domain-specific Supervisors, which route to specialized agents. The key constraint is that every agent in the hierarchy inherits governance from Unity Catalog, so you don’t lose auditability as you add layers.

State management. The Supervisor maintains conversation state across sub-agent calls, using Lakebase for persistence. This means a multi-turn interaction that spans three different sub-agents maintains coherent context — the third agent knows what the first two already established.

Evaluation with MLflow CLEARS. Agent quality is measured through the CLEARS framework: Correctness, Latency, Execution, Adherence, Relevance, Safety. MLflow tracks these metrics per-agent and per-interaction, feeding into dashboards and alerting. For teams building agent observability and AgenticOps pipelines, the CLEARS framework provides a structured starting point that maps cleanly to both technical SLOs and business KPIs.

ALHF (Agent Learning on Human Feedback). A continuous improvement loop where human feedback on agent outputs is captured, aggregated, and used to fine-tune routing decisions and sub-agent behavior over time. This isn’t RLHF at the model level — it’s feedback-driven optimization at the agent orchestration level, which is a genuinely novel approach.

Getting Started: Architecture for Your First Agent Bricks Deployment

Here’s a reference architecture for a production Agent Bricks deployment, distilled from the published customer patterns:

Step 1: Data Foundation

Before you build agents, ensure your data assets are registered in Unity Catalog. This includes Delta tables, feature tables, vector search indexes, and any external data sources accessed through MCP servers. The governance story falls apart if your agents are reaching around the catalog to access ungoverned data.

Step 2: Knowledge Layer

Set up Knowledge Assistant with Instructed Retrieval for your document corpus. Define retrieval instructions that encode your domain’s definition of “relevant” — this is where the 70% accuracy improvement comes from. Build your Document Intelligence pipelines for any unstructured sources that need to feed into the knowledge layer.

Step 3: Agent Authoring

Author individual agents using your preferred harness (LangGraph, CrewAI, etc.). Each agent should have a focused responsibility — resist the urge to build a monolithic agent. Register each agent’s tools through Unity Catalog so they inherit governance automatically.

# Example: Registering a LangGraph agent with Unity Catalog tools
from databricks.agents import Agent, UCTool

# Tools registered in Unity Catalog
tools = [
    UCTool("catalog.schema.customer_lookup"),
    UCTool("catalog.schema.order_history"),
    UCTool("catalog.schema.knowledge_search"),
]

agent = Agent(
    name="customer_service_agent",
    llm_endpoint="databricks-meta-llama-3-1-70b",
    tools=tools,
    instructions="You are a customer service agent..."
)

Step 4: Supervisor Orchestration

Deploy a Supervisor Agent that routes across your individual agents. Define the routing logic — either through natural-language instructions or explicit rules — and configure fallback behavior for cases where no sub-agent is confident enough to handle the request.

Step 5: Gateway and Guardrails

Configure Unity AI Gateway with your cost controls, rate limits, and content guardrails. Set up OBO authentication so agents inherit user permissions. Define contextual policies for any sensitive data domains.

Step 6: Observability

Enable MLflow tracing for all agent interactions. Set up CLEARS metric dashboards. Configure alerting for latency spikes, safety violations, and cost anomalies. This isn’t optional — agent systems that ship without observability end up getting turned off within weeks when the first production incident hits and nobody can explain what happened.

Real-World Deployments

The customer stories put meat on the architectural bones:

AstraZeneca deployed Document Intelligence across 400,000+ clinical trial documents and had a working agent querying them within 60 minutes of setup. The governance layer was the deciding factor — pharmaceutical companies can’t have AI agents accessing clinical data outside of validated, auditable pipelines (DAIS 2026).

7-Eleven built customer-facing agents that reduced search time by 60% and improved first-contact resolution by 25%. The multi-model routing capability let them use smaller, cheaper models for simple queries while routing complex requests to more capable models — a direct FinOps optimization (DAIS 2026).

Franklin Templeton uses Agent Bricks for financial document analysis, leveraging OBO authentication to ensure analysts’ agents can only access the portfolios they’re authorized to manage. Zapier, Workday, Virgin Atlantic, EchoStar, Fox, and Block are also deploying across use cases from workflow automation to media content operations.

The Partner Ecosystem

Databricks has assembled a partner network of 23+ companies building on Agent Bricks, including system integrators (Accenture, Capgemini, Deloitte, EY, Infosys, Wipro), observability vendors (Arize, Monte Carlo), data catalog providers (Atlan), application builders (Retool, Sigma, Qlik), and retrieval infrastructure (Glean, LlamaIndex). This ecosystem depth signals that Agent Bricks isn’t a standalone product — it’s becoming a platform layer that third parties build on.

Where Agent Bricks Fits — and Where It Doesn’t

Agent Bricks makes the most sense when:

• You’re already a Databricks customer — the governance integration with Unity Catalog is the platform’s core advantage, and it only matters if your data is already there.
• You need multi-model, multi-framework support — teams standardized on a single model provider with a single framework may find Agent Bricks adds complexity without corresponding value.
• Governance is a hard requirement, not a nice-to-have — regulated industries (financial services, healthcare, government) where every model call needs to be auditable.
• You’re building multi-agent systems at scale — the Supervisor Agent and Omnigent capabilities are overkill for single-agent deployments.

It’s less compelling when:

• Your data lives outside Databricks — migrating data to unlock agent governance is a high-cost proposition.
• You need maximum framework flexibility with minimal platform lock-in — despite the multi-framework support, you’re still deploying and managing agents through Databricks’ toolchain.
• You’re building lightweight, single-purpose agents that don’t need enterprise governance — tools like LangGraph + LangSmith or CrewAI + their managed platform may be simpler.

Agent Bricks vs. the Competition

What’s Coming Next

Based on the DAIS 2026 roadmap and public announcements, expect Genie Agent Mode to reach GA in late 2026, enabling production use of multi-step structured-data reasoning. The MCP ecosystem within Unity Catalog is expanding rapidly — Databricks is actively courting SaaS vendors to publish MCP servers as catalog assets. And Omnigent, as an open-source project, is attracting contributions from the broader agent framework community.

The broader signal is clear: Databricks is positioning Agent Bricks not as a feature add-on to its lakehouse platform, but as the primary interface through which enterprise users interact with their data. As Databricks CEO Ali Ghodsi said at DAIS 2026, the vision is that every data interaction eventually becomes an agent interaction — governed, auditable, and intelligent.

For agentic AI architects evaluating platforms in 2026, the question isn’t whether to adopt governed agent infrastructure — as the Gartner Hype Cycle for Agentic AI makes clear, that’s table stakes. The question is whether your governance layer should be an extension of your data platform (Agent Bricks’ thesis) or a separate, purpose-built system. If your enterprise data already lives in Databricks, the answer is looking increasingly obvious.

Frequently Asked Questions

What is Databricks Agent Bricks and how is it different from Mosaic AI?

Agent Bricks is the evolution of what was previously called Mosaic AI Agent Framework. It’s a governed enterprise platform for building, deploying, and managing AI agents on Databricks. The rebrand reflects a shift from model-centric tooling (Mosaic AI) to agent-centric tooling (Agent Bricks), with Supervisor Agent orchestration, Unity Catalog governance, and multi-framework support as the core capabilities. All Mosaic AI agent features have been absorbed into Agent Bricks.

Can I use Agent Bricks with non-Databricks models like GPT-4 or Claude?

Yes. Unity AI Gateway supports routing to OpenAI, Anthropic, Google Gemini, Qwen, Kimi, Grok, Meta Llama, and other providers through a unified API. You configure model endpoints in Unity Catalog and agents can call any registered endpoint. 63% of Databricks customers already use two or more model families through this mechanism.

What is the Supervisor Agent and when should I use it?

The Supervisor Agent (GA February 2026) is an LLM-powered orchestration layer that dynamically routes requests to specialized sub-agents. Use it when you’re building multi-agent systems where a single request might need different agents for different sub-tasks — for example, a customer service system that routes between FAQ lookup, account queries, and human escalation. For single-agent deployments, the Supervisor adds unnecessary complexity.

How does Agent Bricks handle security for agents accessing sensitive data?

Three mechanisms: OBO (On-Behalf-Of) authentication means agents inherit the permissions of the user they’re acting for, not a shared service account. Contextual policies let you write SQL-based security rules that consider runtime context (conversation history, data being accessed, user role). And Unity AI Gateway enforces guardrails — content filtering, PII detection, topic restrictions — consistently across all model calls.

What does Databricks Agent Bricks cost?

Databricks prices Agent Bricks through its standard DBU (Databricks Unit) consumption model. Specific costs depend on your compute tier, model endpoints used, and data storage. Unity AI Gateway includes per-agent cost tracking and spend caps, which helps manage token economics at scale. Contact Databricks for enterprise pricing aligned to your usage pattern.

Key Takeaways

• Agent Bricks is Databricks’ play to own the enterprise agent platform layer — extending Unity Catalog governance from data to agents, with over 100,000 agents already built on the platform.
• The Supervisor Agent (GA Feb 2026) enables dynamic multi-agent orchestration with state management, hierarchical routing, and ALHF-based continuous improvement.
• Multi-model and multi-framework support is genuine — 63% of customers use 2+ model families, and Omnigent lets you orchestrate LangGraph, CrewAI, and other framework agents together.
• Governance is the differentiator: OBO authentication, contextual SQL policies, Unity AI Gateway guardrails, and full audit logging address the compliance requirements that generic agent frameworks can’t.
• Knowledge Assistant’s Instructed Retrieval claims 70% higher accuracy over standard RAG — a significant edge if validated against your domain’s documents.
• Agent Bricks is strongest for teams already on Databricks — the governance story depends on Unity Catalog, making it less compelling if your data lives elsewhere.
• Document Intelligence (ai_parse_document, ai_extract, ai_classify) brings unstructured document processing into SQL workflows, eliminating the need for separate IDP pipelines.

References

1. Databricks. “Agent Bricks: A Governed Enterprise Agent Platform.” databricks.com/blog
2. Databricks. “Agent Bricks: Supervisor Agent Now GA — Orchestrate Enterprise Agents.” databricks.com/blog
3. Databricks. “Agent Bricks at DAIS 2026.” databricks.com/blog
4. Databricks Newsroom. “Databricks Grows 80% YoY, Surpasses $7B Revenue Run Rate.” databricks.com/newsroom
5. AI Magazine. “Databricks: Enterprise AI Agents and a US$190bn Valuation.” aimagazine.com
6. ChatForest. “Databricks Agent Bricks: Governed Enterprise Agent Platform — Supervisor Builder Guide.” chatforest.com
7. NexaStack. “AI Agents on Databricks.” nexastack.io
8. Atlan. “Databricks Agent Bricks.” atlan.com
9. Analytics India Magazine. “Databricks Introduces Agent Bricks.” analyticsindiamag.com

What to Read Next

• AI Agent Observability & AgenticOps in Production (2026) — how to build the monitoring layer that Agent Bricks’ MLflow CLEARS plugs into.
• AI Agent FinOps & Token Economics Guide (2026) — the cost management strategies that Unity AI Gateway’s spend controls operationalize.
• AI Agent Memory Architecture: Mem0, Letta, Zep & Cognee Guide (2026) — compare Lakebase against standalone memory frameworks.
• Gartner Hype Cycle for Agentic AI 2026: Complete Guide — where Agent Bricks fits in the analyst landscape.