Building Bionic Supply Chain with Agentic AI on Databricks

Summary

Rivian deployed two production agentic applications — Nova for procurement negotiations and Sonar for material planning — built on a shared medallion architecture that unifies data from SAP, TMS, and real-time telemetry through Unity Catalog on Databricks.
The bionic supply chain philosophy augments human judgment with machine intelligence through a sense-diagnose-execute framework, with human gates on every agent decision to ensure oversight and prevent unchecked automation.
Rivian's recipe for success — govern before building, architect with specialized agents and centralized tools, and ship small to let users teach you — is presented as the practical bridge between stalling and scaling AI projects.

Building Bionic Supply Chain with Agentic AI on Databricks

Modern supply chains suffer from a visibility vacuum: material planners are stuck firefighting with fragmented data, while buyers enter negotiations blind with no real-time cost intelligence. Rivian transformed this by building a bionic supply chain on Databricks, combining sense-diagnose-execute orchestration with classical ML and generative AI. The philosophy is deliberate: augmenting human judgment with machine intelligence, not replacing it.
This talk walks through the complete blueprint. See how Rivian unified SAP, TMS, and real-time telemetry into a governed medallion architecture with Unity Catalog, deployed two production agentic applications (Nova for procurement negotiations and Sonar for material planning), and orchestrated prediction into action through Agent Bricks with human gates on every decision. Learn the recipe that bridges stalling vs scaling AI projects: govern before building, architect with specialized agents and centralized tools, ship small to let users teach you.

Chapters

FAQs

What is a bionic supply chain and how does Rivian implement it?

A bionic supply chain combines classical machine learning and generative AI with human judgment through a sense-diagnose-execute orchestration framework, moving from data signals to recommended decisions without replacing human oversight. Rivian built this on the Databricks Data and AI platform to augment material planners and procurement buyers, keeping human gates on every decision to prevent unchecked automation.

What are Nova and Sonar at Rivian?

Nova is Rivian's AI agent for procurement negotiations that provides buyers with real-time cost intelligence, while Sonar is a supply chain control tower agent for material planners dealing with fragmented data and firefighting loops. Both applications share a single architecture built on Databricks Agent Bricks, MLflow, and a governed medallion data foundation.

How does Rivian use Databricks Agent Bricks for supply chain orchestration?

Rivian uses Databricks Agent Bricks to orchestrate a primary coordination agent alongside specialized sub-agents, each with persona-specific knowledge bases covering different supply chain domains. This architecture, combined with human-in-the-loop gates on every decision, ensures that AI-generated procurement and planning recommendations are validated before any action is taken.

What data sources does Rivian unify for its supply chain AI?

Rivian ingests data from four enterprise systems — including SAP and TMS along with real-time telemetry — into a governed medallion architecture built on Unity Catalog within the Databricks Data and AI platform. This unified data foundation supports six machine learning domains that feed intelligence into both the Nova and Sonar production applications.

Full transcript

[00:08] Alrighty. Good afternoon, guys. Thank you for joining us today. Uh we're going to start with some quick intros so that uh you know, we we're not just faces that you guys are staring throughout the session. Right. So, uh I am Nikhil Pandey and joining with me is my colleague Colin Brasco.
[00:23] Uh we both work at Rubicon's Enterprise Data Science team uplifting data landscape and providing business with next generation tools and solutions year after year. Our charter is to embed AI into the core operating processes of the company.
[00:40] Everything that you're going to see today is a vision that's now a reality at Rubicon. Serving real users and solving real problems every single day. Over the next 30 minutes, we're going to walk you through what we've built, our
[00:55] experience, key decision driving factors, and most importantly, a blueprint that you can take back to your organization. Right. So, here's how we'll spend the next 40 minutes together. Our agenda, so it has eight quick stops. We'll start with a quick introduction
[01:11] about our company and our mission statement. From there, we'll talk the problem on hand and the Bionic solution. After that, we'll do a deep dive into our foundational architecture and the Databricks features that we've leveraged. Once we have clarity on the foundation,
[01:28] we'll switch gears and move on to machine learning and AI orchestration. Now, let's be honest here. It's AI world. No one wants hallucinations. So, couple of insights on how we monitor, evaluate, and keep improving. Right? Finally, we'll touch on the application
[01:44] layer where everything gets packaged together and delivered to our users. We'll conclude with takeaways, share a special recipe that you can take back with you. Q&A will be towards the end of the session. That will be our final pit stop.
[01:59] Right. So, let's get to know a little bit about Rivian and our mission statement. And I'm pretty sure many of you might have seen Rivian vehicles on the road. Right? Some of you might have even driven it. I'm looking at the folks in the front line. I personally own R1S and let me tell
[02:17] you, being behind those wheels is an incredible experience. If you haven't experienced it yet, it's not too late. Do visit our booth at the expo, you know, check out our vehicles and book your demo drive today. Now, as passionate as and proud we are
[02:32] of our EV lineup, we are equally proud of our software platform and our AI for division. So, from our stackable intelligence unified architecture to the custom silicon chips that power it. Right? Our goal is scaling global manufacturing
[02:48] systems with AI-powered robotics and agentic frameworks that bridge digital planning and physical reality. Huge words, but aspirational, right? Which got us thinking, what if we have to run supply chain at lightning speed, too? We got to harness the, you know, power
[03:05] of AI. So, now imagine this. What if your supply chain could sense disruption before it happens, diagnose root cause across systems, and recover cost autonomously, all on a single governed platform?
[03:20] Introducing the Bionic Supply Chain Vision. So, sense, diagnose, execute on one platform. Hold on to those four words. But, you know, let me tell you how this vision came came to life, you know, by walking you through the crisis that we
[03:37] were buried under and the battles that we had to fight every single day. So, two personas, two parallel crises, same villain. So, on one hand, we have our material planners, you know, buried under fragmented data and low-value alerts
[03:52] from the systems, critical alerts get completely lost in all this noise. The impact is that the teams are continuously stuck in a firefighting loop. Right? They cannot do any forward planning. So, anything that is high risk goes
[04:08] undetected until it truly becomes a costly crisis. That's the firefighter's loop. On the other hand, we have our buyers entering supplier negotiations completely blind. No real-time should cost intelligence, cost benchmark. Basically seeding the
[04:24] information advantage every single time. That's the margin leakage. The impact, margins impossible to defend if you cannot challenge the supplier quote with confidence. Right? So, what happens is sub-optimal deals kind of start compounding together
[04:42] and then kind of scale up the unrecovered cost at a very huge amount. That's the visibility vacuum. So, you know, we we kept asking ourselves, "How do we resolve this? What's the antidote?" And that's where the Bionic Vision came to life.
[04:57] So, you must be wondering, "What exactly is this Bionic Brain?" So, uh kind of think about like three steps. Sense, diagnose, and execute. Sense, like our eyes, continuously monitoring the network state,
[05:14] and you know, basically ingesting data streams from our functional systems. Then we have diagnose, which is our brain. Right? So, the machine learning layer detecting hidden patterns and AI orchestrator kind of fine-tuning, trying
[05:29] to synthesize, and building, you know, cross-system context. Then we have the execute, which is basically the arm. The system surfaces options, draft actions, and routes to work. The human is always in the you always in the loop confirming those
[05:44] actions and, you know, passing it through the external systems. Now, the word bionic here is deliberate. You know, this does not mean autonomous. It does not mean replacing the humans. It basically means combining the machine intelligence of AI and uh you know, the
[06:02] judgments that only humans can provide. Um being honest, like philosophy does not, you know, cut it and build systems. So, uh let me walk you through the actual principles uh that help us drive the entire architecture. We like to call them the non-negotiables.
[06:19] So, five driving factors, each one you know, crucially important than the other, bridging the gap to success. On the first line, we have a unified platform. We chose Databricks end to end. We said no to multiple databases, no tools walls. We didn't want like random app
[06:35] hosting servers or machine learning stacks. Everything in in a single perimeter, all governed. The second, we wanted to build persona-driven interfaces around actual workflows. We didn't just build that, you know, generic AI tool and ask the users to adapt.
[06:50] We actually, you know, adapted to their personas and built around it. Third, we wanted AI agents to only act on governed and trusted data. Very important. So, if the data does not exist in the Unity Catalog, basically, the agent
[07:05] says, "I don't know anything." Right? Then the fourth one, every AI action is confirmed by the human before it lands to the external system. So, basically, the agent wraps, the human ships. That's the bionic line we never intend to cross.
[07:21] And finally, the rapid deployments. Databricks bundles, kind of, you know, pushing it through in a single command, and everything going in from merge to production in minutes with full governance. So, now, with those principles kind of locked in, let me show you the
[07:38] architecture from raw source data to a fully functional persona-based agentic application. Right. So, it starts with your raw sources and the right ingestion patterns to land your data into the unified platform. Then comes the data foundation layer
[07:54] where everything all the heavy lifting is done. Your ETL, governance, curation. Basically, you can think of it like a fuel for everything downstream. Then we have the machine learning segment. You have your feature engineering, building your models, predictive evaluation, anything
[08:09] reinforced learning. Right? And then you can also build your serving endpoints for those machine learning models. In parallel, we have our AI orchestrator. So, primary agents uh coordinating with sub-agents underneath it.
[08:25] Think of it like one brain with many specialties. And then finally, we have the application layer uh which kind of, you know, packs it all together and delivers to our user. We use lake base for our current and metadata and uh dabs to kind of push it
[08:41] through all environments with a single command. So, this is our blueprint. You know, same backbone. You give us any problem, any persona. This can solve it. And the proof is actually in the pudding. We use the exact same blueprint to
[08:57] deliver not just one but two production-level applications. That's right. Two applications, two personas, one single architecture. Let me introduce them to you. So, on one hand, we have our negotiation optimizer and value accelerator,
[09:12] Nova. And on the other, a supplier observation for notification and risk, Sona. So, on the left, Nova, it's it's our procurement negotiation engine. You know, it gives buyers the data advantage by providing cost benchmarks,
[09:28] AI-generated negotiation playbooks, margin leakage detection, and supplier price parity. This helps recover uncovered costs and overall help us reduce the bomb cost at scale for our vehicles. I'm going to pass it over to Colin for Sonar.
[09:44] Thanks, Nikhil. So, on the right we have Sonar. This is our material planning and control tower or resource center. We combine SAP, TMS, and Pier 1 system data in the one unified platform. So, material planners are not toggling between multiple screens to understand what's at risk.
[10:01] We then run a a predict, triage, resolve loop that shifts the material planners from a reactive firefighting to being proactive in orchestrating resolution. The idea is that both applications blend classical machine learning and generative AI together on one unified
[10:19] lakehouse. That shared architecture isn't just efficient. It means that every governance decision is only made once, and it gets cascaded down to both applications automatically. Now that you understand what we've built, let's talk about how getting the most out of the next 30 minutes.
[10:38] So, we don't want this to be a case study. We want this to be a repeatable blueprint. So, here are five things that we want you to take home. First is the end-on-end flow. You should be able to draw a straight line from your source data, through your catalog, through the machine learning layer, your agentic layer, your lake base, and ultimately ending up in your application layer.
[10:55] Next is the repeatable blueprint. So, what we're going to show you this cycle is not supply chain specific. Any persona-driven problem can be solved with the same approach of reiterating, rebuilding, and deploying. Next is the Unity Catalog as a contract.
[11:10] For data, models, and agents, only interact to governed catalog assets. That's the principle that makes AI output auditable rather than just impressive. Next is we have our Databricks AI tool chain in action. This is the data Agent Bricks,
[11:25] LangChain, MLflow, and Databricks apps all demonstrated in context rather than just on a slide. And finally, the maturity arc. We'll trace the journey from descriptive dashboards to predictive models to fully autonomous applications. But before we get to there, we got to
[11:40] start at the bottom of the stack, the foundation that everything depends on. So before the AI, before the agents, before the apps, there's the platform. And the decisions we make here determine everything. So part one is the foundation.
[11:56] I want to spend a couple minutes on the platform because the choices we make here are not incidental, they're load-bearing. So first up, we have the data infrastructure. To build trust, we rely on three interconnected pillars that stack sequentially. First is we have data lake
[12:12] and data warehousing. This is our reliability reliability foundation. Because it's asset compliant, the read and writes are perfectly consistent. If an AI agent has an makes an unexpected decision, we can have Delta time travel look back at the exact time in the data that was existing
[12:29] when it made that decision. We use uh Photon to make sure our our queries are lightning fast, ensuring the data layer never gets hung waiting for data. Next up, we have our data uh our medallion pipeline. Our source data enters raw and messy at the bronze
[12:44] layer, gets filtered and structured in silver, and ultimately governed in our gold layer. That is the only layer that is considered our canonical source of truth. And this is the And this progression is not optional. This is our strict contract. And our AI AI agents
[13:00] are only permitted to read from gold data. Finally, the Unity Catalog. This is our governance engine that handles everything, holding it all together, tracing lineage from source to gold, governing access controls, and enforcing row and column-level security.
[13:15] This creates that trust boundary that surrounds every one of our AI agents. With a rock-solid, highly governed data data layer established, we can now layer in the actual AI and the model serving architecture on top of it. So, let's take a look at that.
[13:31] So, now that we have the trusted data layer, we can unleash the AI. But, we don't want our engineers spending months developing developing infrastructure just to run a model. We want to deploy fast. We want to scale instantly. And we want to see exactly what's happening behind the AI layer.
[13:48] This is how we've interpreted the Databricks offerings that turn our trusted data in production-ready AI. So, Agent Brick gives us a pre-built agent pattern with auto-scaling built in. Every AI agent is a REST endpoint. When demand spikes, infrastructure scales. We wrote zero infrastructure
[14:04] code to make that happen. MLflow is how we see what's happening at the AI layer. Every agent call traced, every prompt version logged exactly next to the model version. So, when behavior changes, we know exactly why. And nothing touches production data until it's proven
[14:21] against a challenger data set. And finally, Databricks and data or data apps Databricks apps and lake base is where the application live. React and fast API deployed inside the security perimeter. No external hosting, no data leaving the
[14:37] the platform. Every deployment is repeatable, version controlled, and triggered by a single command. So, now that we have our our our secure data layer and we've got our scalable AI tools, how do they actually talk to one another in the production layer?
[14:53] So, let's take a step and look at the blueprint on how we get everything to work together. So, the building blocks are set. How do we actually get them to communicate? That's one of the hardest challenges in doing this architecture. So, I want to walk you through some of the architectural decisions we made. How the
[15:08] data moves from system, how it gets structured at each layer, and how that structure makes it to the AI layer. In the next several slides, we'll look at the raw source data and the governed gold layer that the agents can query with confidence. But ultimately, it starts with ingestion. Getting the right data to the
[15:25] right place at the right time. Before AI models can do anything smart, they need data they can actually trust. We ingest data from four distinct areas. We have our heavy operational data in SAP and TMS, real-time ordering and telemetry data in
[15:42] Dynamo DB and S3, microservices going through Postgres, and what we've also started ingesting are what we call our hidden signals. These are the contextual data from Workday, Slack, Jira, um and Drive. This is the organizational
[15:57] knowledge that usually never makes it into the AI model, but provides a crucial context for the AI model. And if you listen to yesterday's keynote and today's keynote, you know that context is the next frontier for for AI. So, to move this data, we're using a hybrid approach. For standard uh
[16:14] workloads, we're using Fivetran to manage the heavy lifting. For real-time feeds, we use PySpark streaming. And crucially, everything managed is managed via code by um uh by by Dabs. And we route everything to the isolation an isolated source catalog, and this ensures that the
[16:31] source data is partitioned from production data. But simply landing the data is not enough. It has to earn its way into a layer that the AI agent can trust and query with confidence. So, I'm going to read this verbatim because I think it's really important to say out loud. So,
[16:47] agents and models are only as trustworthy as the data they read. Without a governed semantic layer, every AI output is an opinion. With Unity Catalog, every AI output is now an audible fact. This is the center of our architecture. Organizations that build AI in ungoverned data watch
[17:04] adoption fail because you business users won't actually act on recommendations they can't verify. Governed data is the foundation for AI that people actually trust. Now Now got our governed data, we can start talking about our intelligence layer. This is the part that makes everything
[17:20] worth building. So, part three is now intelligence. The platform is set, the data is governed and trusted. Now, we can look at how classical machine learning and GenAI work together to produce what we call the bionic behaviors. Sensing disruptions before the material planners or buyers are
[17:36] aware of them, diagnosing root cause uh between systems that don't naturally speak to one another, and executing recovery autonomously with humans always staying in the loop where it matters the most. We've identified six machine learning domains, and we're going to walk through
[17:52] those now. So, each one handles a different part of the problem from catching something wrong to knowing what to do about it, and to getting smarter every time that uh a user interacts with it. So, first up, we have anomaly detection.
[18:07] We might have a shipment that's been sitting in port for 3 days longer than it should, and no one has noticed yet. The anomaly detection does, though. It flags the unusual dwell time, the quality quantity mismatches, or possibly the ATP swings automatically before anyone has to go has to escalate
[18:23] anything. That exception surfaces, and the material planner can act upon it. We have forecasting. The material planner needs to know exactly when a part is going to arrive that might be production critical. Instead of providing a date time that's either right or wrong, they get a probability.
[18:40] This is a confidence band based on real-time carrier data and SCP history that they can that they can test their position for the disruption before it happens, not after it. And then, ranking and triage. The material planners open up their application, and they see 40 critical
[18:56] parts. They don't know where to start. Ranking and triage does a machine learning uh rank and eight or machine learning scored agent rank system that tells the material planner exactly which ones to action first. And most importantly, it tells them why it's at the top of the
[19:12] list, not just that it is. So, the next three are on the next slide are kind of where it gets a little bit more interesting. So, the first three capabilities were all about awareness. Knowing what's happening, what's likely to happen, and where to focus.
[19:28] These three are about what to do with that awareness. How does the system help you move, and how does it get better as you do? So, we have next best action. So, we have a disruption that hits, the risk flag was there, but instead of the material planner staring at the screen wondering what to do next, the system
[19:44] recommends a specific move. Could be an expedite, could be a reschedule, a substitute, or an escalate. And this is all based on historical information of what's been successful in the past. And as always, the human the human confirms it before it actually
[20:00] happens. We have supplier profiling. We might have a a senior material planner that leaves the team. This usually means years of institutional knowledge walks out with them. Who's good, who's rough to work with, and how to handle each one of the suppliers. Supplier profiling
[20:16] captures all this from from Jira, from messages, from comments, confluence, and structures it into a profile that the entire team can leverage. And this makes sure that institutional knowledge can survive employee turnover. And last, but certainly not least, is we
[20:32] have calibration. So, we might have a system our our agentic system recommends a solution, and the material planner overrides it. That signal doesn't disappear. It becomes a training data set for the next time. So, every confirmation, every override, every every disagreement makes
[20:48] the model sharper. The system gets more accurate the more the teams use it, and that that emphasis compounds over time. So, now let me show you how these three domains or how these domains actually show up in the applications that we referenced earlier.
[21:09] So, in Nova, the cost prediction model takes labor indices, labor or material indices, labor rates, region, and complexity and outputs what the fair price should be. When the supplier quote comes in at or above a an established threshold, this automatically triggers the negotiation
[21:26] agent to build a data a data-backed challenger strategy. This means the buyer goes into the negotiation knowing exactly what the price should be. In Sonar, the disruption the the disruption model scores every part supplier combination
[21:42] using lead time history, quality signals, and delivery telemetry. When that score crosses specific threshold, that item goes straight into the agent's priority queue for triage. The point is that these aren't solutions that sit alone in a dashboard somewhere.
[21:58] The model output is the trigger, and the agent acts upon it. That tight coupling between prediction and action is exactly what makes the system feel intelligent rather than just automated. Machine learning tells you what's happened. AI tells you what to do about it. And here's how we got there.
[22:18] So this is our AI journey. We didn't start over you know we didn't get here overnight, and we didn't start with agents. We started with Genie Chat. Natural language queries over governed data, no SQL required. This and this was generally helpful for data exploration. But it lacked it couldn't take action.
[22:34] It lacked context. And it had no memory between the sessions. And it treated the procurement buyer and a material planner in the exact same manner. Our users outgrew this within a couple months. So we evolved. Today, we've adopted a hierarchical agent system with
[22:51] a primary orchestration agent routing to domain specialist, persona-aware knowledge bases in lake base, and a closed loop that feeds agent outcomes back into the machine learning models. The lesson isn't that Genie chat was wrong. It was the exact right starting
[23:07] place. The lesson is that your architecture should follow what your users actually need, not what's technically impressive. Start simple, listen to your users, and build towards the complexity that the problem earns. Now, let me show you the agent layer that and how that's actually structured.
[23:24] Like I'd mentioned, we use a primary orchestration plus specialized sub agent architecture. The primary agent has one job and that's routing. It figures out what you're asking, it remembers the conversations, and it hands off to the right specialist. From the application side, there's one
[23:40] endpoint. Your users have no idea that there's four more agents on the other side. Those four specialists or more have exactly one domain. It could be variance analysis, uh inventory risk, expedited evaluation, or drafting communication. And each one
[23:57] is isolated. Means if the the expedited the expedited evaluation fails, the inventory risk model can continue running. And as always, every tool goes through the same governed gold layer or controlled external API.
[24:12] Nothing reaches outside the perimeter without going through the right channels. So, shipping is step one. Improving after you ship is equally as important. So, we've identified two parts of that make that help make the system healthy
[24:27] after it ships. First is we have observability. MLFlow traces every tool call or every agent call and every tool invocation, not just the model, but the full orchestration chain. Prompt versions and model versions log together, so when you when the behavior
[24:43] changes, you can do an audit and see exactly what happened. And dashboards alert you the moment the quality starts to shift, usually before your users tend to notice. And second, we have the improvement loop. Planners and buyers give feedback directly in the applications. AI judges
[24:59] evaluate responses against quality rubric automatically faster than any human can any human human reviewer could cover. Every change has to pass a gold standard before it goes anywhere near production data and we use AB testing with live
[25:16] traffic data to make sure we're actually moving the needle. As always, if we're not measuring it, we're not managing it. Right. Thanks, Colin. Uh now that we know how the brain is wired, let's talk about how we made it more powerful. Right, two
[25:32] things, memory and its reach. Think of it like a seasoned uh coach or a leader with deep pool of knowledge. So, we built a curated knowledge base for each of our personas. We're starting with workflows, scenarios, tribal knowledge, everything baked in.
[25:49] That's what, you know, turned our agents from a regular agent to a subject matter or like we like to call them persona specific coaches. And to keep that knowledge growing, we keep learning from ongoing conversations and use Lake Base as our memory store.
[26:06] The same memory store holds conversation history. So, now the context follows from session to session. Now, let's talk about reach. For the reach of each agent, we built a centralized tool library. Now, fetching tools is like plug and play.
[26:21] Uh we don't have to, you know, maintain that overhead of creating and maintaining different tool stack for, you know, different sub agents. With that, uh we complete all the building blocks of our intelligence layer. Let's get to know how we package it all together.
[26:38] So, it happens all in the application layer, right? We walked the foundation. You've seen the wiring of the brain. We have talked about how to keep everything honest. Now, let's see how to package it, build it, and hand it to our users. It starts with the application stack.
[26:54] One bundle, one command deploying to all three environments, right? That's the goal, and we didn't get it the first day. Uh we took a phased approach. Phase one was basically using standard Databricks templates, which are like Streamlit and Dash. I'll
[27:10] say good for, you know, fast prototyping or actually, you know, shortcuts for a working demo. But they come with their own limitations. And when you want your users to be in the applications day in and day out, you want something that is a giant. Something that is creative and that can
[27:26] be shaped to their needs. So, we rebuilt it. In phase two, we use React as our front end and fast APIs calling our AI serving endpoints and Unity Catalog directly. Plotly and Tailwind, you know, for the
[27:42] powering the design system and Lakehouse for holding the app state. Now, deployment at speed plays just as crucial role. Databricks bundles paired with GitLab CI/CD make that possible. One bundle deploying to all environments
[27:58] with one single command. Now, we're talking about seamless flow from merge request to review, human approvals, auto deploy within minutes. You know, no external databases or no external app hosting servers. The net effect, merge to production in
[28:14] minutes. Right? The governance that is baked in, not bolted on. So, we didn't trade compliance for speed. We got them both. We've walked through how it's built. Now, let's take a sneak peek, you know, when our buyers and planners actually
[28:30] log into the application, what do they actually see? So, introducing Nova, our negotiation procurement engine. First, the personal landing page. This is where the persona curated AI-driven highlights are showcased at the top.
[28:46] The buyer logs in and the system has already triage showcasing critical alerts, highlights, and the agenda for the day. Then we have our supplier insights portraying risk, performance, uh financial health, or supplier profile.
[29:02] Now you don't have to, you know, click through multiple systems to assess one single supplier. It's in a single view. Then the cost DNA breakdown providing cost benchmarks, variance detections, and savings opportunities. After all, knowledge is power. These are
[29:17] the cost insights that going to make impact and, you know, actually help close the real deal. Finally, uh sorry, fourth, the negotiation playbooks. AI-generated strategies, leverage points, something uh like a almost real-time
[29:33] cost intel, which are provided to the buyers. With this information, the buyers actually walk in with a strategy, not gut. And finally, the Q&A buddy. You know, persistent chat history that becomes buyers' personal context.
[29:48] The agent already knows the last conversation and builds on top of it. So the context compounds. It does not reset every time when you change the chat. You guys remember the visibility vacuum? You know, you know, suppliers going in blind in negotiations, margin leakage
[30:04] deal after deal. Nova is the antidote. So different personas, same backbone, and you can see the pattern repeat itself. This is Sonar, our supply chain risk uh control tower for material planners.
[30:21] So instead of jumping between SAP, TMS, spreadsheets, and other peer source systems, there's one screen that answers three of the most important questions for material planners. What's at risk? What's in motion? And what should we do next?
[30:39] On the left, we have our four main capabilities. First being the production risk monitoring. So, this fuses ERP, MRP, and inbound logistics data and gives us a shipment map that shows every in-transit shipment color-coded yellow, green, red based on part and timing risk.
[30:54] Next, we have our priority queue. This is our machine learning scored, agent ranked uh list. So, buyers work on the hot or the material planners work on the highest impact shortage first, not just who's ever shouting the loudest. Next is we have our autonomous agents
[31:10] that follow the predict, triage, resolve loop. Assembling context, surfacing options, and routing the work. And fourth, we have our closed-loop write-back system. When the material planners confirm an action, Sonar agents can update that source system
[31:26] automatically. The idea is to sense, prioritize, act on one governed platform. With that one slide to bring it all together. Uh this is the same blueprint that we sketched for you at the very beginning of the presentation.
[31:42] Just now, it every box has a story behind it. So, starting on the left, we have our raw source data, then our data foundation layer, basically converting everything to a single source truth uh single source of truth. Then the machine learning models kind of ingesting that single source and helping
[31:58] us predict uh predict, evaluate, and overall kind of building models. Then AI orchestrator uh you know, kind of coordinating with those sub-agents and uh you know, getting traced with uh ML flows in the background. And finally,
[32:14] the application layer, packing it all together and delivering to the users. Everything in single parameter and governed. What started as a blueprint 25 minutes ago is now a production-grade application. The diagram didn't change. Everything
[32:30] underneath it hopefully changed your lives. So, how did we actually get to this stage? So, we want to leave you with a recipe that worked for us. So, if you take a picture of one slide this entire presentation, that let's make it this one.
[32:45] We We have three segments and three rules. This is the difference between AI projects that ship and AI projects that stall. First, govern what you or govern before you build. Unity catalog, gold layer, access policies all have to exist
[33:00] before you write a single line of AI code. Building on ungoverned data, you don't just have a data problem, you have an AI problem. So, we make sure that we do not skip this step. All right, second is the agent architecture. Primary orchestrator plus specialized sub agents with centralized
[33:16] tool calling against govern data. Structured outputs that applications can parse deterministically. Human gates on every single action. This is the AI architecture that can scale. And third, ship small and let the users
[33:32] teach you. One command deploys, one persona, one use case. Every action a user takes becomes a training signal. Prove that the loop works and then iterate. We've watched plenty of AI projects stall and almost every single time we can point back and look at one of these
[33:48] three pillars that was skipped. All right, so final takeaways. We started 30 minutes ago with a question, right? What if your supply chain could sense disruptions before it happened? It recovered uh sorry, diagnosed root cause across the system and you know, recover
[34:05] the cost autonomously all on a single govern platform. So, the answer is Bionic Vision. All right, every supply chain runs on decisions. The what to expedite, who to trust, when to escalate. All these questions are what decisions
[34:20] are made of. Most of the teams, these decisions are slow and manual and only good as the person making them. The Bionic Supply Chain changes that. It drives on four pillars. Predict before it happens. Prescribe the right action. Deliver it
[34:37] to the right user. And finally, learn from every intervention so the next decision is better than the last. So we tend to think we have to boil the ocean to see those results. We don't. We've identified five steps within the playbook to help
[34:53] drive that see those results. You know, we got to instrument our data, build high trust models, add guardrails only where appropriate, orchestrate our agents, and close the loop. In our industry, 12 months is a lifetime. So the teams that start building with this framework today are
[35:10] the ones that are going to have the compounding interest over time. All right, click the wrong button. So with that, we'll open up for questions if you would like any.

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.