Sponsored by: Boomi | Action Is the New Insight: Agentic Workflows in Practice

Summary

Industry survey data cited in this video finds that 75% of executives say their AI adoption is more for show than real, 48% report disappointment, and 56% say AI adoption is actively tearing their organization apart.
Moving from insights to action requires transitioning from static dashboards to agentic workflows that combine golden data, governance, and security with deterministic and LLM-based steps in the correct sequence.
Production-grade agentic workflows depend on auditability — tracing every agent decision and tool call — and careful management of token costs and agent loop explosion risks that can erode the value of automation.

Chapters

FAQs

Why do enterprise AI programs disappoint and what is the fix?

A survey of 1,200 executives cited in this video found that 75% said their AI adoption was more for show than real, and 48% reported disappointment with results. The fix is moving beyond dashboards to agentic workflows that trigger real actions — combining clean data, governance guardrails, and well-designed automation that closes the loop between insight and execution.

What is the dashboard problem in enterprise AI?

Dashboards surface KPIs and color-code problems but still require a human to notice the signal, investigate the cause, and manually take action — a loop that breaks down in practice as data volume and decision frequency increase. This video argues that the real value of AI lies in eliminating that gap by designing workflows where agents act on data directly.

What does human governance at machine speed mean?

Human governance at machine speed means establishing the policies, approval workflows, and accountability structures that allow AI agents to act autonomously within defined limits, without requiring a human to review every action. This video explains that the goal is not to remove human judgment but to encode it into the system so it operates consistently and at scale.

How should organizations mix deterministic and LLM steps in agentic workflows?

Deterministic steps handle tasks with clear rules and predictable outputs — such as data retrieval, conditional routing, and formatted outputs — while LLM steps are best suited to understanding intent, generating reasoning, and handling ambiguous inputs. Mixing them incorrectly is a common failure mode; this video emphasizes that each step type must be assigned to the work it is actually suited for to avoid compounding errors.

Full transcript

[00:08] Thinking most of us are here, um we can go ahead and get started. Ryder.com uh surveyed about 1,200 executives about their data and AI
[00:21] um adoption. So, it's a stat that you probably heard before, but 75% of the people who responded said that their AI adoption was yeah, more for show than for real.
[00:34] And that same study is pretty interesting. Um 50 uh no, 48% of the respondents said that their AI adoption was disappointing. And 56% of those respondents, same same
[00:48] group, 56% of them said that their AI adoption was actively tearing their company apart. Which but so if I'm doing the math right, 1,200 people, there was about an overlap
[01:00] there, so at least 72 people said that their AI adoption was tearing their company apart, but they weren't disappointed about that. So, kind of a fun survey. Um
[01:12] I'm I'm Travis Price. I lead field engineering for Boomi, and I'm going to try to make this fun today. I'm going to try to make it interesting, um but I'm also going to try to make it valuable for the next half hour or so.
[01:25] Hopefully, you get something, some little piece of information that you can take back home with you, some ideas of something that you can go work on to help drive your AI and help put something new into production. That's the goal.
[01:37] Um how many of you have actually built a dashboard? All right, good. I've built a lot of dashboards. Um most of the dashboards I built followed the same pattern. You would
[01:50] have a visual that surfaced the KPIs, and if something was off or not quite within range, you'd color code it red. So, whoever was looking at the dashboard could say, "Oh my god, that's red. Why is that red? I've got to find out why
[02:02] that's red." So, they would click it and it would drill deeper into the dashboard where they could explore the data. And maybe they had some widget where they could do some dragging and dropping and explore the data even further and they would find out why that thing was red
[02:14] that wasn't supposed to be red. And then they could, in theory, go do something about that, right? Ultimately, we're giving them the tool. We're surfacing the data. So, once they find out what's really going on that's
[02:26] causing this problem, they can go fix it. Okay. How many of you actually stopped people using these dashboards? Or how many of you were disappointed by this the that the usage wasn't quite as high as you
[02:39] thought? Right? Yeah. I I I saw that a lot. Like you built these dashboards, you thought they were so cool, um but people didn't really use them as much as you thought and you had to keep reminding them, "Hey, that's in the dashboard. Go back to the dashboard."
[02:51] And something was just kind of missing there. And I think it's because, ultimately, as soon as you put the data in that dashboard, it's old, right? And data at rest is basically just storage. Data in
[03:03] motion, that's where the magic is, right? And that's what we'll be on what we'll be on to talk about here when we talk about Boomi is data in motion. Um so, imagine if those dashboards were smarter, right? Imagine if those dashboards could take that red metric,
[03:17] automatically do the analysis and figure out why that thing was red that wasn't supposed to be red, and then go do something to fix it. You know, go initiate a communication or go update another system or go contact a supplier
[03:30] or go do something else. Go take action to actually make that change. And that's kind of where we're at. Um a lot of our executives had have had a title change in the last year or so, right? A lot of CDOs are now CD AIOs.
[03:46] So, they're responsible not just for the data strategy of their organization, but also for the AI initiatives and making those work because there's such a close alignment there, right? So, we're not today.
[03:58] We're also going to talk about ROI. And in this in this instance, we mean more than just return on investment. I mean return on intelligence, right? Return on those insights. Um return on our individuals, return on
[04:10] our people, right? ROI is something we want to make sure we're delivering in all of our projects. So, we're going to cover three things. Um first, we're going to review the the current mandate and identify why the
[04:22] current system might be broken. We're going to talk about some patterns that do work, uh some proven patterns of of what a an agentic workflow would look like. And then, um using some financial reporting examples, we'll talk about
[04:35] something that actually does work in production, something that's proven. Ready? So, we're moving from this age of digital transformation to agentic transformation, right?
[04:50] Well, I think we've probably all heard that. We're probably all caught up in the middle of it. But what's preventing a lot of us from getting there is that we're designing our governance that's for humans.
[05:02] And now our human-based governance is being applied to machine speed, right? So, we have agents that are doing things similar to how people would do them, but they're doing them a heck of a
[05:14] lot faster, and our current governance frameworks don't quite keep up. So, think about even something like a like a financial close, right? You every quarter every quarter you're running the numbers and you're making sure things
[05:26] make sense. Well, that works because it's operating at human speed, right? Humans are supplying that data, humans are doing those actions. We can, you know, do these checkpoints every every
[05:39] quarter. We can do monthly um check-ins to validate that we're in compliance. We can do semi-annual data quality checks to make sure our data all makes sense. All of that works because we're still
[05:52] operating at pretty much human speed, right? Those are human processes and human speed. Now, when we start thinking this for agents, agents are doing things much faster. They're making thousands of decisions per second. They're taking thousands of
[06:04] actions per second. Um if there's a uh number that's not quite right, that gets published in a report, no big deal, right? It will It'll be caught in the review. It's embarrassing maybe, but we can fix
[06:16] it, right? And we can publish the updated report. But if that same number is being read by a thousand agents, and those agents are all doing things based on what they found that number to mean, uh then we
[06:28] have more of a problem. So, this is really transforming kind of how we think about things, right? The goal is to not slow down our agentic development. We want to empower people to do this. We
[06:40] want to make sure they're doing it in a way that is safe, in a way that scales, and in a way that's giving us the right answer. So, governance becomes really important. Governance needs to be baked in from the very beginning. Um
[06:52] governance is not something that we're applying at the end. We need to design it into the solution along the way, right? And that's going to be critical because data is going to be the the fuel that drives these agents, and we need
[07:04] the governance on that data too to make sure that the agents are using things that the numbers that are trusted, verified, and accurate, so they'll get accurate results. Let's look at the landscape.
[07:16] Um most of you, cuz the average organization has about 360 different applications in production. They manage about 10,000 different APIs.
[07:29] And they manage about a thousand different data sources. That's a lot by itself. But it's becoming even more and more complex. If you believe Gartner here, um in the next couple of years, the amount of agents in production is going
[07:42] to explode to 150,000 in your average Fortune 500. We're 150,000 agents. Right now, it sits at about 15. So, that's a 10,000 times increase. That's a
[07:54] 10,000-fold jump in scale just over the next couple of years. How are we going to be able to manage that explosion? Right? We're not going to slow down. We're not going to tell our people to stop building agents and stop trying to
[08:07] innovate and stop putting things into production. We have to make sure we put the right governance around it so we can empower them to do these things. We can empower them to become more productive. We can empower them to automate a lot of these
[08:19] manual processes. But, in order to do that, we need to make sure we're giving them trusted data. Let's make sure we're talking about thing. Um you know, you think of like traditional
[08:32] AI like generative AI being very conversational, right? The human is initiating something, right? Initiating a prompt to the AI, to the LLM. The AI thinks for a little bit and then
[08:45] produces a response or it does what the human told it to do. The human reviews that and then the human provides another instruction and the agent goes and and performs that instruction, right? Or executes that next task. And this back
[08:58] and forth keeps the human in the loop. So, human's kind of there governing the whole process. Well, with agentic AI, that's not exactly what happens, right? Um there's not a human necessarily initiating this. Instead, it
[09:11] could be some kind of a business event, a transaction that's po- or something else. Some event causes the agent to go start doing its work. And then the agent has to access multiple systems. It can invoke different tools,
[09:25] so it can call different APIs into our systems within our organization. Um it can query different databases within our organization. It can even, you know, produce updates in some ways. It can publish new transactions. It's doing all
[09:37] this work kind of on its own. There's no human necessary, right? A human doesn't need to be in the loop. So, if there's not a human there, where is the agent getting its instruction?
[09:51] I'm going to really beat this point home. From the data, right? It's getting its instructions from the data. It's looking at the data. It's looking at the resources it has available, and it's figuring out what to do next. All of that's happening kind of by behind the
[10:03] scenes automated without a human having to be there. Um we still want to observe it. We still want to monitor it, and we'll talk about that. But, all these things can happen without human intervention.
[10:15] So, data. Data's pretty important. Um let's talk about kind of how we got here. And uh I know most of you probably lived through this. Um but, over the last decade, we've seen
[10:27] some change. Uh we've moved from ETL to ELT. Our data location has changed, too. Most of our databases have moved from their on-premises location into the cloud somewhere.
[10:39] Um and the format of that data has changed as well. We've moved from more rigid data warehouses with very well-defined dimensional models to more flexible data lakehouses that also can handle unstructured data, right? And
[10:52] tools like Databricks and other technologies have unlocked that for us, right? We've been able to separate compute from storage, so we can scale much much greater than we thought we ever could, right? All of that has been
[11:05] unlocked just as as as our technology has evolved. We're able to store more data. We're able to do more with that data. And now, we have agents that need access to that data. So, the agentic AI that we're building and we're putting
[11:18] into production needs to be able to read from those modern data stacks. But, they're also building those data stacks. You know,
[11:30] I saw a lot of my customers like building automated data pipelines using AI because it would they were able to automate a lot of the painful manual processes they had in place. So, agents can do a lot of that for us today. They
[11:42] can build connectors to different systems. Um they can build and design pipelines. And they can actually build the transformations as well, right? If we give them the right business context, they can build the transformations into
[11:55] those pipelines and architect part of that data stack for us. That's powerful. But the agents only are as good as the data that they can access and the data they can actually
[12:07] understand. And that's important because it's not always just pointing the agent to a database and saying, "Hey, go figure this out because I'm going to need to move this data from here to here. It has to be transformed and it has to be able to meet these different
[12:19] use cases." No, it needs to really understand what that data means. So, there are two things that we need to put in place. We need the connectors. So, we need the ability for those agents to connect
[12:32] securely in a governed manner to those internal data systems that we want them to work with. And we need some semantic intelligence around that so that the agents actually understand what that
[12:44] data means. Like not just in the structure of it, but what that data really means. So, we need that business context as well. And I'm not done hammering this data point home, right? Because our agents
[12:57] that we deploy in production are only going to work, right? We're only going to get adoption as much as the results they're producing are trusted. Right? Think about that. Right? If we put into production and people start using it and
[13:11] they get a response back or the agent does something they're like, "Well, I'm not really sure about that. I don't I'm not sure I like what it did, so I'm just going to I'm not going to use it anymore, right? I'm going to go around or I'm not I'm going to build my own agent now that does something similar."
[13:24] So, you see a lot of that. Um So, we need to trust it and the trust also comes from having good quality data. Uh think about your architecture today, right? Data's kind of the language that
[13:36] we use to connect different systems, right? That's how they speak to each other. They share data. Um we build algorithms on top of that data that can help us make the best possible decision, right? Or we create algorithms that will help us create the best personalization
[13:49] for our customers that improves our customer experience and improves their their satisfaction scores. Um we can build the most awesome analytics and the most awesome models, but if something happens in that data
[14:02] that changes and all of a sudden all those things are operating on bad data, then the whole thing just is is bad, right? The whole thing falls apart. Um so, the data's wicked important. Uh you've well heard the the phrase
[14:15] garbage in, garbage out, right? Again, right? If there's bad data that goes in and it it shows up on one report, no big deal, right? We can correct it. Um
[14:29] maybe it is kind of an embarrassment if that gets published or shared, but we can correct it. But if that same bad data point makes its way into a data system that we're scaling to, you know, 10,000 times the number of agents we have today, but
[14:42] if those 10,000 agents start react interacting with that data and they're doing things with it, then we have a potential problem, right? So, the governance here is
[14:54] something we got to design from the beginning, right? Not just the governance of the access of the data, but making sure the data is quality, right? Making sure it meets our our quality requirements and making sure
[15:06] that the agents know what it is that they're working with and know how to use it. Think about uh your your leader or your executives or even your CEO. What are they asking us to do right now with AI?
[15:19] Right? They're asking for three things, basically. Scale it safely as we can't just not use it. We need to use it. We need to scale it safely. Control cost as these models can get pretty expensive, especially if we're
[15:31] using the latest and greatest frontier models. Um and we want to produce real ROI. We need to make sure we're delivering value. Right? Those are the most important things. Um and in order to do that, in
[15:44] order to make sure we're delivering value and we're doing things that are actually going to help the organization, we need to start using these AIs to take actions that would normally be like a human problem that would involve a lot
[15:56] of manual effort, right? That's where we can get the most value. Automating some of these manual processes that become error-prone and manually um and these manual processes that just are time-consuming, right? Um not only is is
[16:08] the time expensive, but it also hurts the employee morale a little bit, right? To do the same kind of mundane tasks over and over. We want to be able to give them more valuable work, right? To improve the employee experience. All of that's important. So, when we're
[16:21] building agents, unlike building our dashboards in the past, we're not just going to surface these insights. We're going to then do something with them. So, think about um an engineer publishing um a a new version or a new
[16:35] release, right? An agent can check that release and make sure there are no problems. If there is a problem, instead of just putting an alert on a dashboard or filing a Jira ticket, the agent can actually roll it back. You know what? This one this one's got a problem. It's
[16:47] going to create more problems if we let people use it. We're going to roll it back. Agents can take action. Um employee onboarding, right? Is another good use case where we see a lot of AI. Um there's a lot of coordination between
[17:00] systems required. So, instead of just surfacing a potential issue with an employee's onboarding, the agent can start to, you know, surface that uh communi- or start to initiate that communication between IT, between HR,
[17:12] between finance, and make sure that those issues get resolved. All right, we can put agents in there to automate the things that humans kind of do today that, you know, they don't like doing. It's painful stuff. Right? Um and finally, like inventory
[17:24] management is another great example. Um we have a a predictive algorithm that we're really proud of. The data science team built this in here. We predicted a stock out at one of our locations. So, instead of surfacing that on a dashboard
[17:37] or firing off an email alert to somebody, the agent can now initiate a communication with that supplier and update the ERP system and do something to make sure that that stock out doesn't happen, right? You can
[17:50] automate those things that a human would have to manually do. The problem is you know, it sounds easy, right? It sounds easy, those three things. We just want to deliver ROI, right? We want to
[18:03] control our costs. We want to control our token spend. And we want to make sure we're scaling AI safely. It's really hard. Right? Only what? 90% right? I think it's around 90% of AI
[18:15] pilots right now never made it to production. So, they're still in pilot mode. I mean, I've heard that stat a lot of different ways. MIT says it's as high as they say it's 85. Um I
[18:27] I think Gartner said 90. It's right around there, right? But whatever it is, most of these pilots, they just they get stuck. They get they never make it past the experimentation phase or they're in pilot mode and they don't ever make it any farther. Um
[18:40] and I think it's because those AI agents are really hard to govern. So, let's think about it differently. Here's what we're getting into now. We're getting into our agentic workflows. But think about it differently. Instead of building an
[18:52] agent and giving an agent a big task and saying, all right, I want you to automate um the data pipeline that's going to take data from this system and put it over here, right? Want you to automate that whole that
[19:05] whole workflow. Well, that could be pretty expensive cuz the AI is going to be figuring out every single step. It's going to be re-ingesting all of the data in. It's a lot of tokens, right? So, it's going to be sitting there churning through
[19:17] tokens. It may get caught in a loop where it starts to iterate. You know, well, that doesn't quite look right. I'm going to try it again this way. And all of a sudden the costs get out of control, right? That's one problem. The other problem is
[19:31] these are these models are probabilistic. They're not going to give us the same answer every time. And that's that's actually a pretty cool thing if we need that, right? Cuz it's doing some reasoning and some other things. It's it's a really valuable thing for us.
[19:45] But if we're expecting the same answer every single time and the agent decides to do something a little bit different, that could be bad, right? The easiest logic that you can write in code is an if-then-else
[19:58] statement, right? And it's deterministic. You'll get the same answer every single time. If day equal Friday, run payroll, right? What if we told the agent, run payroll?
[20:10] The agent says, well, it's Friday. I would normally run payroll, but the payroll department hasn't had a break in a while and Monday's a holiday. We're going to run payroll on Tuesday. You know, and you can see the whole reasoning, right? I mean, I'm we would
[20:23] never do that, right? We would never do that because of how absurd it is. We wouldn't trust the agent to do that. We wouldn't want that deterministic process to be now governed by AI. So, the right thing to do is to mix it
[20:35] all together, right? So, think about this. When you design your agentic workflow, your agentic workflow should be a mix of those deterministic steps, the things that we already know, the things that we already understand, and the things that
[20:48] have already been proven, and then insert the large language models, right? Where it makes sense, where we need that more advanced reasoning, right? Where we have that manual step,
[21:00] right? Where the workflow usually has to, you know, notify a human and somebody has to look at it and they have to like make a decision. Well, I'm going to compare this data this data. Yeah, okay, I'm going to do this, right? Those are the things that we should be working
[21:13] with our finance teams, working with our HR teams, working with our payroll teams to understand where those painful processes are and build those agentic workflows that combine the deterministic steps
[21:25] with the reasoning, right? With the AI where it's appropriate, and build a process that actually works that we can govern. Think about it. We're restricting what the agent's actually doing,
[21:37] right? We're we're limiting the AI to just do that one little piece that we want it to do and we don't want it to go do anything else crazy, right? We're we're restricting it with guardrails. We're also limiting the tools and the
[21:49] data it has access to, so the agent can only access the data that it needs for that task, can be very specific, it's not going to hallucinate, right? And um we're giving it the tool the tools, the APIs, right? And access to the systems
[22:02] that it would need in order to be able to resolve that issue. So we're we're keeping it pretty small, we're controlling our costs, we're controlling the context, we'll talk more about that, so that we can keep that context window small and not
[22:14] burn a lot of extra tokens, right? And got a process that's governable, right? Where we get the same answer every single time and we're able to trace and see where the agent made a decision and we're able to then verify
[22:28] and make changes and evolve that process as we go. But we built something that's actually delivering real value. So, here's an example. Um we'll go back to kind of that financial reporting example,
[22:40] but these in this process, we're not letting the agent do everything. All these white boxes represent a deterministic step. So, we're triggering that workflow, right?
[22:52] That's based on an event that happens. We can do that today, that's known. Um then we know what data we need to collect. So we're able to pull that data in automatically, we don't have to let an agent decide what to do. Um and then we're able to update the
[23:04] logs, uh update dashboards, generate reports. All of those things can be done because those are known things that we already have in place. Um but then the data quality step, where we
[23:16] want to check and make sure something is valid, well that normally requires a human. That's a great place where we can introduce AI, where we need the more advanced reasoning. So that critical step that usually takes a long time, that's where we introduce
[23:29] the agent. That's where we limit what it's able to do. We have it compare the data. It can make a probabilistic determination of well, yeah, this this looks like it might be a problem, but I
[23:41] can't really tell. I need to look at this. And we can see those steps where it goes and checks goes and checks, goes and checks, figures out, okay, I know how to resolve this because I have access to this API that where I can go make that update. Or I don't know how to
[23:54] resolve this or I don't have access to that system. Now I can alert a human. So you can put a human in the loop. These don't have to be fully autonomous, but you're still automating a lot of those manual steps. You're delivering real value in this agentic workflow. Um
[24:08] but you can still bring a human into the loop where it makes sense, right? You don't have to these things run completely autonomous. So let's look uh let's let's compare, right? We have the agentic workflow, which is
[24:20] probabilistic. It's not very fast, right? It'll take a few seconds to spin through those tokens and, you know, make a decision as it goes through its inference. Um and it can be expensive,
[24:32] right? Depending on the model we're using, depending on how many tokens we have, it can be quite expensive. Um but the flexibility is there, right? We can do just about anything, right? We can get really super creative and we can do things we never could have done before.
[24:45] Um traditional if-then-else statements, 100% we're going to get the exact same answer every single time. It is incredibly cheap and it's incredibly fast. Right? In microseconds and just we're
[24:58] doing a quick database look up, all of those things. Those work. Problem is it's a little bit rigid, right? We have to hardcode everything or we have to build build rules by hand. There's a lot of work that goes into building those
[25:10] traditional systems. Bringing in the agent where it makes sense or bringing in the the foundational models where it makes sense, we can add more flexibility to that. So, the hybrid organization is is going to do both, right? You're going
[25:22] to leverage the traditional deterministic processing for the things that are known. For the things that are have already been solved, right? The problems that are that have already been working you're been solved and everything's
[25:35] working well. It's been that way for a very long time. You don't have to go reinvent the wheel just because, "Hey, it'd be really cool if we did that with Claude instead of that Python program that was written 10 years ago." No. Leverage what you already have in place
[25:48] and use the AI to solve the new problems or to do things that you can't do today. Right? And that's what the That's what the the successful companies are really doing. You can't build completely on the
[26:00] agentic side. You know, to be successful, you need to bring in a little bit of both so you can get the governance and the observability that you need as well. So, this is good for our CD AIOs in the
[26:12] room. Do we have any CD AIOs in the room? Do we have We have a couple? Yeah? We have The rest of you probably report to a CD AIO at some point in your chain. Um well, those individuals are governed
[26:25] on three things. Right? They want they're they're responsible for governance. They're responsible for cost control. And they're responsible for outcomes.
[26:38] This is what the agentic workflow helps us do, right? By mixing the deterministic steps with the um with the agentic processing, we're able to control costs cuz we're not letting
[26:52] that model sit and spin and just burn tokens. Right? We're controlling costs that way. We're also providing governance along the way, because we've minimized what the model with the LLM is actually doing
[27:05] for us, and we're surrounding it with all these deterministic steps that are auditable and governable and traceable. Right? Um and we need to figure out how we measure
[27:17] outcomes as well. And this is this is um going to apply when you start thinking about use cases. But we want to make sure that we're tracking ROI, so we want to make sure we're building an AI that we can put into production that has
[27:30] value that we can actually measure. Right? Especially for some of those early ones. If you want those early wins, you know, find a painful process that, you know, is a is a real, you know, real thorn in the side of the business. Right? Something they deal with all the
[27:42] time. Something that requires a lot of manual work. Some place where an intelligent workflow could really shine. Um because I know which use cases most of you already have in place today. Um most of you are exploring the
[27:55] horizontal use cases. I Gemini, Claude, Claude Co-work, you know, those applications are great. Even meeting summaries. How many of you
[28:07] joined a meeting yesterday with where AI joined and automatically started taking notes? Or this morning. Yeah? Yeah. It's nice to have, but it's hard to measure the value of that. You don't know I mean we know it's adding value. We know having
[28:20] that agent come to that meeting and take notes for us is valuable. We know that's a nice thing to have, but how do you measure that? How do you measure how much value it's really giving you? And how do you like how do you show an ROI based on the cost
[28:32] that it takes to turn through all those tokens? It's pretty hard to do. Um I actually heard Andy Jassy did this in one of their earnings calls for AWS, but he was talking about how um you know, these AI assistants are a a like
[28:45] email. You don't know how much value emails really giving you. It's hard to measure, but you just know you need it. Right? So, you just got to have it. Like, you can't operate without it. And we've got to the point with coding assistants and
[28:57] with the with the AI assistants like Co-work, that I think we're getting that point where we just need them. Right? They They do so much for us. We just need them. It's just hard to measure what they're really giving us. Um So, focus on the vertical use cases.
[29:09] Right? The vertical use cases give us a little bit more measurable real value. Um so, for example, the financial reporting agent. Right? That's going to consolidate all that data for us. We can
[29:22] automate all that manual processing that goes in, and it can save a lot of time. An invoice reconciliation agent. It can automatically match an invoice to a PO. Something that might be a manual process
[29:35] today. Right? If the if it comes in and it doesn't match perfectly, you've got to look it up. Right? And you've got to pull data from different systems and figure out, okay, you know, which which PO is this invoice go to? Do I pay it or do I not pay it?
[29:47] Right? Got to do that. All right? Got to Got to look for places where we can automate some of that pain. Um another good example is triage, you know, for support tickets. Um if we were able to automatically
[29:59] categorize, prioritize, and even generate automatic responses in some cases to resolve a customer's issue much faster, then we improve their experience. All of these have real measurable
[30:11] outcomes. Customer experience directly relates to CSAT. You know, those customers are much happier. Happier customers stay with us longer. They're more interested in our other products and services as well.
[30:23] Um Invoice reconciliation. That's a huge use case now for Agentyc AI, because it is a big manual process today, and it actually costs money. If we can't match the PO to an invoice, or we can't match
[30:36] that invoice to a PO, and it doesn't get paid on time, well, we lose maybe that prepayment discount that we had agreed to. So, it actually does impact, you know, it impacts us financially. So, that's value. And then the financial
[30:48] reporting, we talked about that. That is a that there's a lot of annual steps in that process, right? And all of those could be potentially or a lot of those could be potentially automated there or they're good for an
[31:00] AI agent. Let's talk about those. So, if we were just to focus on like the close process, it's a painful thing today. Um how many works in How many of you
[31:12] guys work in finance or at least have helped a finance team through this process? Okay. A lot of manual work. Um it can take days at the end of every quarter to get the different teams together and assign tasks and get them all working on the
[31:25] close process. Um data, if it exists in multiple systems, you know, each one of those systems has to have a pull, so different teams have to go spend a couple hours pulling the data from each of those systems. Then
[31:38] they bring it all together and try to reconcile it. That requires like a lot of manual work just to check it and make sure it matches the way it's supposed to. Um each one of those different teams that's involved, they've got different rules
[31:50] that they're using to validate the data. Um you got to make sure those match up. And what it Where do they do all this work? In Excel, right? They pull all that data down and they bring it into Excel. So, we're in Excel hell. By the way, that's
[32:02] getting a lot worse because we're not building spreadsheets anymore. Claude is, right? People are feeding this data in the co-work and it's creating the spreadsheet. So, it's creating it's compounding this issue. Um and then it's
[32:14] hard to approve because, you know, you're waiting for data and that data is being pulled through these manual steps. So, it it takes a long time to get to the point where you feel like you have enough data to make a decision. Um and cuz you're waiting for data, you never
[32:27] have any idea of where you are in the process. So, there's no real-time visibility. Um and forget every single quarter and start all over the next quarter doing it all over again. There's we're not building
[32:39] repeatable real processes here. So look at where an agent can help us. An agent can automate all those manual steps potentially. Right? It can automate the data
[32:51] extraction and reconciliation. Um it can do that much faster. It can pull information in real time and it can also update, you know, dashboards in real time so people have visibility into the process. Um
[33:05] A lot of value in that, but how do you measure it? Right? If we were to deploy an agent just to do something like this, how would we measure the outcomes? What would we know what success looks like? We'd set goals. So, right now the close cycle, let's say
[33:19] it takes 10 days. We'd want to cut that in half, right? A goal good goal would be 5 days. Um the number of records that are can be automatically processed without a human
[33:31] intervening. We would want that to be high, maybe north of 80%. And accuracy of of things that were being flagged as anomalies, we'd want the agent to hit like 95 plus percent
[33:43] for that. Right? So, we set real goals and then we can go deploy our agent to do those things. The agent has a lot of moving parts. Right? So, think about these four. First, you have the environment. This is
[33:56] where the agent is going to live and work. In this case, the agent lives within the finance department. Perception or the inputs. These are the instructions, the goals, and the other um
[34:08] critical pieces of of instruction that we're giving that agent to go perform. The agent has access to tools. Right? Has access to um eight different APIs and other MCP servers that it can invoke. Right? So, we've given it things
[34:21] that it can go do. The last piece is the brain. And this is a pretty important part because it's not just the large language model. It's all the data that it would need to pull in and make those decisions.
[34:35] Right? That's important because that doesn't mean we just give it all of the the data and let it figure it out. That's how we spend a lot of tokens, right? So,
[34:47] having good context is is really important, but that doesn't mean having a whole lot of context. There's a There's an art to this, right? And it's giving the agent the right context at the right time so it can make the right
[34:59] decision. That's context engineering. Have you thought about this? Are you guys doing context engineering today? Yeah, well, I'm getting a lot of nods. Okay. Um if you're not thinking about context
[35:11] engineering, then you're not AI on a good foundation. But context engineering is is critically important and it's important that you do these things. Um and I I talked about this early on,
[35:23] but it's important that you don't just point your AI at a database. You tell it what that database represents. We've got a map that raw data to the semantic context so that the agent understands what it all means. We're mapping it to
[35:35] our business glossary, basically, so it understands. We also have to map that data to the rules and regulations around how that data can be used, right? This basically allows the agent to kind of employ its own governance, right? So, if
[35:48] the agent knows what the data represents, knows how it can be used, then the agent can decide whether or not it should actually pull that data in to make its decision, right? And that's the other piece. We've got to make this easy for the agent to find.
[36:00] So, we do those things. Semantic context, um rules for usage, and you know, a way of delivering that enriched metadata back to the agent. How we can generate and engineer the
[36:12] right context so that the agent makes better decisions. This produces real outcomes. Um agents that are that don't have the right context at the right time, they have to guess, or they get caught
[36:25] in a loop. I think we've all been in that situation where we're working with an AI and all of a sudden it just doesn't really know what to do. So, it keeps kind of repeating the same thing that's not really right. You get caught in that. That's expensive. You're spending through tokens. Um but with the
[36:37] right context, you're able to minimize, just send the right amount of information, keep that context window small, and still get the best results. All right? So, you get better results at a more reduced cost.
[36:49] Um We'll go through some uh a couple of other things. I want to try to wrap this up. But, we also need to be able to answer the question, "Why did my agent do what it did? What
[37:01] did my agent do and why?" Um so, we need to build these things in. We need to be able to trace the data back to the source. Um we need to establish that business glossary and those business terms that we all agree on. We need a
[37:13] way for the agent to log the steps that it makes and how it makes its decisions, as well as the tools that it calls, right? The APIs it's interacting with. We need to be able to audit and trace all of that. And finally, we need to make sure that the data um has some more
[37:26] enriched information about the quality. Like, we want to know when it was last refreshed. The agent should know when it um pulls data in for a decision, it should know if it's old or not. Did it miss something, right? That needs to be included in here.
[37:39] What this looks like in Boomi, I'm getting to the point here. Um this is what we do, right? This is what we've been working on. We've been We've been working with so many customers over the last few years um that have have been working through how to do this. And
[37:53] we've been designing our platform so that it it actually does those things that we're talking about today. Now, we've had the connectivity, you know, in the integration, as well as the API management, all those things that your agent needs, and we brought in the data
[38:05] integration and other tools as well. So, the agent has this complete modern infrastructure it needs to be able to to make those right decisions and and automate some of those tasks we're talking about. So, within Boomi,
[38:18] as we're building out this workflow, um we can automate the ingestion of that data. We can automate the business rules. We can automate the updating of the dashboards so everyone has real-time visibility into that process.
[38:30] The platform looks like this. Oh, at the core, we've got the data management pipelines as well as the lineage and the context capability and the quality checks for your agent. We've got the tools and integrations that your
[38:42] agent would need in order to be able to interact uh with your internal systems and take actions on your behalf. And we've got the governance so you can monitor all of this and you understand what your agent is doing. Finally, our
[38:55] runtimes allow you to deploy anywhere. On premises within your own data centers, within a co-location data center, or within the cloud. Wherever your data needs to live, this is where your workflows can run.
[39:07] Come see us. We're at we're booth 312. You can't miss us. Um, ask to see a demo or just chat with us. We'd love to chat. We'd love to take you out for ice cream. Whatever you want to
[39:19] do, come by and say hello. Um, and so I'll make sure everyone memorizes 312. And right on time, surveys. These are important and we use
[39:32] this to try to make sure we're creating great content for everyone that comes to these conferences. So, please fill out your survey. All right. 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.