agents
latest
false
  • Getting started
    • About this guide
    • About agents
    • Agent capabilities in the UiPath Platform™
  • UiPath Agents in Studio Web
  • UiPath Coded agents
UiPath logo, featuring letters U and I in white

Agents user guide

Last updated Oct 30, 2025

Building an agent in Studio Web

This section walks you through how to build an agent in Studio Web. To make reliable production-grade agents, we highly recommend you check out Best practices.

Exploring the agent workspace

Use the main Studio Web designer canvas to design your agent, and the left and right panels to explore the agent structure and resources.

Choosing your canvas type

You can design your agent using two distinct views: Form and Flow.

  • Flow is a visual canvas. It features a drag-and-drop, node-based visualization where each component (model, prompt, context, tool, or escalation) is represented as a node on the canvas. This view is ideal for users who prefer a graphical and exploratory approach to agent design, enabling them to build, debug, and refine logic through direct manipulation of visual elements.
  • Form is the standard, form-based experience of Studio Web. It provides a structured, form-based authoring experience where each component of the agent is configured through dedicated panels and input fields. This view is ideal for users who prefer a tabular or configuration-driven approach to agent design, enabling step-by-step setup, validation, and testing without relying on visual diagrams.

Switch between Form and Flow modes with lossless synchronization between both experiences. Any property edited in the form is immediately reflected on the flow view, and vice versa.



Flow view

The Flow canvas is structured around four main areas:

  • Central canvas – The primary design surface where agent logic is represented as connected nodes. The canvas supports zoom, pan, and mini-map navigation for complex agents.
  • Left-side panel – Provides access to the Project Explorer, Data Manager, Errors, and Deployment Configuration panels, consistent with the form-based interface.
  • Right-side panel – Displays the Properties and Dev tabs, allowing users to edit node attributes or run quick debug tests.
  • Bottom panel – Shows Execution Trail, History, and Evaluations, and integrates live trace data during design-time debugging.
Node types on the Flow canvas

Each node on the canvas represents a logical component in the agent definition:

  • Agent node – Define the system and user prompts and expose the schema (input/output arguments) in the Data Manager. Configure the model, temperature, and token settings.
  • Context nodes – Link Context Grounding indexes, allowing configuration of query strategy, thresholds, and retrieval limits.
  • Tool nodes – Visualize the connected automations, activities, or other agents. Each tool node can be expanded to display input/output schemas, guardrails, and simulation options.
  • Escalation nodes – Indicate human-in-the-loop mechanisms and memory links. Selecting them opens the escalation configuration panel with task recipients and outcomes.


Debugging in Flow view

The Flow canvas provides real-time visual feedback during debugging:

  • Trace streaming: As the agent runs in design time, trace spans appear directly on the canvas, and nodes light up as they are activated in the agent loop.

  • Conversational agents: When debugging a conversational agent, a persistent chat window allows users to exchange messages with the agent. Each message triggers a debug run.
  • Breakpoints: You can pause an agent’s execution at specific nodes by setting breakpoints. When a breakpoint is reached, the agent stops just before executing that node, allowing you to inspect its inputs, outputs, and trace data.
Form view

The Form view offers a structured, panel-based workspace for building and configuring agents through guided inputs. It provides a clear, step-by-step layout suited for precise configuration and validation of agent components.

Layout overview
  • Agent definition form: Displays the agent definition and its core components, Prompts, Tools, Contexts, and Escalations, organized in a linear, form-based structure.
  • Left-side panel: Includes the Project Explorer, Data Manager, Errors, and Deployment Configuration panels for navigating and managing project resources.
  • Right-side panel: Contains the Properties and Dev tabs, used to edit component settings, run quick tests, and view design-time traces.
  • Bottom panel: Provides access to Execution Trail, History, and Evaluations, showing debug results and evaluation metrics in real time.
Agent configuration

Each section of the form corresponds to a major agent component:

  • Prompts: Define the system and user instructions guiding agent behavior.

  • Tools: Add and configure automations, Integration Service activities, or other agents the agent can call during execution.

  • Contexts: Connect Context Grounding indexes to provide relevant data for reasoning.

  • Escalations: Set up human-in-the-loop actions and enable Agent Memory where needed.
    Figure 1. The form view

Debugging in Form view

When testing an agent in Form view, you can run debug sessions directly from the toolbar to verify logic and outputs. Design-time traces appear in the Execution Trail panel, showing inputs, outputs, and any errors for each run. For conversational agents, an integrated chat window allows you to exchange messages and observe responses in real time.

Using the Studio Web panels

The left-side panel shows you the agent structure and includes:

  • The Project Explorer – Organize and build your agent. Define prompts, tools, context, escalations, and more.
  • The Data Manager – Define input and output arguments.
  • The Errors panel – See design-time issues, broken configurations, or failed test runs.
  • The Deployment configuration panel – Set environment-specific configuration for publishing and running the agent.

The right-side panel includes:

  • The Properties panel, split between:
    • The Properties tab – Configure agent-level and component-level settings.
    • The Dev tab – Run test inputs, debug, and inspect design-time traces.
  • Agent score (Preview) – View your agent’s readiness based on evaluation results and test coverage.
  • The Run output panel – Review results from the most recent test runs.
  • Autopilot (Preview) – Get AI-powered suggestions to refine the prompts, tools, and agent setup.
Figure 2. The Agents workspace

The bottom panel makes evaluations a core part of the design experience by keeping history, results, and live traces all in one place. The available tabs depend on the type of agent you are building:

  • For autonomous agents, the bottom panel includes:
    • Execution Trail – Shows trace details from the current run. When you execute your agent, this tab opens automatically so you can follow the live traces in real time.
    • History – Displays all your agent runs with execution traces and details. From here, you can add runs directly to evaluation sets.
    • Evaluations – Lists all your evaluation sets, showing recent scores. Expand a set to see its evaluations, view details, or run tests individually or as a full set.
  • For conversational agents, the bottom panel includes:
    • Chat – Replaces the Execution Trail tab. Provides an interactive chat window to test conversations with your agent while also displaying the execution trail for each exchange.
    • History – Displays all your conversational runs with execution traces and details. From here, you can add runs directly to evaluation sets.
    • Evaluations – Lists all your evaluation sets, showing recent scores. Expand a set to see its evaluations, view details, or run tests individually or as a full set.

Creating the agent

  1. Go to studio.uipath.com.
  2. Select Create New button, then select Agent.
  3. Select the agent type:
    • Autonomous: Create an agent that acts independently to complete a given task.
    • Conversational (Preview): Create an assistant that interacts with users through real-time dialogie.
  4. If you want to create your agent from scratch, select Start fresh.
  5. If you want to generate your agent using Autopilot (Preview), describe the agent you want the create in the available message box, then select Generate Agent. Be as specific as possible, so that Autopilot can efficiently generate an agent.
  6. The new solution opens, with the Agent designer canvas displayed.

  7. When configuring your agent, you can choose between two design modes: the traditional Form view and the Flow view (Preview). Both modes share the same underlying agent definition and remain fully synchronized, so you can switch between them at any time without losing data.

    Use Form view for a structured, step-by-step configuration experience, or switch to Flow view for a visual, node-based layout that lets you see how your agent’s components connect and interact.

Configuring the agent

When configuring your agent, you can choose between two design modes: the traditional Form view and the Flow view (Preview). Both modes share the same underlying agent definition and remain fully synchronized, so you can switch between them at any time without losing data.

Use Form view for a structured, step-by-step configuration experience, or switch to Flow view for a visual, node-based layout that lets you see how your agent’s components connect and interact.

Build an agent using Form view (Default)

  1. From the docs image Project Explorer panel on the left, access the agent Definition, Evaluation sets, and Evaluators.
    Figure 3. The Agent inside a Solution

    1. The Definition panel is where you design and define the core elements of an agent. The definition contains the following sections: General, Tools, Contexts, and Escalations.
      • Use the General section to define the prompts for your agent.
      • Use the Tools section to connect runtime tools, like Integration Service connectors or published automations.
      • Use the Contexts section to link knowledge sources using Context Grounding indexes to give your agent relevant data access.
      • Use the Escalations section to set up human-in-the-loop fallbacks and enable Agent Memory to persist interactions and help calibrate future agent escalations.
    2. The Evaluation sets panel is where you create evaluations and store results. Evaluations objectively measure your agent's output and assess whether or not it is consistent with your objectives. For details, refer to Evaluations.
    3. The Evaluators panel is where you create and manage the evaluators used in evaluations.
  2. First, select your agent under Project Explorer. Right-click to select Rename, and give your agent a unique name.The agent name helps to identify the agent across projects.
  3. Next, access the Properties panel from the right-hand side menu to select the large language model you want to use with your agent.
    1. Select a model from the available dropdown list. Models are provisioned through UiPath AI Trust Layer. For details, refer to Configuring LLMs.
    2. Configure the Temperature and Max. tokens per response fields. These settings may be controlled by an Automation Ops governance policy. For details, refer to Settings for Studio Web Policies.
    • Temperature determines the creativity factor of the LLM generation. You can set a value between 0 (Precise) and 1 (Creative).
    • Max. tokens per response refers to the maximum number of tokens to generate with the agent's response.
    Figure 4. Configuring the model settings

  4. In the agent Definition panel, provide your agent with a System prompt and a User prompt.Add a well-structured prompt to give your agent instructions for what it should do, and constraints it should follow. For details, refer to Prompts.
  5. Use the Data Manager panel to define the agent input and output arguments used in the prompts.
    Figure 5. Input arguments in the Data Manager panel

  6. In the Tools section, select Add tool to add any tools your agent can use during execution.These can be a set of Integration Service activities, existing agents, and published automations to which you have access. Each tool must have a detailed description that helps inform the agent how and when to use this tool. For details, refer to Tools.
  7. (Optional) In the Contexts section, select Add context to give the agent access to Context Grounding indexes.Choose an existing index available in your tenant, or select Create new to create a new index directly in Orchestrator. For details, refer to Contexts.
  8. (Optional) In the Escalations section, select Add escalation to add a human in the loop through an escalation app and enable Agent Memory.Adding an escalation allows your agent to involve a human to review, approve, or update output as it is running. For details, refer to Escalations and Agent Memory.

Build an agent using Flow view (Preview)



  1. Open your agent project in Studio Web.
  2. In the top-right corner of the design-time canvas, select the Flow (Preview) option from the authoring mode toggle.

    • The Flow canvas opens, displaying the agent structure as nodes.

    • You can switch back to Form view at any time. All changes are saved and translated automatically between the two modes.

  3. Start with the LLM node.
    • Select it to open the Properties panel on the right, then choose and configure your model.
      • Select a model from the available dropdown list. Models are provisioned through UiPath AI Trust Layer. To learn how to use a custom model, refer to Configuring LLMs.
      • Configure the Temperature and Max. tokens per response fields. These settings may be controlled by an Automation Ops governance policy. For details, refer to Settings for Studio Web Policies.
        • Temperature determines the creativity factor of the LLM generation. You can set a value between 0 (Precise) and 1 (Creative).
        • Max. tokens per response refers to the maximum number of tokens to generate with the agent's response.
    • Once a model is selected, the node updates with the corresponding model family icon and the highlight disappears.
  4. Configure the Agent node.
    • The Agent node is created by default alongside the LLM node.
    • Open the Prompt section on the right to define your system and user prompts. For conversational agents, this section is simplified and only the system prompt is shown.
    • Open the Schema section on the left to define input and output arguments in the Data Manager panel.
  5. Add context, tools, and escalations. After completing the LLM and Agent nodes, three new node types become available:
    • Context: Select a Context Grounding index and adjust its search parameters.
    • Tools: Open the command palette, search for a deployed tool, and add it to your canvas. You can further configure each tool once added.
    • Escalations: Add a human-in-the-loop node that connects to the existing escalation configuration experience.
  6. Access additional options by selecting the ⋮ (More actions) menu on a tool node. The following actions are available:
    • Add breakpoint – Inserts a breakpoint at the tool node. When the agent is debugged, execution pauses just before this tool runs, allowing you to inspect its inputs, outputs, and trace data. Breakpoints are useful for verifying tool logic and debugging errors during design-time testing.
    • Add guardrail – Opens the Guardrail configuration window, where you can define rules that restrict or monitor how the tool is used at runtime.
    • Disable – Temporarily disables the selected tool node from agent execution. Disabled tools remain on the canvas but are skipped during runtime and debugging, allowing you to test or refine the agent’s behavior without permanently removing the tool.


  7. Debug your agent.
    • Select Debug to run your agent in design time.
    • As the agent executes, nodes light up in sequence to show the execution flow.
    • If you run simulations, nodes appear in a different color to indicate mocked data or tool calls.
    • For conversational agents, a persistent chat window allows you to test exchanges; each message triggers a debug run that displays highlights across the connected nodes.
    • You can also set breakpoints on specific nodes to pause execution and inspect inputs, outputs, and trace data.
  8. Save and publish your changes.
    • All updates in Flow view are stored automatically and remain synchronized with Form view.
    • When ready, publish the agent to make it available for testing and deployment.

Testing the agent

Now it's time to test your agent and see how you can improve it.

  1. Navigate to the toolbar above the Studio Web designer.
  2. Select the arrow next to the debugging environment, then select Debug configuration.
  3. In the Debug configuration window, confirm the resources used in the solution and the sample input.
  4. Select Save and Run.
  5. Use the test output to refine the agent design.

Evaluating the agent

Next, go to the Evaluation sets and Evaluators panels to review and measure your agent.

  1. In the Evaluation sets panel, rename the default evaluation set and add test cases with expected outcomes.
  2. In the Evaluators panel, add evaluators to validate the agent output.
Each evaluation links a known input with an assertion about the output.

Calculating the Agent score [Preview]

Select Open health score from the right-side panel to calculate the agent score. Refer to Agent score to learn how it is calculated.

Using Autopilot to improve your agent [Preview]

Select Open Autopilot from the right-side panel to receive suggestions on improving prompts, tools, and other components. Such improvements support a higher Agent Score and make your agent ready for deployment.

Publishing and deploying the agent

Once you have tested, evaluated, and refined your agent, it's time to publish it. This step is necessary for the agent to be available in the Run Job activity.

  1. Select Publish to publish the agent to Orchestrator as a process. Select where to publish:
    1. Orchestrator Personal Workspace Feed - The process is published to your personal workspace and is only be available to you. This is the default selection.
    2. Orchestrator Tenant Processes Feed - The process is published to the global tenant feed and is available to all users in eligible folders.
  2. Select a version. A version is generated automatically starting with 1.0.0 when you first publish, and then incremented automatically every time you republish.
  3. Optionally, you can select Submit as a template to make the agent available as a template in your organization, or Share, to share it with users in your organization.

Running the agent

Using agents as activities means you can incorporate them into workflows to handle parts of larger deterministic processes, have multiple agents act in series, and start agent execution based on triggers.

To incorporate your agent into a workflow, follow these steps:

  1. Publish your agent to Orchestrator.
  2. In Studio, use the Run Job activity to integrate your agent into a workflow.

  3. Whenever you make changes to your agent, republish the updated agent to Orchestrator and upgrade the corresponding process in Orchestrator.

    The Run Job activity always executes the version of the agent currently configured in Orchestrator. This ensures that your workflow consistently uses the most up-to-date version of your agent.

Refer to the System activities guide to learn how to configure and use the Run Job activity in your Studio workflows.

Note: Starting with UiPath.System.Activities version 25.4.2, the execution of agents and other Orchestrator jobs has been consolidated and improved under the Run Job activity. Existing workflows using the Run Agent activity continue to function without changes, ensuring a smooth transition. When adding new agent-running functionality to your workflows, the system automatically suggests and implements the Run Job activity, even if you search for Run Agent.

Using agent templates

You can start your agentic journey with a set of agent templates, available in the Agents page in Automation CloudTM and in UiPath® Marketplace.

An agent template comes preconfigured for specific tasks. It requires a minimum configuration to be executable in Studio, and you can modify it and tailor it to your specific needs. An agent template has:

  • Predefined components – System prompts, activity tools with descriptions, starter evaluation sets.
    • Components are generic, not company or organization-specific.
    • Components are readily available in the agent definition. Some components (such as activities as tools) may need additional configuration, like creating the necessary connections in Integration Service.
  • Components that require additional configuration – Context Grounding indexes, automations and processes as tools, custom escalations, and all affiliated descriptions (instructions for the agent).
    • These components are organization and tenant-specific.

To start using agent templates from the UiPath Marketplace, take the following steps:

  1. From the Agents page in Automation Cloud, go the Templates tab and select any template.

    You are redirected to the template from Marketplace.

  2. Select Download.
  3. In the Downloading an agent template window, select Download Solution.
    A .uis file containing the agent definition is downloaded to your machine.
  4. Agent templates also include Extras, a separate package containing assets for your agent (automations, custom escalations). Select Download Extras.
    A .zip file is downloaded to your machine.
  5. In Studio Web, import the Agent definition .uis file as described in Importing a project downloaded from Studio Web.
  6. Next, go to Solutions. For details, refer to Accessing the Solutions UI.
  7. Upload the .zip file, as explained in Transporting a solution package, then deploy the solution. For details, refer to Deploying the solution.
  8. You can now access your agent template from Studio Web and add any tools deployed to your tenant.

Was this page helpful?

Support and Services
Get The Help You Need
UiPath Academy
Learning RPA - Automation Courses
UiPath Forum
UiPath Community Forum
Uipath Logo
Trust and Security
Terms of Use
Privacy Policy
Cookies Policy
© 2005-2025 UiPath. All rights reserved.