- Getting started
- UiPath Agents in Studio Web
- UiPath Coded agents
Agents user guide
Running agents
Unified runtime is the execution foundation that runs all agents, regardless of how they are built. It provides a single runtime model that ensures agents behave consistently whether they are created using low-code tools or written directly in code.
At a high level, unified runtime provides:
- One execution engine for all agents
- One runtime contract that defines how an agent runs
- One operational model for debugging, monitoring, and resuming execution
Agents are represented using a standardized definition that includes prompts, tools, inputs, outputs, and settings. At runtime, this definition is interpreted and executed by the unified runtime engine.
This enables a "best of both worlds" approach:
- Low-code users can build and iterate quickly using visual tools
- Pro developers can extend or convert agents into code when needed
- Enterprises benefit from consistent governance, security, and observability
This eliminates fragmentation between low-code and coded agents and avoids the need to rebuild agents when moving between development styles.
Unified runtime execution model
When an agent runs:
- The agent definition is prepared as a self-contained execution contract.
- The runtime executes the agent in a secure, serverless environment.
- Long-running steps (such as human-in-the-loop actions or external processes) can pause execution.
- The agent resumes automatically when the required action completes.
- Execution details are captured through traces and logs.
All of this happens using the same runtime, regardless of whether the run is triggered from Debug or from Orchestrator. From a user interface perspective, unified runtime is largely invisible.
From Agent Builder and Orchestrator:
- You select Debug to test an agent.
- You publish the agent to a UiPath tenant as a solution and run it as an Orchestrator job — triggered via API, a Maestro node, or a process activity.
- You view inputs, outputs, tool calls, and traces.
- You see agent runs move through familiar states: running, pending, suspended, completed, or failed.
Traces
Because all agents run on the same runtime, traces have a consistent structure regardless of whether the agent was built with low-code tools or written in code. The traces UI surfaces:
- LLM calls and responses
- Tool invocations and results
- Errors and guardrail actions