Building an AI agent that works in a demo is the easy part. UiPath's documentation includes a surprisingly concrete pre-deployment checklist for agents built in its Agent Builder, with numeric thresholds. It's useful even if you never touch UiPath, because the discipline it describes applies to any agent you plan to put in front of real work.

The checklist below is from UiPath's "best practices for publishing and deploying agents" page. My commentary is marked as such.

The seven publishing gates

UiPath lists seven things to validate before publishing an agent:

  1. Prompts and examples. The system or user prompt includes a role, constraints, and three to five examples mapped to the inputs.
  2. Tools. Every tool has a name, a description, and an input/output schema.
  3. Guardrail logging (optional). Tool calls are logged for audit and debugging.
  4. Context sources. If the agent needs company knowledge, it's grounded in a relevant knowledge base.
  5. Interactive testing. At least 30 interactive tests, covering typical, edge-case, and malformed inputs.
  6. Evaluation set. At least 30 curated test cases that reflect real-world usage.
  7. Performance validation. The evaluation set scores at least 70%, with no regressions.

Notice what's missing: nothing about model choice or prompt cleverness. The list is almost entirely about evidence that the agent behaves.

Tools are contracts, not conveniences

The docs say each tool should be defined with its name, purpose, schema, and side effects, plus logging, filters, retries, and escalation behavior, and should return consistently structured responses.

"Side effects" is the important word. A tool that reads a record and a tool that issues a refund look identical to the model unless the description says so. Writing the side effects down is what lets you decide which tools need a human approval step. In Agent Builder, UiPath's tutorial also stresses giving every tool a detailed description that tells the agent how and when to use it, since that description is what the model reasons over.

Grounding: where the knowledge comes from

UiPath's Context Grounding indexes give an agent access to permissioned knowledge bases, so its answers and actions are tied to business data instead of whatever the model remembers. The getting-started tutorial builds a simple HR assistant that answers questions about company policy by attaching a Context Grounding index as a tool.

The word to underline is "permissioned." An agent that can search a knowledge base should only see what the person asking is allowed to see. That is a configuration decision, not something the model will figure out.

Testing: 30 is a floor, not a target

The docs ask for at least 30 interactive tests and an evaluation set of at least 30 curated cases, scored using methods such as LLM-as-a-judge, exact match, or trajectory scoring, and tracked across every prompt or tool change.

My view, not UiPath's: 30 cases is enough to catch an obviously broken agent and not enough to estimate how often it fails. If the agent touches money, customers, or regulated data, treat 70% as the minimum bar to be allowed to try, not as evidence the agent is ready. The valuable part of the guidance is the regression rule: re-run the same set after every change, so a tweak that fixes one case doesn't quietly break three others.

Governance and rollout

The remaining guidance is about process rather than prompts:

  • Use semantic versioning and track changes.
  • Get security, operations, and product sign-off.
  • Write runbooks covering inputs and outputs, credential rotation, and recovery steps.
  • Build in human-in-the-loop escalation, and decide what happens with each outcome.
  • Roll out with canary deployments or traffic splitting at low volume.
  • Re-run evaluations periodically and review prompts and tools quarterly.

That last point is the one teams skip. An agent is not finished when it ships. Models change, data drifts, and the quarterly review is the only thing standing between "it worked in March" and a silent failure in September.

A short version you can copy

Whatever platform you use, the checklist reduces to: define each tool as a contract, ground the agent in permissioned data, build an evaluation set before you build confidence, gate release on a score, roll out small, and schedule the review.

If you want the platform context, UiPath Maestro Explained covers the orchestration layer that these agents run inside, and UiPath's AI Features, Explained covers the wider product line.

Sources

AI AgentsAI GovernanceAgentic AIEnterprise AutomationUiPath