Vinny LaRocca: Thanks for joining, everyone. We’re going to be talking about agentic orchestration today. If you have any questions, just make sure to put them in the chat, and we’ll get to those at the end of the presentation. I have with me Logan Emerson and Jacob Ortega. Jacob is one of our senior engineers with Lydonia, and Logan Emerson is in charge of AI with UiPath.
Logan Emerson:
So, we’re going to be looking at Maestro specifically. I’ll share my entire screen now.
Before we get here, which is kind of our home base, I want to reintroduce BPMN with a little bit of a crawl-then-walk-then-run approach. So, you want to create a new process. We understand that it needs to start somewhere, and we’re going to have training. I think we may already have training on UiPath Academy for how to use BPMN and get started with building BPMN workflows. It’s also an industry standard, so you can find third-party modules to train yourself on or get trained and up to speed on what BPMN is.
Essentially, you start with a start event. You might have tasks—do the first thing, then the second task does the second thing. Maybe another task, but maybe this is specifically a user task where a human is going to be in the loop. Then, do the last thing, which is manual.
Then, we’re going to have an end event. What you could do is test and see this run, see a token run through it. Since there’s nothing hooked up to it, it’s just going to help you understand how this tends to run. However, I have an actual workflow below here, so I’m going to get rid of this and take a more in-depth look. Give me a verbal confirmation if the size is difficult for anyone to see. I’m going to try to make this as large as possible. Jacob, just let me know if it’s too small for you.
Jacob Ortega: That works.
Logan Emerson: Excellent.
So, what we’re looking at here is a standard invoicing process. This is a small part of that P2P process that we went through earlier in the slides. When an invoice is sent out, it needs to be matched to the purchase order. Actually, you know what—I’ll just walk through it in the workflow.
An invoice is received. I have purchased things, I have received those goods and services, and now I’ve received an invoice from the vendor expecting payment for the goods and services delivered. So, I receive an invoice—that’s an inbound file that could be received through email or however invoices arrive at your business.
Then, we have an automation. This is a real automation. You can see it’s hooked up here. Now, I have manually dropped in inputs, but this is a real automation where I could run this and have it be part of my business.
So, “Invoice to PO Matching”—is resolution required? That’s the output of this process. If so, we use this “Resolve Discrepancies” agent, which will resolve those discrepancies. If further review is needed, a human in the loop is brought in.
But if no further discrepancy resolution is needed beyond the agent, it’s either rejected, where we’ll notify the vendor—something’s wrong with this invoice. We can give them the specific details of what’s wrong with that invoice using the Integration Service Outlook connector. Or perhaps we approve this invoice.
That’s an Action Center app task. So that’ll be sent to me, where I’ll be rejecting or approving invoices. If rejected again, we’ll send that notification. And if approved, we’ll post that invoice to SAP. Again, that is a real automation that can post to SAP.
Now, for time, I’m not going to jump into SAP and show all of that, but this is a fully-fledged, end-to-end automation process for invoice processing that goes from invoice received to invoice processed. Now, this is part of a larger end-to-end process, which is purchase to pay. Maybe in a future webinar, I can show what that looks like. I have not developed every element of that so far. But this is how we get here.
And now, I’ve designed this. I can test this in this environment. But this is just testing. So think of this kind of like Studio. This really is Studio. I am developing this. So, of course, live demo with preview products—that would be bound to happen.
Let’s see if this works on my second try. Looks like—no. But that’s okay. We’re in design mode. I’ve actually already published this process. So this process exists in my environment. I can run it. You can see I’m looking at all instances right now.
So, from the top, we have the exact same process. Now, I’m looking here. If I minimize this and look at all these instances of the process that I’ve run in the last day or so, you can see each individual instance of that being run.
Now, again, what I want to impress upon you is that this up here is a relatively complex process. We’ve got a human in the loop. We’ve got agents. We’ve got another human. We’ve got multiple automations. And I can see all of it right here. I can understand what’s going on with each of these elements, and I can see a specific trace.
So this is the time that we received an invoice, and we can look at how it ran down. It took 2 minutes and 37 seconds. Maybe I’ll look at this one because it might be a little bit more interesting. It took just over half an hour. I want to see why it took over half an hour.
Again, we can see the flow that it ran through.
All right. That’s interesting.
What took so long? Oh, well, approving the invoice took about 37 minutes, which is almost the entirety of this. So it was waiting on a person for 37 minutes.
Now, these times in this demo environment might not be the most applicable to an actual business context, but we can see generally how you can start pinpointing what went wrong in this specific instance.
But we’re not always just interested in every specific instance. We’re interested more in monitoring the process and how it runs generally. So I want to look at the most recent version of this process, and I want to monitor this process now.
Now I’m looking at all the runs that I have. So we’ve got 12 successful runs through here. We had one failure at Invoice to PO Matching but 11 successes through here. You can see that a few of them went this direction.
Now, I’m just looking at these numbers that are relatively small. But if I wanted to have a better idea of where things are taking time—well, it says Invoice to PO Matching. That’s a relatively complex process that uses Intelligent Document Processing to match a PO to an invoice.
It’s more complex. It may need to be broken up into smaller chunks so it doesn’t fail as frequently. That might be a recommendation that the logs have for me. I can dive into that in a second.
And also, approving that invoice—that’s taking a significant amount of time. You can see the heat map here.
So that is monitoring from a top level. And then again, I’d love to have more data to show for you here, but you can see over a specific time. So, hey, we’re looking at the end of the quarter. We want to see how this ran for the last two weeks of the quarter. Well, there’s no data. Oh, that’s at the end of February. My apologies. We want to see the last two weeks of this quarter up to now. Oh, we’ve got a lot of runs in that timeframe.
I think you get the idea. You can see instances per day, per week. You can see the average duration.
And any of you that are kind of familiar with Insights, Process Mining, some of our Discovery Suite—there’s a lot of overlap here where we’re taking the good chunks from that and understanding, hey, how can we implement that into our agentic orchestration in Maestro?
These are some of the out-of-the-box features. You can also customize and make these a little bit more applicable to what you need to monitor in your agentic automations.
Let’s go back to some instance management. I want to see why this instance failed. Recall again, we saw that there was a failure at Invoice to PO Matching. I’m interested in why that failed. What the heck’s going on here?
Get an error message—job faulted. Automation canceled because it reached the time limit. Consider optimizing your workflow.
So this is real text generated by a healing agent. We’re not covering healing agents here, but this is text that can be generated by a healing agent. And a healing agent could be deployed to try to fix this.
That would require some human in the loop to then implement those fixes that might be recommended by the healing agent. But you can think of it almost like autopilot for developers.
It’s helping developers—people who are interested in monitoring, updating, optimizing processes—and it will give you lots of guidance on how to fix your process, how to improve this process based on failures, based on your business context, and based on what specifically went wrong in that particular instance of the process.
Now, something I can do—hopefully, this version of it runs well—is run this instance. Now, let’s say a new invoice enters the mix. We can start seeing this run through, and I’m going to look for a running status so we can look at this particular instance.
Okay, it’s already matched. The PO doesn’t need resolution. It’s waiting for somebody to approve that invoice. Well, that’s going to be me.
So I’ll refresh my actions. Now, you may be familiar with Action Center already, but this is where humans in the loop enter the mix. I’ve assigned that to myself. This will populate with invoice information. I can approve or reject it. Let’s say I reject it. I don’t like that Logan Emerson guy, so I’m going to reject that one.
Let’s take a look at what happens next. It’s going to notify the vendor, which also happens to be me. And let’s take a look—I’ve received an email that my invoice has been rejected.
And me, as a developer, I’m going to add some variables to make that a little bit more specific later. But I think you get the idea. We watched a real instance of this run all the way through, and I was able to notify the vendor. And I understand, in this particular instance, this is exactly what happened when we received that invoice. I can even look at the arguments of that invoice that were generated, see where it went through step by step, and understand—hey, if I’ve got a vendor that says, “Hey, you never notified me about this,” well, I can go investigate this automation, or I can also confirm it looks like we actually did receive that. I’m curious—maybe your filters aren’t set up quite right, Mr. or Mrs. Vendor.
So, I hope that’s a helpful demonstration. I think we’re just about at the 30-minute mark, and we have some time for Q&A. Unless, Jacob, you think there’s anything else that you’d like me to show specifically here in the Maestro product or Vinny.
Jacob Ortega: I think—I mean, that was so super helpful. It’s really good to see this process in an end-to-end fashion, right? Just trying to make it as simple as possible. Logan, would you mind just touching a little bit on maybe what that agent is doing if it does identify discrepancies?
Logan Emerson: Yeah, absolutely. So, this agent is going to look for discrepancies. It’s also going to use business context to understand which discrepancies are okay with me—as you know, Acme, Inc.—versus which discrepancies aren’t okay. So, it’ll use business logic to understand. If you have any interest in extending on context grounding, I’m also happy to talk about it, but you can use business context to understand—hey, when a purchase order, purchase requisition, or an invoice is valued above $40,000, well, we can’t have any discrepancies. We can’t mess around with that.
Or, if this is an invoice for $100, that’s okay. We’ll let this go because we don’t need to have humans in the loop every step of the way for something that’s relatively low value. Now, I just used 40,000 and 100 as examples. Those can obviously be set by the users, by the automation program, by the IT team to understand—hey, what’s actually real for us? Where do we set these bars?
The agent is going to use those bars that are set. It’s going to kick off other automations that might be necessary to help us understand more context about these discrepancies, and it will then come to some sort of resolution—either resolved, fully rejected, or escalated to a human in the loop for further resolution.
Vinny LaRocca: Well, thanks everyone for joining. Feel free to reach out to us if you want any more additional information or if you want to discuss, use cases. But yeah, thanks again.
