UiPath Documentation
getting-started
latest
false
Getting started developer guide
  • Introduction
    • Overview
    • Environment set up
  • Getting Started with UiPath Agents
  • Getting Started with UiPath Agents using LangGraph
  • Building a Low-Code Agent in Studio Web
    • Introduction
    • Build the agent
    • Test the agent
    • Evaluate the agent
  • Adding Tools to Your UiPath Agent
  • Getting Started with the Flow canvas in UiPath Maestro

Build the agent

Use Autopilot to generate the agent configuration, then review and refine the system prompt, inputs, and outputs.

Create an agent project in Studio Web and let Autopilot generate its system prompt, input schema, and output schema from a plain-language description. Then check the generated configuration against the input and outputs the rest of this lab depends on.

Step 1 - Open Studio Web​

Open Studio Web and start a new agent project from your Cloud Workspace.

  1. Log in to UiPath Automation Cloud.
  2. Open Studio Web from the left navigation. Your Cloud Workspace opens, showing your existing solutions and a Create New button.
  3. Open the drop-down menu next to Create New.
  4. Select Agent from the list of project types.


Step 2 - Generate the agent with Autopilot​

Autopilot in Studio Web can configure an agent from a plain-language description. You describe what you want, and Autopilot proposes the system prompt, input schema, and output schema.

  1. Select Autonomous as the agent type.

  2. In the What should your agent do? field, paste the following description:

Build an autonomous agent that classifies quests for a fantasy RPG Adventurer's Guild. Keep it simple: build the system prompt and input/output schemas only. You do not need to add any tools, contexts, or escalations.

Given a quest description, the agent should consider the quest, what monster the party is likely to face while completing the quest, and then classify the quest's difficulty as one of four tiers:
- Trivial: simple errands anyone can handle (e.g., deliver a letter, clear rats from a cellar)
- Standard: moderate quests requiring some adventuring skill (e.g., escort a merchant caravan, hunt a wyvern, drive back the kobolds)
- Heroic: difficult quests requiring significant adventuring expertise (e.g., slay an adult dragon, infiltrate a thieves' guild)
- Legendary: extreme quests requiring top-tier heroes to complete (e.g., defeat a lich, slay an ancient dragon)

Return the tier and a brief, two-sentence reasoning. Use these exact field names:
- Input: questDescription (string, required)
- Outputs: tier (string, restricted to exactly "Trivial", "Standard", "Heroic", or "Legendary", so the agent can't return any other value) and reasoning (string)
Build an autonomous agent that classifies quests for a fantasy RPG Adventurer's Guild. Keep it simple: build the system prompt and input/output schemas only. You do not need to add any tools, contexts, or escalations.

Given a quest description, the agent should consider the quest, what monster the party is likely to face while completing the quest, and then classify the quest's difficulty as one of four tiers:
- Trivial: simple errands anyone can handle (e.g., deliver a letter, clear rats from a cellar)
- Standard: moderate quests requiring some adventuring skill (e.g., escort a merchant caravan, hunt a wyvern, drive back the kobolds)
- Heroic: difficult quests requiring significant adventuring expertise (e.g., slay an adult dragon, infiltrate a thieves' guild)
- Legendary: extreme quests requiring top-tier heroes to complete (e.g., defeat a lich, slay an ancient dragon)

Return the tier and a brief, two-sentence reasoning. Use these exact field names:
- Input: questDescription (string, required)
- Outputs: tier (string, restricted to exactly "Trivial", "Standard", "Heroic", or "Legendary", so the agent can't return any other value) and reasoning (string)
  1. Select Generate Agent.

  2. Review the suggestions in the Autopilot window. Autopilot walks you through building and configuring the agent from the prompt you gave it.

  3. Accept the suggestions to create the agent.

The prompt is structured on purpose, and each part does a job:

  • Exclusions up front. Telling Autopilot not to add tools, contexts, or escalations keeps the agent minimal, so every part of it is something you asked for.
  • Tiers as a list. One tier per line, each with examples, gives Autopilot clear boundaries to copy into the system prompt.
  • Exact field names on their own lines. Autopilot uses these names verbatim in the schema, and the evaluation set you build later depends on them.
  • A constraint with its reason. Restricting tier to four values, and saying why, stops the agent from inventing a fifth tier such as "Moderate".
Important:

Autopilot is non-deterministic, so your generated configuration can differ from the screenshots. Continue when the agent canvas loads with the questDescription input and the tier and reasoning outputs. If the canvas shows an error or fails to load, refresh the page and repeat this step.


Step 3 - Review the agent canvas​

Check that Autopilot built the input, outputs, and tier values that the rest of this lab depends on, and correct anything that is missing or extra.

  1. When the Agent Canvas opens, select the agent node to open its Properties panel. You can also open properties using the wrench icon in the upper-right corner of the canvas.
  2. Check the following in the generated configuration:
    • Input - questDescription (string) is listed.
    • Outputs - tier (string) and reasoning (string) are listed.
    • System prompt - describes the four tiers with an example of each.
  3. Open the Data Manager (the clipboard icon along the left rail).
  4. Select the tier output.
  5. Check that the four values are exactly Trivial, Standard, Heroic, and Legendary. Depending on how Autopilot generated the schema, the values appear either as a list of allowed values or in the field description. Either works.
  6. If the list or description is missing a tier, or adds one, edit it.

Refine the system prompt (optional)​

Autopilot generates a working system prompt from your description, but its wording varies from run to run. If you want consistent results that match the expected outputs in this lab, replace the system prompt in the Properties panel with the following:

You are a quest intake classifier for an adventurer's guild in a fantasy RPG world.

Classify the incoming quest description into exactly one difficulty tier:
- Trivial: simple errands anyone can handle (for example, deliver a letter, clear rats from a cellar)
- Standard: moderate quests requiring some adventuring skill (for example, escort a merchant caravan, hunt a wyvern, drive back the kobolds)
- Heroic: difficult quests requiring significant adventuring expertise (for example, slay an adult dragon, infiltrate a thieves' guild)
- Legendary: extreme quests requiring top-tier heroes to complete (for example, defeat a lich, slay an ancient dragon)

Consider the quest and the creatures the adventurers are likely to face. If no monster is stated, infer only a reasonable threat from the description and say when it is uncertain.

Return the tier and a brief, two-sentence reasoning.
- `tier` must be exactly one of "Trivial", "Standard", "Heroic", or "Legendary"; never return another value.
- `reasoning` must be exactly two concise sentences and mention both the quest's challenge and the likely monster or threat.
- Never add markdown, extra keys, or extra text.

Final reminder: make one consistent tier decision and return exactly two sentences of reasoning.
You are a quest intake classifier for an adventurer's guild in a fantasy RPG world.

Classify the incoming quest description into exactly one difficulty tier:
- Trivial: simple errands anyone can handle (for example, deliver a letter, clear rats from a cellar)
- Standard: moderate quests requiring some adventuring skill (for example, escort a merchant caravan, hunt a wyvern, drive back the kobolds)
- Heroic: difficult quests requiring significant adventuring expertise (for example, slay an adult dragon, infiltrate a thieves' guild)
- Legendary: extreme quests requiring top-tier heroes to complete (for example, defeat a lich, slay an ancient dragon)

Consider the quest and the creatures the adventurers are likely to face. If no monster is stated, infer only a reasonable threat from the description and say when it is uncertain.

Return the tier and a brief, two-sentence reasoning.
- `tier` must be exactly one of "Trivial", "Standard", "Heroic", or "Legendary"; never return another value.
- `reasoning` must be exactly two concise sentences and mention both the quest's challenge and the likely monster or threat.
- Never add markdown, extra keys, or extra text.

Final reminder: make one consistent tier decision and return exactly two sentences of reasoning.

With the agent configured, you can test it against real quest descriptions in the next section.

  • Step 1 - Open Studio Web​
  • Step 2 - Generate the agent with Autopilot​
  • Step 3 - Review the agent canvas​
  • Refine the system prompt (optional)​

Was this page helpful?

Connect

Need help? Support(opens in new window)

Want to learn? UiPath Academy(opens in new window)

Have questions? UiPath Forum(opens in new window)

Stay updated