MAGI: Secure, Explainable, Repeatable AI for Healthcare

Summary

Centene, a healthcare payer serving 26 million Americans, partnered with Slalom and Databricks to build MAGI (Machine Agentic Governed Intelligence), a production framework that embeds security, explainability, and repeatability directly into the AI platform infrastructure.
The three gifts of MAGI are Security through AI Gateway enforcement and compliance guardrails, Explainability via MLflow tracing and immutable audit trails, and Repeatability through standardized templates and utilities that let teams adopt governed AI without reinventing compliance.
MAGI includes human-in-the-loop workflows with risk-tiered approval and continuous feedback loops for agent evaluation, reducing new team onboarding from weeks to days while making governance the default path rather than the friction point.

MAGI: Secure, Explainable, Repeatable AI for Healthcare

In regulated industries, deploying agentic AI at scale demands more than models and policy, it requires runtime governance built into the platform. Healthcare payers face a paradox: enormous opportunity to improve member outcomes and operational efficiency through AI, but devastating consequences if that AI operates without guardrails, explainability, and compliance tracking. Centene partnered with Slalom and Databricks to build MAGI (Machine Agentic Governed Intelligence), a production framework that delivers governance as part of the platform infrastructure itself.
Discover the three gifts of MAGI: Security through AI Gateway enforcement and compliance guardrails, Explainability via MLflow tracing and immutable audit trails for every decision, and Repeatability through standardized templates, guides, and utilities that let teams adopt governed AI without reinventing compliance. Learn how to design human-in-the-loop workflows with risk-tiered approval, implement continuous feedback loops for agent evaluation, and build agent runtime architectures using identity-bound governance at every stage. These patterns reduce onboarding time from weeks to days and make governance the default path, not the friction point.
🤝

Chapters

FAQs

What is MAGI and what problem does it solve for healthcare AI?

MAGI, or Machine Agentic Governed Intelligence, is a production AI governance framework built by Centene in partnership with Slalom and Databricks. It solves the challenge healthcare payers face deploying agentic AI at scale under strict regulatory requirements by building governance, compliance guardrails, and audit trails directly into the platform infrastructure rather than treating them as external policies.

What are the three gifts of MAGI?

The three gifts of MAGI are Security, Explainability, and Repeatability. Security is enforced through AI Gateway for compliance and guardrails; Explainability is delivered through MLflow tracing and immutable audit trails that document every decision; and Repeatability is achieved through standardized templates, guides, and utilities that allow teams to adopt governed AI without rebuilding compliance from scratch.

How does MAGI handle human-in-the-loop governance for high-risk decisions?

MAGI implements risk-tiered approval workflows where higher-risk AI decisions require human review before action is taken, ensuring autonomous agents do not make consequential healthcare decisions without appropriate oversight. This human-in-the-loop design is integrated into the agent runtime architecture alongside identity-bound governance at every stage of the platform flow.

What is the Billy agent workflow described in this video?

The Billy agent workflow is a prior authorization use case that illustrates how MAGI applies governance in a real healthcare scenario involving sensitive patient data and compliance-critical decisions. It demonstrates how the framework enforces security controls, logs decisions for audit, and applies appropriate human review checkpoints within an end-to-end agentic workflow.

Full transcript

[00:07] Thanks for coming out after what's probably a late night for some of you to listen to our talk. Uh we're very excited to be here to present uh the work we've been doing over the last year as a collaboration uh with Slalom. Uh I'm Barrett Vote. I'm senior director
[00:22] over the AI Hub team at Centene. I've been at Centene for about uh 9 years. That whole time has been building up Centene's data science, machine learning, machine learning operations, and now agentic AI platforms.
[00:37] Uh I'm joined by uh Mark Tabor on on my team uh and uh Guniti Sharma from Slalom. Do you want to introduce yourself? I'm Mark. I've uh worked at Centene for a little bit less than Barrett. I am the senior manager
[00:53] over enterprise data science and AI platforms, largely based on Databricks, but we also manage JupyterHub and and a couple other things. Really glad to be here. Hey everyone. I am Guniti Sharma. I work as a senior principal in the AI team at
[01:08] Slalom. I handle the agentic governance enterprise platform and the ATS lead for West Coast, and we have been partnering with Databricks and Slalom and Centene. So we've been uh Databricks customers for you know over 4 years, I believe.
[01:26] That uh has been an interesting journey for us. We started out building our data science and machine learning platform uh when I joined the company 9 years ago, and at that time we were building everything ourselves primarily from open-source technologies. And we had a long road map
[01:41] of the things we wanted to do for to make machine learning uh and machine learning engineering easier and faster, uh more repeatable. And we found that uh you know there were particular features in Databricks that we wanted. At the time it was specifically building a feature store that uh we started
[01:58] you know bringing Databricks into our environment and over time we found that our own road map of capabilities we wanted kind of merged with what Databricks was producing for doing machine learning and machine learning operations to the extent that today probably over 80% of our machine learning and machine learning operations is done on Databricks.
[02:14] And that actually put us in a perfect position with the rise of large language models and agentic AI to pivot and turn what was a primarily our machine learning operations platform into agentic AI platform.
[02:31] And so before we go into more details about that, a brief overview of who we are at Centene. Centene's probably the unless you're in health care the biggest company you've never heard of. We're actually Fortune 19 this year. You may have heard of many of our other brands. So
[02:47] part of Centene's strategy has been to be intensely local. So we do primarily state sponsored health care so Medicaid, Medicare, and ACA plans. We are in the majority well yeah we're in all US states in one way or another.
[03:04] And you may recognize some of our other brands for example Fidelis in New York or Sunshine in Florida or Superior in Texas. Ambetter is our ACA plans. Wellcare is our our Medicare plans. So while you may not have heard of Centene you've probably heard of our products. We have over 60,000 employees serving
[03:23] over 26 million Americans. That's one in 15 people in the United States. And these aren't just like average sampling of the United States. These are the most vulnerable members of our population. So people often people who are on Medicare or or Medicaid.
[03:39] And so in doing machine learning and AI for a company like Centene it gives a really great reason to get up in the morning that we're using math for good helping our members live healthier lives while uh hopefully saving the company money.
[03:58] All right. So, the opportunities for AI in healthcare for healthcare payer are pretty broad. I'm going to tell just like a little story kind of like set some perspective about a imaginary prior authorization reviewer for pharmacy named Billy. So, Billy's workflow today might look something like this. He gets in uh case
[04:15] details, he looks through the corresponding policy for that member. He thinks about it, thinks about whether there's any data that's missing that he needs to make a decision. He might ask for additional information from whoever entered the prior authorization request or go to other systems to get medical
[04:30] information. And then he thinks about it some more and makes an authorization decision. That process could take hours at best to days or weeks at worst if the data needs to make some round trips. You can easily imagine how this could be an agentic workflow where instead of
[04:47] Billy sitting right there at the beginning receiving the the request, he gets the sorry, there's an agent waiting for the case details, which then also looks at the policy to see how the prior authorization request corresponds to the policy. That agent might make some empty
[05:03] MCP calls, pull out data from different sources. Maybe it sends a message to somebody to get some additional information to enter into the system. And then presents Billy with the summary of here is the case, here's all the data that I gathered, here's how it corresponds to the policy.
[05:19] This is my recommended decision. You know, what do you decide? And so, what you know, could have taken a very long time now takes, you know, minutes to hours. And prior authorization moves much faster, which for somebody who's waiting to get a prescription might be
[05:34] pretty different experience relative to receiving their healthcare. There are lots of different places that uh AI and agentic AI can be used for healthcare payer. And so, part of the our challenge in navigating this was to figure out where should we
[05:50] uh insert governance, and I'll talk more about that in a second, and where should we we should should we just let people run. And so there are some obvious places where we just like let our employees run, things like software engineering uh and using for just basic uh back office
[06:06] operations, things like uh summarizing documents or knowledge bases. And there are some you know some areas that are you know more specific to our industry. We I actually used AI a lot for compliance. We get regulator questions from a variety of different you know states and federal government
[06:22] that the questions themselves tend to be pretty similar uh with some some small differences. And so we've actually have this kind of knowledge base already of all of our answers to all the regulators that is much faster to to rewrite and then proofread uh using AI.
[06:37] There are other parts There are other applications for AI for health care pay payer that are much riskier that we don't want an agent operating independently, things like making claims decisions or authorization decisions or fraud, waste, and abuse decisions. We absolutely want a human in the loop to prevent uh bad outcomes for our members
[06:54] or abrasion for our providers. And so therein lies the challenge for health care company. There's enormous opportunity for helping Centene be more efficient in everything that we do in providing better outcomes for our members at a lower cost.
[07:10] Um but if we do that it uh kind of without regard for the consequences, we could end up in pretty bad shape. So over there over a thousand bills introduced last year regulating AI or proposing to regulate AI in some way another, over 300 uh this year. Many of those are
[07:26] relevant to Centene, including laws that have passed to explicitly ban AI only uh adverse decisions for like claims and authorizations, uh requiring a physician to be in the loop for some critical kinds of decisions, um and making sure that any
[07:42] decision that AI makes is auditable and explainable. And so, when we're thinking about how to make this work, if we were just to fully enable AI, we we would very quickly run into bad situations. It'd be like a car with a gas pedal and no brake. It's
[07:57] going to go and then it's going to go off the road. Um but if we took the opposite uh situation, I actually just talked to somebody at breakfast today who he works at a company where as soon as agentic AI happened, the company just said, "No, you can't use it at all." If we did that for health care, we'd be missing out on
[08:14] all of those opportunities we could make the experience for our members better um or to save the company money. And that'd be like a car with uh brakes and no gas. Um it's safe, but it's also not going to go anywhere. And so, we need both. We need a gas pedal to enabling AI and a brake pedal
[08:30] to govern AI, and that needs to be built into the machine itself. Uh and so, the the key insight you'll see throughout the talk today is that governance must be provided at runtime, built into the platform, um not just before production or after production. And so, to that end, we built over the
[08:47] last year a platform we call Magi, which stands for machine agentic governed intelligence. And uh Mark Tabor on the team who led a lot of this development is going to tell you more. Thanks, Barrett. So, Magi. What is a Magi? Magi are elders. They're wise men.
[09:05] They're sages that have spent their time researching this deep magic and power that allows them to do mystical things that are unexplainable. Kind of sounds like AI, right? So, what we're trying to do is take that, capture that power, and
[09:23] then teach our own employees how do you utilize, how do you bring these tools to bear. But that has a a huge upside, but like Barrett was talking about, you can also cause a lot of harm. You can fly off the the cliff if you go too fast.
[09:38] So, we need to create a practice. We need to standardize. So, essentially what we've done is we've we built a framework that has cookbooks and guides. It has templates, so it has some that you can start with. It has a shared
[09:53] utility library, and all of this runs on top of Databricks. So, the our our goal as Magi is to deliver these three gifts to Santen. First, we need security, right? There
[10:09] are lots of regulations coming out saying that you can use AI for this, you can't use AI for that. So, we need to build a framework that allows us to put guardrails up. Next, we need to be able to explain it. There are lots of um
[10:25] laws that are coming out that talk about you have to provide a chain of custody, there needs to be provenance of data, you have to create an auditable report so it can be reviewed. So, we can't just use AI, we have to know why AI is doing what it is doing.
[10:41] And then finally, we're going to do this over and over again, right? So, we don't want every uh mage to have to go through the desert over and over again and and find their own way. We're going to pave a road that allows us to do this much much faster,
[10:57] build the freeway, and then we can use that car with brakes to get there in a safe fashion. So, first, we need security. How are we going to enable security? So, as this situation was evolving,
[11:13] it just so happened that we were adopting Mosaic AI Gateway. Not for security. We were being selfish. We had AWS Bedrock, we had Azure AI Foundry, we have all of this AI all over the place. We wanted to centralize it. So, the AI Gateway that Databricks provided, it
[11:30] answered that problem. And then, as the regulatory challenge evolved, how are we going to answer this? How are we going to track everything? Oh, wait, the gateway. It tracks every input, every output, creates inference tables stored in Delta. So, now we can say
[11:46] every decision, and we can go back, and we can audit how we're using AI. This also provides a lot of a lot of other benefits. We can put in rate limits, we can do routing, we can put in guardrails, so you can either ask questions about PHI, you cannot.
[12:04] One of the things in our industry, there's lots of things that are um not generally safe, but you may become a a licensed practitioner, right? So, as a therapist, you may be trained to talk about suicide and self-harm, and so on. But, we don't want everybody to do that.
[12:20] There's lots of stories coming out talking about people are going to AI as a therapist. We want to stop that. You should be able to use that in a controlled way with a licensed clinician, but don't do it without that.
[12:36] So, the AI gateway, it enables us to actually implement these guardrails and say this agent, it is trained in this area, so it can answer these things, but if it goes outside of that, it just won't even respond.
[12:53] Next, we need to explain what we're doing, right? So, we're going to have to produce lots of audits, we're going to have to produce duty of care, disclose where we're using AI. We need to track everything that we're doing. So, in order to do this, we need to capture how we're using AI.
[13:10] We need to assess every use of AI. We need to constantly monitor and see is the AI changing? And then, we need to be able to update our AI. So, how how can we actually do this?
[13:25] First, we're going to use MLflow. MLflow provides something called tracing. I'm sure a lot of you guys are familiar with this, but if you're not, a trace is hugely important. When you use AI, you just you put in an
[13:42] answer, you get a response. But that's not what's happening. You can see in the bottom left-hand corner, that's a trace. So you have an agent. Agent calls a sequence, the sequence calls a tool, that calls a lambda, that calls an agent, so on and so forth. So although
[13:58] it just feels like one in and one out, it's actually a chain of functions. And we need to have complete understandability on what's going on. We need a glass box, not a black box. So being able to use MLflow and tracing
[14:14] allows us to capture the fidelity of information that we need to have in order to respond to our regulatory challenge. Next, we need some way to know how are these agents actually working? How are they being leveraged? Are they
[14:30] being misused? But also, are they being effective? There was a MIT report that came out earlier this year that said 95% of companies have received no ROI on AI. They called it the AI gap. And the key finding in that report was
[14:48] these enterprises are not updating their agents. And the reason why they're doing that is they have no way to capture the signal. They build something in a lab, it's static, it works, gets out to production, and it falls over. So we
[15:03] need a way to actually get that signal and bring it back in. So MLflow provides human signal logging. Um so when you use the agent, you can actually attach you can put thumbs up, thumbs down, questions, answers, and
[15:20] that will go back into the trace as well. And then finally, we need to score. We need to So, as we are using these agents, we want to know what's the quality of the agent. You want to be to say, "Hey, is this
[15:36] hallucinating? Is it even answering on topic? Is it responding with too much information?" So, with MLflow scores, you can actually create these tests, and you can right-size them to your agent. You can create a deterministic test to
[15:52] say, "This response needs to be in this format." You can create ground truth. So, here's how I want my agent to respond. Here are factual information. Is it actually responding with the facts? And then you can pull in LLMs as
[16:07] a judge. So, if you have one model says one thing, another model says another, it's not agreed upon, this is not a good answer. This allows us to get to a test-driven development approach to actually build these solutions and have them approved,
[16:24] take that human signal logging. So, finally, on the top right, you'll see that's where we want to be. That is our goal. We can build a model. We assess it with the test and the ground truth that we have captured from the start. We have a group of people
[16:41] that help us develop this in the lab. We get into production. Then we start to get that human signal logging when it goes live. So, maybe with five people, it was amazing. A thousand people don't like it. And now we can actually see and understand that these agents are are not
[16:58] working in these specific ways, and this allows us to iterate and approve. So, finally, the last gift is repeatability. Again, MAGI, machine agentic governing intelligence,
[17:14] is a framework that provides one, guides and run books. So, these are actual instructions that tell you why you should do things. Is this important? Is it not? Secondly, templates. So, you know, 75% of your
[17:31] code is probably scaffolding that you have to do over and over and over again. Instead of having everybody repeat that, start from that baseline and just add in what's unique. Next, we have a shared utility library. So, as we get these rules and
[17:47] regulations, we have to have different types of reports. We can create a standard library that runs on top of Databricks to collect everything in a uniform way. And then when we get new things, we can update the library and everybody who's using Magi gets that new functionality.
[18:06] And then finally, Databricks MLflow, the AI gateway, all of these tools enable us to create these guardrails and security so that we can train our mages and have them operate in a safe way.
[18:22] I'm going to pass it over to Guniti, who's going to talk deeply about how this is working. Thanks, Mark. So, as what Mark said, this is the third gift of Magi, the repeatability at scale. This is where the magic becomes mechanical. It's how we make the bots
[18:39] safe, fast, and no team ever has to reinvent governance itself. The four uh the four to five building blocks we see as a foundation layer from the infrastructure moving towards data, vector store, vector embedding, and also looking at the full cycle of
[18:54] infrastructure to LLM data, prompt engineering, operation governance, which are phased so the teams could adopt it incrementally. On the right-hand side, you could also see the legend. We have done it in three different phases. We have matured from phase one to phase two and phase three for production itself.
[19:11] That's where you could think of of out of a example, if a team wants to onboard on this Magai framework, they just have an app that reuses this codebook templates, audit utility, which could takes weeks to re-implement this for a new project. Now, it just takes days to
[19:28] move forward. So, governance, you have to remember, is the governance that fails. We make the governance as the default path, so that the team could ship better and in spite of governance in spite of it. We are also looking forward to have
[19:44] repeatability as what that governance scale to it instead of slowing us down. And it sets the engine that actually run through these agents. Now, digging dive more into uh repeatability, that's where we have the
[19:59] agent runtime and orchestration. It's the hood under the Magai that turns an approved model into an governed multi-step agent itself. The four building blocks that we see here is agent runtime, which is powered by line graph or custom with execution
[20:15] context. We have tool gateways like MCP tools, agent identity, authorized access. Those are the kind of four pillars we see in governance right from identity, entrance, observability, and also guardrails, too. The one we see on the third, which is
[20:31] the agent blueprints, reusable patterns using super agents, document experts for your use case again and again within the different teams itself. And lastly, we have memory and context, so that we know we can build that semantic layer for using short versus long-term memory and
[20:48] shared context including the privacy control. This is all composable by design. Agents are assembled from those governed blocks, so teams ship new use cases without re-solving governance. And every call stays identity-bound, joined by one
[21:04] MLflow trace ID. We are also using human in the loop. Think it up of the risk tar control panel that we have created and put all the different use cases into three different categories: high, medium, low. For high and medium actions, that's
[21:21] where with human approval is required before the execution so that we could keep the autonomy inside the compliance boundaries. Everything we build here is emits signals. That's how we close the loop with logging and evaluation so that
[21:36] we could work on that high frequency context coming as a feedback which could be used an input for our workflows later on. This is the heart of the platform, the ML flow AI gateway, the single governed front door to every model we use.
[21:52] One endpoint and any model output. Your application only sees one unified governed observable integration point. The gateway routes to approved providers. The providers could be anyone, OpenAI, Anthropic, and so on. That's how we are maintaining the
[22:09] adaptability towards no vendor lock-in. That's how we're making our framework modular in the future and we don't have to reinvent this wheel again and again. The six AI gateway's capabilities that you see inside that box, each is pointing to the one gift of Magi. For
[22:25] example, on the usage, that's where we have the repeatability or explainability. The full external model, that's where we go to the repeatability using my different teams itself. And on the centralized account level governance, that's comes
[22:42] security. So, we have all the three Magi gifts of us, security, repeatability, explainability all in one box in this AI gateway. Why this? Why not a low-code tool? That has been the question we have been asked
[22:58] while we were building this. So, low-code tools doesn't give you the account level governance. It doesn't give you the full external model coverage or the audit trail that requires a regulated payer needs the govern gateways mandatory for starting point everything else built on.
[23:14] So, this is why we have this ML flow AI gateway our starting point and ending point for an end user to have a request in and response out. One governed endpoint to every model. That's what makes any model safety a platform promise rather than just a
[23:32] recommendation to be adapted moving forward. Here's the whole picture which is transactioning of all the components we have said into one big platform. One request flowing from left to right through different governed stages.
[23:47] The key stages here is identify and access looking at inferencing run through the governed agent. Feedback captures those traces, assess them, and govern closes a loop with audit, monitoring, and compliance reports. The whole flow is stitched together by
[24:05] one joint key, app ID which could be an application ID governed by like a user or a plat or a project that has been using this framework end-to-end plus the ML flow trace ID. The whole flow is stitched along the identity to inference to
[24:21] feedback to governance. Governance isn't step at the end. It's not a process processing step. It's a pre-processing steps. It will decide when the agent is chosen, the data it's touching before even moving the workflow end-to-end and
[24:37] executing it. It enforced at runtime at every stage which is exactly what regulators now require. One request that has been fully governed and running end-to-end, that's the gift of Magi we are proposing. Having the secure, repeatable, and explainable AI.
[24:56] Over to you, Mark. So, for that this slide, um this is anychat. anychat is the first major application that we built on top of Magi. Um essentially, it's just Libra Chat, right? I'm sure a lot of you guys are familiar with Libra. It's an open-source
[25:12] chat framework. Um we have other tools like Copilot. We've brought in uh enterprise chat GPT. A lot of these things created hard make uh make difficulties due to so much use around PHI and healthcare and so on.
[25:28] So, we want our AI use to go through Magi to the AI gateway because it captures everything much with much more fidelity and understanding what's going on. So, we built anychat here, and that taps in to one, the AI gateway to give
[25:44] us access to all of the LLMs. I think we have about 50 now. We're using AWS Bedrock, uh Azure AF AI foundry, and all the models Databricks provides. Plus, we have custom and open-source models that we host there as well. And then, it uses
[26:00] Magi. So, every user who is chatting, they uh have a payload get that gets attached to the trace to say this user is asking these questions. All of this then can flow in, and we can assess and audit and trace to see what people are
[26:16] doing and how are they using this tool. Next slide. Great. So, to wrap it all up then, I kind of give you an overview of everything that is inside of Magi. So, we have, as Mark just mentioned, a large collection of
[26:32] LLMs from a variety of different cloud sources, plus what ships with Databricks and open-source LLMs, all being exposed in the AI gateway, which lets us do guardrails, all of the logging and monitoring, uh rate limiting on LLMs, LLM routing.
[26:49] Of course, Databricks is It's a fantastic environment for serving up AI agents. So, uh we serve uh our agentic applications from Databricks. Uh we also are starting to use it for our MCP tool catalog. Uh the environment lets us do all of the
[27:05] operations required of an enterprise platform, including uh all availability and scalability, as well as as FinOps. Very excited about all of the cost controls that are now in Unity AI Gateway. Um and then as we talked about throughout this talk, the observability, evaluation, explainability, and
[27:22] importantly for us, auditability of everything that AI is is being used for on Magi is all built into the platform. And of course, uh integrate, you know, Databricks is also and was first uh first-class data platform. So, integration with all of Sentine's uh
[27:38] data applications to make all of that available to our our agentic applications. And so, without uh Magi, each team needs to go out and re-implement a whole bunch of guardrails and governance um that would be kind of
[27:53] cost-prohibitive to do at scale. And um in addition, they would the the governance process, if they had to do it kind of a special snowflake every time, would would take a long time. Like, we've gone through the governance process on one-off basis bases before
[28:09] Magi was present, and it it's quite uh a large effort. And moreover, there's just lots of infrastructure that would need to be rebuilt over and over, and uh might be incomplete, where they uh they might be using one tool set, another team is using a different tool set, and if they are talking to each other, or even better yet, using the
[28:25] same platform, um they would have a much broader tool set to draw from. And so, with Magi then, uh governance is inherited from the platform. Uh there's if you use the platform, you get a whole bunch of governance for free that you don't need to re-implement. You get a whole bunch of a head start on the templates, cookbooks, and utility
[28:42] libraries. And there's one place that that can govern any agentic application um that that's running on on the platform. And so I'd like to thank you all uh for your attention. We're We're very excited to present to you today and we do have some time for questions uh if you have
[28:58] any to address to us. Thanks.

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.