Build low-code agents with Coding Agents

A coding agent with UiPath skills installed can scaffold, configure, validate, and publish UiPath low-code agents entirely from your terminal — no browser required after initial login. You describe the agent you want to build, the coding agent creates and iterates the project files, and uploads the result to Studio Web.

For setup (installing the agent, logging in, installing skills), see Install and set up.

Requisitos previos

• The uipath-agents skill installed for your coding agent. See Install and set up.
• Una sesión iniciada (uip login).

Qué puede hacer el agente

Each row covers one stage of the agent lifecycle. The coding agent picks the right uip agent commands from the installed skill — you state the outcome, not the command.

Área	Qué puede hacer el agente	Ejemplo de solicitud
Scaffold	Create a new agent project with the full directory structure, including agent.json, input/output schemas, and default evaluation sets	"Create a new sentiment analysis agent for social media inbound comments."
Configure prompts and schemas	Edit the system prompt, user message template, input/output schemas, and LLM model settings in agent.json	"Update the system prompt to handle invoice data and add a confidence field to the output schema."
Add and manage tools	Add RPA processes, other agents, API workflows, Maestro flows, Integration Service connector tools, context grounding, and escalation apps	"Add a SharePoint search tool and an RPA process for document validation."
Refresh and validate	Run uip agent refresh to write artifacts and sync entry-point schemas, then uip agent validate to check JSON structure (read-only); fix errors automatically	"Validate the agent and fix any errors."
Upload and download	Upload the local project to Studio Web (uip solution upload) or download an existing Studio Web solution to edit locally (uip solution download)	"Upload the agent to Studio Web so I can review it."
Evaluar	Create evaluation sets and test cases, run them against the Agent Runtime, and review scores and execution traces	"Run the regression eval set and show me which test cases scored below 0.7."
Pack and deploy	Package and publish the solution via uip solution pack and uip solution publish, deploy it as a process, and start a job	"Deploy the invoice agent to the Production folder."

The build loop

The coding agent follows this cycle when building or iterating on a low-code agent:

Scaffold > Configure > Add resources > Refresh > Validate > Fix > Upload

1. Scaffold — create the solution with uip solution init, then scaffold the agent with uip agent init.

2. Configure — set the prompts, schemas, and model settings in agent.json.

3. Add resources — create a resource.json file under resources/<tool-name>/ for each tool the agent needs.

4. Refresh — write artifacts and sync entry-point schemas with uip agent refresh.

5. Validate — check JSON structure with uip agent validate (read-only).

6. Fix — correct any validation errors, then loop back to Refresh. Multiple cycles are expected and normal.

7. Upload — once the project is clean, upload it to Studio Web with uip solution upload.

Result: The agent project is now visible in Studio Web and available for review, evaluation, or deployment.

Agent project structure

When the coding agent runs uip solution init and uip agent init, it creates the following structure:

<AgentName>/
├── agent.json               # System prompt, user message template, LLM settings, input/output schemas
├── project.json             # Project metadata
├── entry-points.json        # Entry point definitions, kept in sync with agent.json schemas
├── bindings_v2.json         # Resource binding references
├── SolutionStorage.json     # Written after push — captures the Studio Web solution ID
│
├── resources/               # One directory per tool
│   └── <tool-name>/
│       └── resource.json    # Tool config: type, connector key, schema, connection ID
│
├── connections/             # Connection references for bound Integration Service tools
│
├── evals/                   # Evaluation configuration
│   ├── evaluators/          # Evaluator definitions (semantic similarity, trajectory by default)
│   └── eval-sets/           # Test case collections
│
└── userProfile/
    └── debug_overwrites.json  # Local connection overrides for debugging

Tool types

The coding agent registers tool types by directly authoring resource.json files under resources/<tool-name>/. The type field in each file determines the tool type. Runtime execution support varies — some types can be registered for Studio Web compatibility but do not yet execute on the agent runtime.

Tipo de herramienta	resource.json Tipo	Executes on agent runtime
Conector de Integration Service	integration	Sí
Orchestrator process (RPA)	process	Yes (non-interactive)
Sub-agent	agent	Sí
Flujo de trabajo de API	api	Registration only
Maestro flow	processOrchestration	Registration only
IXP (Document Processing)	ixp	Registration only

Context grounding, escalation apps, and MCP servers are added as separate solution resources rather than tool-type resource.json files. The coding agent authors them and syncs them into the project with uip solution resources refresh.

Example builds

Open your coding agent and describe the agent you want. The agent loads the UiPath Agents skill and handles the rest.

What to ask	What gets built
"Create a new sentiment analysis agent for social media inbound comments."	Standalone agent with a custom system prompt and structured input/output schemas
"Add a social media manager agent that delegates to the sentiment analysis agent to handle a batch of inbound comments."	Multi-agent solution with a manager agent using the sentiment analysis agent as a tool
"Build me a flow with an AI agent for drafting professional emails."	Flow project with an inline agent node connected to start and end nodes

Evaluating your agent

The coding agent can drive a full build-evaluate-improve loop:

1. Build and configure the agent locally.
2. Upload to Studio Web (uip solution upload) — evaluations run against the agent runtime and require the project to be uploaded first.
3. Run an evaluation set and wait for results.
4. Review per-test-case scores, execution traces, and failure messages.
5. Adjust prompts or configuration based on failures.
6. Upload the updated agent (uip solution upload).
7. Re-run the evaluation set.

Result: The evaluation run completes successfully, with scores visible for each test case and clear indications of which cases passed or failed.

Example asks:

• "Create an evaluation set called regression-tests with five test cases covering the main invoice input scenarios."
• "Run the regression-tests eval set and show the results."
• "The third test case failed with a low trajectory score — update the system prompt to make the tool selection more explicit and re-run."

The following evaluator types are available:

Evaluator	Qué mide
Similitud semántica	Compares expected output to actual output semantically
Trayectoria	Checks whether the agent followed expected tool usage and reasoning steps
Precisión del contexto	Scores relevance of retrieved context to the query
Fidelidad	Scores whether agent responses are grounded in provided context

Ver también

• Install and set up — agent setup and skills install.
• Build coded agents with Coding Agents — Python-based coded agents from a coding agent terminal.
• Skills overview — the skill model that drives this behavior.
• uip agent reference — full command reference for agent lifecycle, tools, evaluations, push, pull, and deploy.