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

Summary

Enterprise agent platform: Agent Bricks is Databricks' developer platform for building enterprise agents at scale, addressing the 99% infrastructure challenge beyond the agent loop.
Developer capabilities: The platform provides choice in models and agents, context from unified data, and control over authentication, identity, and long-running operations.
Governance and optimization: Unity AI Gateway provides governance and cost-control through token optimization, shifting from "tokenmaxxing" to "valuemaxxing" for enterprise AI.

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

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
02:30 — Developer pain points: choice, context, and control
24:45 — Get started with Agent Bricks
Presenters:
Kasey Uhlenhuth, Director, Product Management, Databricks
Ankit Mathur, Sr. Staff Software Engineer, Databricks

Chapters

FAQs

What is Agent Bricks?

Agent Bricks is Databricks' enterprise agent platform that helps developers build and deploy production agents at scale, addressing the infrastructure challenges beyond the agent loop.

What's the AI's 99% problem?

The agent loop is only 1% of production agent work; the other 99% involves handling authentication, identity management, timeouts, infrastructure provisioning, and operational concerns.

Should we build custom AI agents or buy an agent platform?

Building custom AI agents is superior to buying agent platforms when your organization has unique business logic, specific data integrations, or custom governance requirements that general-purpose platforms cannot address. Agent Bricks on Databricks provides the framework and components developers need to build custom agents without rewriting core functionality, striking a balance between flexibility and development velocity. Organizations can assemble agents from pre-built components while retaining control over business logic and data handling.

what is an internal developer platform

An internal developer platform provides standardized tools, templates, and infrastructure that enable application teams to build, deploy, and operate software with reduced friction and consistent quality standards. Rather than each team duplicating work to handle authentication, monitoring, and deployment, an internal developer platform centralizes these concerns while allowing teams to focus on business logic. Agent Bricks provides components that can be incorporated into internal developer platforms to enable teams to build custom AI applications.

How do I build custom agents that use company data securely?

Building custom agents that use company data securely requires isolating agents within a governance boundary where they access only authorized data, their actions are audited, and they cannot escalate permissions. Agent Bricks combined with Databricks' Unity Catalog enables this by enforcing identity-based access control, maintaining audit logs of agent decisions, and providing visibility into data access patterns. Organizations can confidently deploy agents knowing that security policies are automatically enforced.

Full transcript

`0:00` Agent Bricks, the enterprise agent platform for developers

Welcome to the stage, Databricks Director of Product Management. 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. Where 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. 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.

`1:32` AI's 99% problem

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.

`2:30` Developer pain points: choice, context, and control

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 stacks, which means you have to re-platform 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.

`3:56` The Agent Bricks difference

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. And today, we're excited to announce, in partnership with SpaceX, that you now get access to the Grok model family as well. 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 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 of 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, LangGraph, 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 they 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-built 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.

`8:04` Introducing Agent Memory Services

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 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.

`9:13` Introducing Databricks Sandbox

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 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 securely run and 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 on behalf of permissions to your data so that your agent can get creative with your data inside of that VM that won't affect the rest of your system.
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.

`10:48` Unity AI Gateway's new capablities

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 OK. But wouldn't it be great if you just had 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 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 OK for it to then access and publish things to the public 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 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 project.
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 intelligent system out there that kind of helped 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, 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 T Hi, everyone, 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.

`16:24` Live demo: Unity AI Gateway

Now, as a software engineer, I, myself, use AI every single day, and what we're seeing is that leading 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 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 used towards the gateway. So all I need to do is something like this. And boom. Codex starts just as it normally would with a couple differences.
It's now pointed at the Unity AI Gateway. So your 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 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.
And so we can take a look at this, and it's automatically recommending that we switch to 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 Omnigent 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 Omnigent connects through the gateway. And for that same query that I had before, which was relatively simple, 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 Omnigen 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 CoreLogic 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 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 govern 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 wrap up Agent Bricks. KAYSEE KINGHARANI- Thank you, Ankit, for that amazing demo. So as you can see, Agent Bricks is our complete end-to-end agent developer platform.

`24:45` Get started with Agent Bricks

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 securely execute 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. Thank you.

Learn more about the Databricks Data and AI platform.

The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.