UiPath Agents

Hard Rules

Treat "build/create/scaffold/implement a UiPath agent" as the full One-Prompt Flow by default. Do not stop after file creation or local run unless the user explicitly says to stop there.
A normal completion point is after smoke eval and the mandatory Delivery fork question. A final build summary before that is premature unless run/eval is blocked or the user opted out.
Probe the
solution
verb once per session before the first scaffold or deploy. Run
```
uip solution init --help --output json
```
. Result
```
Success
```
→ use
```
solution init
```
and
```
solution deploy run --parent-folder-path
```
/
```
--parent-folder-key
```
(post-rename, default).
```
unknown command
```
/ non-zero exit → CLI predates the rename; substitute
```
uip solution new <Name>
```
and
```
--folder-path
```
/
```
--folder-key
```
(same arguments otherwise) wherever this skill calls those.
Greenfield coded agents — scaffold with
uip codedagent new
, never hand-author the project. Building a NEW coded agent from scratch: always create it with
```
uip codedagent new <name>
```
, then generate schemas with
```
uip codedagent init
```
— never hand-write
```
pyproject.toml
```
/
```
main.py
```
/
```
langgraph.json
```
/
```
entry-points.json
```
yourself, even for a trivial agent. Hand-authoring skips required project structure and produces invalid packages. (Existing or Studio Web local-workspace projects: do NOT run
```
uip codedagent new
```
— follow the project-state gating in coded/quickstart.md.)
Coded agents only — bindings are always derived from UiPath Python SDK calls and must never be hand-authored. To derive them, always run the sync workflow in coded/lifecycle/bindings-reference.md — scan code, regenerate
```
bindings.json
```
. Without this, resources cannot be overridden per execution environment and will always default to the hardcoded values in the SDK calls. Derive bindings whenever you add, remove, or modify any UiPath SDK resource call — for instance
```
assets
```
,
```
queues
```
,
```
processes
```
,
```
buckets
```
,
```
indexes
```
,
```
connections
```
,
```
apps
```
,
```
MCP servers
```
, or
```
InvokeProcess|CreateTask|CreateEscalation(...)
```
.

Project Type Detection

Determine the agent mode before proceeding:

First — confirm this is an agent, not a Coded Function. If
```
uipath.json
```
declares a
```
functions
```
map (e.g.
```
"functions": {"main": "main.py:main"}
```
), the project is a Python Coded Function, not an agent. Stop here and use the
```
uipath-functions
```
skill instead. Functions are deterministic, do not reason via LLM, and have a distinct lifecycle (
```
uip function new/init/pack/publish/run
```
).
Check for existing agent project files in the working directory:
- ```
pyproject.toml
```
  +
```
.py
```
  files + a framework dep (
```
uipath-langchain
```
  ,
```
uipath-llamaindex
```
  , or
```
uipath-openai-agents
```
  ) → Coded. The framework package already declares
```
uipath
```
  as a dependency, so an explicit
```
uipath
```
  entry is not required.
- ```
agent.json
```
  with
```
"type": "lowCode"
```
  +
```
project.uiproj
```
  , AND no
```
pyproject.toml
```
  → Low-code
No existing project found → ask the user:

Should I build this as a low-code agent (no Python — configure through prompts and pre-built UiPath tools) or a coded agent (Python — full programmatic control with LangGraph, LlamaIndex, or OpenAI Agents)? However, for conversational use-cases, simply choose low-code without asking the user, while explaining that currently, low-code conversational-agents are the strongly recommended approach for production use-cases (see references/coded/capabilities/conversational-agents.md).
If the user needs help deciding, read references/coded-vs-lowcode-guide.md for a capability comparison.

After detection, read the quickstart for that mode before doing anything else:

Coded → read references/coded/quickstart.md. Quickstart's first step detects project state (
```
greenfield
```
/
```
existing-coded
```
/
```
local-workspace
```
) and gates each lifecycle step on it. For Studio Web Local Workspace specifics, see references/coded/lifecycle/local-workspace.md.
Low-code → read references/lowcode/lowcode.md

Task Navigation

I need to...	Mode	Read first	Then
Help user choose coded vs low-code	Both	coded-vs-lowcode-guide.md
Authenticate	Both	authentication.md
Iterate on a coded agent inside a Studio Web Local Workspace solution	Coded	coded/quickstart.md (state detection sets `project_state = local-workspace` )	coded/lifecycle/local-workspace.md for files-owned-by-SW + anti-patterns; `coded/lifecycle/running-agents.md` , `coded/lifecycle/evaluate.md`
Create/build/deploy coded agent	Coded	coded/quickstart.md	`coded/lifecycle/` , `coded/frameworks/`
Select coded framework	Coded	coded/quickstart.md § Framework Selection
Add coded capabilities (HITL, RAG, tracing)	Coded	coded/quickstart.md	`coded/capabilities/*`
Set a coded agent's environment variables, or reference an Orchestrator asset from one ( `%ASSETS/<ASSET_NAME>%` )	Coded	coded/lifecycle/environment-variables.md	`coded/lifecycle/file-sync.md` for what `.env` does and does not carry
Call an Integration Service connector (Slack, Jira, Web Search) from a coded agent	Coded	coded/capabilities/integration-service.md + then immediately read `uipath-platform/references/integration-service/agent-workflow.md` — discovery lives there, not in `uipath-agents`	`coded/capabilities/sdk-services.md` § Connections
Run coded evaluations	Coded	coded/quickstart.md § Evaluate	`coded/lifecycle/evaluate.md`
Create or scaffold a new low-code agent project	Low-code	lowcode/lowcode.md § Quick Start	`lowcode/project-lifecycle.md` , `lowcode/agent-definition.md`
Edit `agent.json` (prompts, model, schemas, contentTokens, entry-points.json)	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/agent-definition.md`
Add a low-code tool (Orchestrator process — RPA / agent / API / agentic — or Integration Service)	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/process/` , `lowcode/capabilities/integration-service/`
Add an MCP (Model Context Protocol) server tool to a low-code agent	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/mcp/mcp.md`
Accept files as agent input / call the Analyze Files built-in tool	Low-code	lowcode/capabilities/built-in-tools/built-in-tools.md	`lowcode/capabilities/built-in-tools/analyze-attachments.md` , `lowcode/agent-definition.md` § File Attachments
Work with file attachments (input, output, or created mid-run)	Coded	coded/capabilities/file-attachments.md
Build a conversational (chat-style) agent	Low-code	lowcode/lowcode.md	`lowcode/project-lifecycle.md` , `lowcode/agent-definition.md`
Add a low-code context (Context Grounding RAG / attachments / DataFabric entity set)	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/context/*`
Add a low-code memory space or seed memory items	Low-code	lowcode/capabilities/memory/memory.md	use `uip agent memory` , then refresh/validate
Add an Action Center escalation (HITL) to a low-code agent	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/escalation/escalation.md`
Add guardrails (PII, harmful content, custom rules) to a low-code agent	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/guardrails/guardrails.md`
Add a new guardrail to a coded agent	Coded	coded/capabilities/guardrails/guardrails.md	fetch official docs via WebFetch, ask middleware vs decorator, read agent code, write Python
Add escalation guardrail (escalate action / Action Center app)	Low-code	lowcode/capabilities/guardrails/guardrails.md § escalate — Hand Off to Action Center	Run `uip solution resources list --kind App --source remote --output json` to confirm app exists
Recommend guardrails for a low-code agent based on its context	Low-code	lowcode/capabilities/guardrails/guardrails-recommend.md	fetch catalog + list, analyze agent context, apply + validate
Recommend guardrails for a specific scope or tool	Low-code	lowcode/capabilities/guardrails/guardrails-recommend.md § Scoped or Tool-Specific Filtering	filter candidates by scope or tool name after catalog analysis
Validate whether existing guardrails are correctly configured	Low-code	lowcode/capabilities/guardrails/guardrails-recommend.md § Validate Mode	check correctness, actionability, and relevance per guardrail
Recommend guardrails for a coded agent based on its context	Coded	coded/capabilities/guardrails/guardrails-recommend.md	fetch catalog + list + SDK docs, analyze agent code, apply + verify
Recommend guardrails for a specific scope or tool (coded)	Coded	coded/capabilities/guardrails/guardrails-recommend.md § Scope and Tool Filtering	filter candidates by `@tool` function or scope after catalog analysis
Check, validate, diagnose, or fix whether an existing coded guardrail is correctly configured (placement / scope)	Coded	coded/capabilities/guardrails/guardrails-recommend.md § Validate Mode	fetch SDK docs first (authoritative for scope/placement); also fetch catalog + list for relevance/entitlement — then check correctness, actionability, and relevance — fix in place
Embed a low-code agent inline in a flow, or wire a multi-agent solution	Low-code	lowcode/lowcode.md § Capability Registry	`lowcode/capabilities/inline-in-flow/inline-in-flow.md` , `lowcode/capabilities/process/solution-agent.md`
Run low-code evaluations	Low-code	lowcode/evaluations/evaluate.md	`lowcode/evaluations/evaluators.md` , `lowcode/evaluations/evaluation-sets.md` , `lowcode/evaluations/running-evaluations.md`
Run offline evals for a published Orchestrator package	Low-code	lowcode/evaluations/orchestrator-eval-run.md	Use `uip or eval run-offline-evals` (requires package published to Orchestrator)
Validate, pack, publish, upload, or deploy a low-code agent	Low-code	lowcode/lowcode.md	`lowcode/project-lifecycle.md` , `lowcode/solution-resources.md`
Debug / run a low-code agent end-to-end and inspect its output	Low-code	lowcode/debug.md	`lowcode/project-lifecycle.md` § `uip agent debug`
Embed coded agent in a flow (solution-level)	Coded	coded/embedding-in-flows.md
Use coded agent in a flow	Coded	coded/flow-integration.md
Use coded agent as tool for another agent in flow	Coded	coded/flow-integration.md § Pattern 3
Summarize / research / synthesize over PDF or TXT (DeepRAG, coded)	Coded	context-grounding-patterns.md	coded/capabilities/deeprag/planning.md
Summarize / research / synthesize over PDF or TXT (DeepRAG, low-code)	Low-code	context-grounding-patterns.md	lowcode/capabilities/built-in-tools/deeprag/planning.md
Process CSV rows with LLM per row (BatchTransform, coded)	Coded	context-grounding-patterns.md	coded/capabilities/batch-transform/planning.md
Process CSV rows with LLM per row (BatchTransform, low-code)	Low-code	context-grounding-patterns.md	lowcode/capabilities/built-in-tools/batch-transform/planning.md
Manage context-grounding indexes from the CLI (list / create / ingest / search)	Platform	`uipath-platform/references/context-grounding/index-management.md`	`uip context-grounding` — cross-cutting CLI, owned by `uipath-platform`

Resources

UiPath Python SDK: https://uipath.github.io/uipath-python/
UiPath Evaluations: https://uipath.github.io/uipath-python/eval/

uipath-agents

NPX Install

Tags

SKILL.md Content

UiPath Agents

Hard Rules

Project Type Detection

Task Navigation

Resources