Last month, I hit a wall with our invoice processing pipeline. We had a solid UiPath RPA bot that extracted data from PDFs and dumped it into our ERP, but it kept choking on edge cases—handwritten notes, weird vendor layouts, multi-page contract bundles. Every time it failed, a human had to intervene, and the "automated" process became a game of whack-a-mole. I kept thinking: what if the bot could just ask an AI agent to figure out the weird stuff, then carry on?
That's exactly what sent me down the rabbit hole of UiPath Agentic Automation. I'd been using UiPath for traditional RPA for years, but the new agentic features—Agent Builder, Maestro orchestration, and the whole ecosystem around it—felt like a different beast. Here's how I actually got it working, mistakes and all.
Setting Up the Prerequisites
Before you touch anything agentic, you need the right foundation. I made the mistake of trying to jump straight into Agent Builder without updating my environment. Don't do that.
First, grab the latest version of UiPath Studio. I'm on 2024.10+, and that matters because the agentic workflow activities aren't available in older versions. You also need:
- An active UiPath Automation Cloud tenant (the community edition works for learning)
- The "Agentic Automation" feature enabled in your tenant—check your Admin portal under "Manage Packages"
- An AI Connection configured (I used OpenAI, but UiPath supports multiple LLM providers through their AI Trust Layer)
The AI Trust Layer piece is actually important and not just marketing fluff. Because all LLM calls route through it, your data doesn't just get dumped raw into a third-party API. In our case, that was the difference between getting security sign-off and not.
Building Your First Agent in Agent Builder
Agent Builder is where you define the AI agent's personality, tools, and guardrails. Think of it as giving your agent a job description and a toolkit.
I started by building a simple "Invoice Exception Handler" agent. Here's what I did:
Step 1: Create the Agent
In Automation Cloud, navigate to Agent Builder (it's under the "Agents" section in the left nav). Click "Create Agent." I named mine InvoiceExceptionAgent.
Step 2: Define the System Prompt
This is where I made my first real mistake. I wrote a vague prompt like "Handle invoice exceptions." The agent had no idea what that meant and gave useless responses. After some iteration, I got specific:
You are an invoice processing specialist. When given an invoice image or extracted text with missing or ambiguous data, you must:
1. Identify what information is missing or unclear
2. Search the provided company vendor database for matching vendor details
3. Calculate any missing line item totals using the subtotal and tax fields
4. Return a structured JSON object with the corrected fields
Never guess at values. If you cannot determine a value with confidence, set it to null and flag it for human review.
Specificity is everything. The agent performs exactly at the level of your instructions.
Step 3: Attach Tools
This is where UiPath's approach differs from just calling ChatGPT. Agents can use tools—which are essentially UiPath automations they can invoke. I attached two:
- A reusable workflow that queries our vendor database via API
- A document understanding model for re-scanning problematic sections
In Agent Builder, you add tools under the "Tools" tab. Each tool maps to a UiPath workflow with defined input/output arguments. The agent decides when to call them based on the task at hand.
Step 4: Set Guardrails
Under the "Guardrails" section, I set:
- Maximum iterations: 5 (prevents infinite loops)
- Maximum LLM tokens per turn: 2000
- Human-in-the-loop threshold: Any confidence score below 0.7 triggers a pause for human approval
That last one saved me during testing. The agent tried to "correct" a vendor address that was actually right, and the guardrail caught it.
Wiring It Into an Agentic Workflow
An agent by itself is just a conversational thing. The real power comes when you orchestrate it alongside traditional RPA activities. UiPath calls these "Agentic Workflows," and you build them in Studio.
Here's the flow I built:
- Scope: Use "Use Application/File" to point at the incoming invoice folder
- Extract: Use Document Understanding to pull structured data
- Decision: Check if extraction confidence is above threshold
- If low confidence → Invoke Agent: This is the key activity. It's literally called "Invoke Agent" in the activities panel (under the "Agentic" category). You pass in your agent name and the input data.
- If high confidence → Skip agent: Go straight to ERP upload
- Upload: Post the final data to the ERP system
The "Invoke Agent" activity was surprisingly straightforward to configure:
Agent Name: "InvoiceExceptionAgent"
Input: extractionResult
Output: correctedResult
Timeout: 00:05:00
The output comes back as a JSON object matching the schema you defined in Agent Builder. I then used a "Deserialize JSON" activity to pull out individual fields for the ERP upload.
The Maestro Orchestration Layer
Here's where things get more advanced. For simple scenarios, the Studio workflow approach works great. But for long-running processes that span multiple systems, need human approvals, and might take days to complete, UiPath offers Maestro.
Maestro is the orchestration control plane. I haven't deployed my invoice process to Maestro yet (still testing in Studio), but I've prototyped a simpler approval flow. The key concept is that Maestro coordinates hybrid work—robots, agents, and humans all working on the same process instance.
In Maestro, you define a process as a series of steps. Each step can be assigned to:
- A robot (traditional RPA)
- An agent (agentic AI)
- A human (via UiPath Action Center)
The orchestration engine handles routing, state management, and escalation. If an agent hits its confidence threshold, Maestro automatically creates a human task in Action Center. Once the human completes it, Maestro routes the process back to the agent or robot.
This is the piece that solves the "whack-a-mole" problem I started with. Instead of me manually checking failed bots, the system handles the routing automatically.
What Actually Surprised Me
A few things I didn't expect:
Agents are slow compared to RPA. A traditional bot activity takes milliseconds. An agent call with LLM inference takes 5-15 seconds. You can't just replace all your RPA activities with agents and expect the same throughput. Use agents for the judgment calls, not the mechanical work.
The iteration limit matters a lot. During testing, my agent got into a loop where it kept calling the vendor lookup tool with slightly different queries. The maximum iterations guardrail (I set it to 5) prevented this from running forever, but it also meant the agent sometimes gave up before finding the answer. Tuning this is a balancing act.
Reusable workflows as tools is genuinely powerful. I already had a dozen utility workflows built for traditional RPA. Being able to expose them as agent tools means my existing investment isn't wasted—it's amplified.
Practical Tips
Start with a narrow, well-defined agent. Don't try to build a "do everything" agent. My first attempt was a general "document processor" and it was terrible. The invoice-specific agent works much better.
Test your agent in Agent Builder's chat interface first. Before wiring it into a workflow, have actual conversations with it in the test panel. Give it real inputs and see what it does. This catches prompt issues fast.
Version your agents. When you update a system prompt, the behavior changes. Keep track of what prompt produced what results. Agent Builder has versioning, but I also keep a local markdown file with my prompt iterations and notes.
Monitor your AI Units consumption. Every agent call consumes AI Units, and they go fast during development. I burned through my monthly allocation in two days of heavy testing. Check the "AI Units" dashboard in Automation Cloud regularly.
Don't skip the human-in-the-loop. It's tempting to set the confidence threshold low and let the agent run wild. Don't. The first time it makes a wrong decision in production, you'll lose stakeholder trust. Start conservative and loosen the guardrails as you build confidence in the agent's performance.
Honest Limitations
UiPath's agentic automation is not a magic wand. The agents are only as good as your prompts and your tools. If your underlying data is messy, the agent will be messy too. The learning curve is real—you need to understand both RPA orchestration and LLM behavior and LLM prompting behavior, which are very different skill sets.
Also, the ecosystem is still maturing. Some of the Agent Builder features feel like v1. The debugging experience for agentic workflows could be better—when an agent makes a weird decision mid-workflow, tracing why is harder than it should be. And the documentation, while improving, still has gaps around advanced orchestration patterns.
That said, for my invoice problem, it worked. The agent handles about 70% of the exceptions that used to require manual intervention, and the remaining 30% get routed to humans through Action Center automatically. That's a real, measurable improvement—not a theoretical one.