From MLOps to AgentOps: Shipping Autonomous Agents You Can Actually Trust

Summary

Agents break the rules of traditional MLOps because their outputs are nondeterministic, behavior depends on tools and context, and production reliability cannot be validated with binary tests—as illustrated by the real Air Canada case where the airline faced legal liability for its agent's hallucinated refund policy.
AgentOps on the Databricks Data and AI platform addresses three new dimensions of complexity using MLflow for agent tracing and LLM-judge-based evaluation, Unity Catalog for AI governance and tool access control, and Databricks Asset Bundles for promoting agents across environments.
The four pillars of AgentOps—evaluation, governance, observability, and promotion—require integration gates that prevent code from advancing without passing evals, and architecture choices between managed AgentBricks and code-first approaches depend on team requirements.

From MLOps to AgentOps: Shipping Autonomous Agents You Can Actually Trust

We spent a decade learning to ship models reliably. Agents break most of those assumptions: outputs are nondeterministic, behavior depends on tools and context and “good” is defined by domain experts, not a binary test. AgentOps is what MLOps becomes when your system can reason, call tools and act on its own. In 20 minutes, we’ll trace the jump from MLOps to LLMOps to AgentOps and distill it into a practical operating model on Databricks: choosing the right architecture tier (managed AgentBricks vs. code-first), making evaluation a first-class citizen with MLflow LLM judges, governing tools through Unity Catalog and promoting agents across environments with Databricks Asset Bundles. You’ll leave with the stakeholder map, anti-patterns, and DevOps principles needed to move an agent from a demo that impresses to a system production can depend on.
Talk By: Pavithra Rao, Sr Solutions Architect, Databricks ;

Chapters

FAQs

What is AgentOps and how does it differ from MLOps?

AgentOps is what MLOps becomes when your system can reason, call tools, and act autonomously—it adds three new dimensions of complexity: nondeterministic outputs, behavior that depends on tools and context, and success criteria defined by domain experts rather than binary test results. Traditional MLOps practices like model versioning and monitoring are necessary but not sufficient for agents.

What happened in the Air Canada agent case mentioned in this video?

A man sought a bereavement fare refund based on a policy that the airline's AI agent confidently described—but the policy did not actually exist. When he sought the refund, the airline claimed the chatbot was a separate legal entity and disclaimed responsibility; a tribunal ruled against the airline and required them to honor the refund. This real incident illustrates the legal and reputational cost of deploying agents without proper governance.

How does MLflow support agent evaluation in an AgentOps workflow?

MLflow provides agent tracing, LLM-judge-based evaluation, and subject-matter expert feedback loops that make evaluation a first-class citizen alongside development. Integration gates in the CI/CD pipeline prevent agent versions from being promoted to production without first passing these evaluations, ensuring only validated behavior advances.

What role does Unity Catalog play in governing AI agents on Databricks?

Unity Catalog provides AI governance for data access control, ensuring agents can only access the data and tools they are authorized to use. Combined with Databricks Asset Bundles for environment promotion, this gives teams a governed, repeatable path for moving agents from development through staging to production on the Databricks Data and AI platform.

Full transcript

[00:10] Um, thank you all for being here. I hope uh the day one is going well. Uh, thanks for being here, taking time joining us for the summit. Uh, today I'll be talking about MLOps, stage and ops. Um, so pretty uh, I would say
[00:25] like a intense topic. I'll try and make it very very simple 20 minutes. So let's get into it. I'll start with a quick story, right? This is a real incident. A man loses his grandmother and he goes to
[00:40] a website, airline website to book his flight. He
[00:53] beaverment policy?" So the AI assistant agent is so confident it will say yes go ahead and book for it pay the full price within 90 days go and request for um
[01:08] refund and when he actually goes and requests for a refund the airline policy will say uh airline team says that the agent is not true the policy never
[01:22] existed. So think about it. Uh he brings them to the court and in the court the airline says that this is their words. Chatbot
[01:36] is a separate legal entity and we are not responsible for it. Let's sit with that. You go to any website and there is no backing from the entire team for the agent agents
[01:49] response. you you don't want to be in that position if you are a customer if you are like a team who is building this bot and this is a true story it happened with Air Canada and the tribunal in the
[02:02] court said they have to pay for the um the like the filing uh issue so they had to pay for the refund policy right so
[02:16] next 20 minutes I want to talk about why do agents break the rules we learned right um can I get a quick show of hands
[02:29] where folks have built agents here like any kind of agents of course right even I build my own agents and show your hands if you've had the agent not being
[02:44] giving trustable responses trustable uh behavior in in production Do we have folks? Yeah. So you see right there within the room
[02:56] that's the drop between the agent that works on the demo but that fails in production, right? So let's let's understand how do you what is that gap? How do we fill that gap? And that gap is
[03:09] expensive, right? It's not just the money. It's about the trust. It's about the branding. So let's talk how to do the agent ops. um in next 15 minutes.
[03:21] So we have spent decades right like machine learning has been here since I've ever stepped into this industry like 12 years uh 13 years back and we
[03:34] have really disciplined it. We know how uh machine learning models work but why do why do agents break this rules right?
[03:46] So what got us here is three waves. One is MLOps. Mlops gave us the discipline of monitoring drift, monitoring drift.
[03:58] Then you uh you are also like able to do the observability and it is more deterministic. You give one input, there's one output clean, you're able to u monitor its behavior. with LLM ops
[04:13] came um a language model and a prompt. That's fine. You can still it's it's a single call. You can give it to it and it comes back with the response and it's more deterministic. You know, uh there
[04:27] are only certain things it can uh give the output. But what happens with agent ops? really breaks all these rules because the agent by itself is an LLM with a lot of tools.
[04:43] You're now getting into a space where you're not able to predict its behavior. So everything that we learned with MLOps, how to monitor drift, how to track its performance is not going to
[04:56] work with agent ops, right? It's it's a completely different beast. uh if you were to say that so when we say agent an LLM with a prompt that is single
[05:10] model call rag retrieves the context then generates still a basic function as I said what makes things uh something an agent is the harness
[05:23] agent has an LLM lm can reason and it's a brain it's like a human body Right? You have a brain, it can reason, that's great. But who is taking actions is all
[05:35] your body parts. So think of the same analogy with the entire agent. It gets an LLM. It has context memory. It has tools. So you really need to make sure
[05:48] all each of these components is working as expected as it's behaving as expected versus not just looking at the LLMs, right? you you never you'll never be
[06:00] able to like monitor the LLM's behavior and say okay this is really doing great and you move into production. So it's a complete harness that you need to do ops
[06:12] on. It's not just LLM ops. There was a wave of LLM ops but we have really broken that and got into agent ops. And the the next few minutes I'm going to
[06:24] talk about what's the framework how you're going to do that do the agent ops but I just wanted to start with this mind like understanding that why even MLOps LLM ops is never going to work for
[06:39] agent ops. So this is the practical operating model we'll uh talk about.
[06:54] So I think I I skipped this. Yeah, sorry I'm I'm getting some delay here. Give me one second. Uh I'm seeing yeah three assumptions. So the three assumptions as I said one is the same input different
[07:06] output for machine learning. You give an input you know this is the output you have the true data set you can monitor that. But with um agent ops agents you you
[07:19] cannot do that. You have to stop uh testing for the strings but for each case you have to test it couple of times. You can't just test once and it gives you one output you're great. No,
[07:32] that doesn't happen. So it is not deterministic and context dependent. There is no like a concept of context for machine learning models. It's it's a
[07:44] true set of data structured data. You give the input you get the output. But with agents there are let's say you change a tool within a agent like let's say you're uh calling an MCP or like any
[07:57] other tools that you want your agent to use in real time. If you change that upstream three steps away suddenly the behavior of the model changes so how do you account for that? How do you track
[08:09] for that? And the finally this is the biggest thing I think there's one thing you want to take away is next few things couple of slides I'll talk about is what is good do we know like it is so
[08:22] subjective it's it's not like one or zero or like couple of categorical variables that you would say okay this is the output it's great it's code 100% no the good is defined by your subject
[08:34] matter experts so you you will really have to bring this and central to your entire agent ops life cycle of evaluating what good means. So that
[08:46] leads me into the next section which is people right we often forget that people are the one who make or break things
[08:59] right do we agree we decide we know if the agent ops is behaving when I say we are we the right people the developers won't be able to say that so this is really something we have worked with
[09:12] couple of enterprise customers and put this together as uh uh blueprint is you definitely need all these people in your room when you're talking about releasing an agent to production. If you really
[09:26] want to trust and uh back the agent's uh outputs just like what happened with Air Canada's agent, they were not able to back the responses that agent was
[09:38] giving. uh so you really want to tr build a trustable ones and as you see here I've highlighted um the governance and validation of course you need uh engineers but you start with the product
[09:51] manager understand what their requirements are and then the sponsors of course who who talk about the risk and ROIs and finally the SME and compliance team if you're a regulated
[10:03] industry or even not if you're touching customer data you're you're immediately in compliance teams conversations Right. So you really have to make sure that uh all these team folk team members are
[10:16] involved even before you write a single line of code. You got to make sure everybody is aligned and you have the right support from the team to start working on this.
[10:30] So there are four decisions I'll talk about. Again this is a 20 minutes talk so I'm trying to keep it very high level. So there is really good action items for this team to go with.
[10:42] So pick your architecture tire uh tire. I've often seen teams like uh customers start on the right end the code first approach but you really don't know what you're
[10:55] building for right the the space is always evolving. You do you use knowledge assistant versus do you build your own custom rag? Is there out uh out of the box uh agent bricks? So my my
[11:08] recommendation is uh at least what you have seen with successful customers is start with the managed and again keep in mind this is not oneway door. It doesn't mean you start with managed and uh
[11:20] you're locked in. No, it's always a dial. Start with the managed for fast results, lower overhead and when the stakes actually increase that you really
[11:32] need custombuilt code first approach, you can always um upgrade to the code u code first approach. With code first approach you have a lot of flexibility
[11:44] with lot of power comes lot of responsibility. So you're building the langraph, the traces, the tool calling agents, the chains, everything. You you'll have to invest a bit more of a time versus uh agent bricks is mostly
[11:59] managed. So you you just have to tell it what you need in terms of okay, I I want to build like a supervisor agent and pick couple of smaller agents, put it together through the UI and you're ready
[12:11] to start testing at least. Right. So you have really escaped that um ROI or like um investment like cycle of not investing in code first versus go with
[12:24] agent bricks. The next thing here I want to spend honestly couple of minutes because this is like your make or break decision. The
[12:37] one princip pr principle that changes everything is your eval with agent framework mlflow agent framework you're actually uh this is again open source you're not logged in
[12:49] again but with mlflow 3.0 plus we have invested a lot of um resources to make this first class for the entire development life cycle. So as you see in
[13:02] the uh screen here and um this is more of a life cycle where you start with um the the entire application and the evaluation is happening not just once
[13:15] but all the time. So you there is mlflow traces agent uh agent framework has u agent eval for mlflow has traces feedback and once you get the evaluation
[13:30] going you can have judges. So there will there are two types of judges one is your llm judges. So you can have one LLM judge the output of the agent and there
[13:42] are basic um scores that you get. So think of it like you go to a show right there judges and they put the play cards of like out of 1 to 10, five, seven, nine. So similar to that you have judges
[13:56] like LLM judges who are scoring the outputs. That's like the bare minimum a developer has to do. It's out of the box. You don't need an additional human
[14:08] to help you do this like a SME or a product team. But when you have to bring it to production once you have this whole thing going when you move into production that's where you need the inputs from your domain experts. So the
[14:22] domain experts will come as the ex uh the next level of judges who are assessing the outputs from the LLM judges. So you're not creating any gaps
[14:34] there but you're really bringing this to the SMEI but not wasting their time or the cycles in from from day one but give them the baseline of okay this is what we built this is the judge it's scoring
[14:47] this and you can give it to them and we have uh MLflow where you can bring in review there is a review app they can review it and then give the uh outputs. So how does this change with production
[15:00] right? So in production LLM judges are always running for any input that comes in there is an ML flow trace and that output becomes an input for your eval life cycle. So this is a whole life
[15:13] cycle and once you set it up it keeps going. you can bring in the SME. Often if the model is not performing across all the uh criterias, basic criterias or
[15:25] the custom criterias you build, you can always do that and test during the development and move around and this honestly the life cycle of at least putting a custom judge and production
[15:39] which I have in the next slide. I think uh I'll come back uh I guess yeah this one eval gates that should between dev staging and prod that should really be
[15:52] really really be your gates like integration gates you can never allow any agent code to be deployed into any other higher environments unless it passes those integration tests with your
[16:06] eval gates right so that's about decision two let's come back to decision like go to the decision three now think about the Canada Air
[16:18] Canada example I gave right the agent gave an output and now we are not able to like the Air Canada team is not able to trace why did it even come back come up with that response right it
[16:32] it it cannot make up things unless it is connected to few systems so there was no answer to that but if you if they were to in use a governance framework especially unity catalog where it's a
[16:46] universal catalog they could have actually gone back to the traces and understood how exactly the output came and trace everything back to the input so what is that agent calling what are
[16:59] the tool calls uh what data it has access to how is it even evaluated everything would have been stored the story would have been completely different that man who lost his grandmother would have at least got the
[17:12] refund for what he expected, right? Because they would have built a agent or at least not given a wrong promise. So, Unity catalog um we are releasing AI
[17:24] gateway. This is in beta for customers who already know this. We are in beta and then uh we are uh going to do a lot of announcements in next couple of days. So, look out for it. Uh now it's not
[17:38] just models as you see here it's agents MCPS skills uh external model providers all of this is coming under unity catalog and now you'll be able to trace
[17:50] it back so you definitely highly highly encourage put put a governance framework and it works really uh very tightly integrated with your uh ML flow as well.
[18:03] um promote agents like code. This is one of the biggest thing we see is like production going into production is not overnight deployment where one or two developers are saying okay overnight no
[18:16] one is touching my system I'll go and f make the changes done we are in production that's not the case here and the other thing I'll call out is you don't want to promote um a agent by
[18:29] itself we highly recommend promote the code and deploy that agent because there are a lot of advantages. Let's say you're making any changes in the lower environments and you want to promote
[18:41] this to production uh or you you want to evaluate it, it's not touching any production basic SDLC life cycle, right? So think about it. you would probably need to make sure
[18:54] that evalgate we talked about is something you have to make as a integration testing and then move uh the code from dev staging and prod. If you're interested uh find me around the
[19:07] booth here after the talk uh we can discuss we we are releasing a big book of agent ops. We are going to discuss a lot of patterns in there. I know many customers who have multiple workspaces, multiple accounts, multiple cataloges.
[19:21] We have addressed all those but this is the fourth decision I would really call out and this all comes together like if you think about it agent ops is a complete loop on data bricks decision
[19:34] one we talked about the build decision two is evaluation which is u in sme here and also the governance um and and the evaluation and the third one is the
[19:46] governance and the fourth one is promotion. So uh your entire agent ops is very similar to devops flow feedback and continuous learning. You set it up
[19:58] once there is a continuous flow of the live monitoring in production and then that feeds back into your eval into lower environments.
[20:10] Um I know we have uh 5 seconds here. This is just summarizing like um all the decisions we talked about. It only takes
[20:22] discipline to not skip any of this step. If you really want to bring a agent into production, it's not about throwing a bigger model. It's about making sure you
[20:36] follow three or four decision framework that we discussed and make sure you have the trust. It's not just a shiny demo that works in a room versus um a agent
[20:48] that you can stand by when it's put in production. So one takeaway, treat evaluation as a first class citizen, not an afterbolt
[21:00] once you have finished the agent development. Finally, uh this is my last slide. Uh take this home. It's very hard to cover agent ops in 20 minutes. Really really
[21:12] um hard. It it needs it. It deserves its own like uh conversations. So uh we are releasing big book of agent ops. I'm one of the co-authors. There is more sessions tomorrow day after if you
[21:26] want to also check it out on agent ops. Uh uh like look out for the release. It's probably coming sometime in August. We are working on it. Um so look out for it and there's a quick survey. I'm sure
[21:40] you have seen this if you have attended sessions last year or from the morning. Uh give us feedback what's working, what's not working. We would love to hear and you can always connect with me.
[21:52] Thank you so much for being here.

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.