- Getting started
- UiPath Agents in Studio Web
- About UiPath Agents
- Licensing
- Running agents
- Working with files
- Contexts
- Escalations
- Evaluations
- Agent traces
- Agent score
- Managing UiPath agents
- UiPath Coded agents
- Build with Coding Agents
Agent execution in Agents: a single execution model that runs low-code and coded agents consistently, whether triggered from Debug or Orchestrator.
All agents run through the same execution engine, regardless of how they are built. This 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, this shared execution model 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 same underlying 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.
Agent 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 engine, regardless of whether the run is triggered from Debug or from Orchestrator. From a user interface perspective, this execution model 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 engine, 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