# Using UiPath CLI with Coding Agents

> AI coding agents — Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, OpenCode — can build and operate UiPath automations using `uip` the same way a developer does. You teach them by installing **skills**: task-oriented instruction bundles published by UiPath. Once a skill is installed, the agent knows when to pack a Solution, how to chain `publish` with `deploy run`, when to wait for a job, how to inspect an Orchestrator folder — the whole surface, not just command names.

AI coding agents — Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, OpenCode — can build and operate UiPath automations using `uip` the same way a developer does. You teach them by installing **skills**: task-oriented instruction bundles published by UiPath. Once a skill is installed, the agent knows when to pack a Solution, how to chain `publish` with `deploy run`, when to wait for a job, how to inspect an Orchestrator folder — the whole surface, not just command names.

This page walks through set-up per agent: install the agent's own CLI, log in to UiPath, install skills, and verify the install.

## Prerequisites

All supported agents share the same prerequisites:

1. **`@uipath/cli` installed** on your machine. See [Installing UiPath CLI](./installing-uipath-cli.md).
2. **A logged-in session.** Run `uip login` once; skills use the same session the rest of the CLI uses. See [Authentication](./authentication.md).
3. **The coding agent installed.** Each section below links to the agent's installer.

You do not need to install UiPath tools (`uip tools install …`) before installing skills — the agent can auto-install them on first use.

## Pick an agent

| Agent | `--agent` value | Scope support | Notes |
|---|---|---|---|
| Claude Code (plugin) | `claude` | Global only | Skills install as Claude Code plugins; the plugin system is user-scoped, no project option. |
| Cursor | `cursor` | Global or local | Skills are installed to `.cursor/skills/<skill>/`; Cursor loads them per-workspace. |
| GitHub Copilot | `copilot` | Global or local | Skills are installed to `.github/skills/<skill>/`; Copilot loads them as custom instructions. |
| Gemini CLI | `gemini` | Global or local | Skills are installed to `.gemini/skills/<skill>/`. |
| Codex | `codex` | Global or local | Skills are installed to `.agents/skills/<skill>/` — the open Agent Skills standard directory. |
| OpenCode | `opencode` | Global or local | Skills are installed to `.opencode/skills/<skill>/` (local) or `~/.config/opencode/skills/<skill>/` (global). |

See [Skills](./concepts-skills.md) for the model and [uip skills reference](./uip-skills.md) for the full flag surface.

## Claude Code

### Install the agent

See [claude.com/claude-code](https://claude.com/claude-code) for installation. On macOS/Linux, the common path is `curl -fsSL https://claude.ai/install.sh | bash`.

### Install skills

```bash
uip skills install --agent claude
```

Claude Code is **global-only** for skills. Passing `--local` errors out with a `ValidationError`.

### Verify

Open Claude Code. Ask: "Pack this Solution and deploy it to the Shared folder." The agent should propose `uip solution pack` → `uip solution publish` → `uip solution deploy run` — the canonical flow.

If the agent does not recognize UiPath-specific tasks, restart Claude Code so it reloads plugins, then retry.

## Cursor

### Install the agent

See [cursor.com](https://cursor.com) for installation.

### Install skills

Global (available in every workspace):

```bash
uip skills install --agent cursor
```

Per-project (tracked alongside your repo):

```bash
cd /path/to/project
uip skills install --agent cursor --local
```

Local installs add the skills store directory to `.gitignore` automatically — cached skill bundles stay out of commits.

### Verify

Open Cursor in the repo. In the Composer, ask: "Create a new UiPath Agent project and pack it." The agent should propose `uip agent init` → `uip agent validate` → `uip agent pack`.

## GitHub Copilot

### Install the agent

GitHub Copilot is a VS Code / JetBrains / Visual Studio plugin. See [github.com/features/copilot](https://github.com/features/copilot).

### Install skills

```bash
uip skills install --agent copilot
```

(Add `--local` for per-repo rules.)

### Verify

Open a project in VS Code (or your supported editor) and open the Copilot Chat panel. Ask a UiPath-specific task. Copilot should cite the installed skill rules when composing its response.

## Gemini CLI

### Install the agent

See [github.com/google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli).

### Install skills

```bash
uip skills install --agent gemini
```

(Add `--local` for project-scoped skills.)

### Verify

Run `gemini` in the repo. Ask for a UiPath task and check that it proposes `uip` commands from the installed skills.

## Codex

### Install the agent

See OpenAI's Codex installation instructions.

### Install skills

```bash
uip skills install --agent codex
```

### Verify

Start Codex. Ask for a UiPath task; the skills should guide it to the correct `uip` command chain.

## OpenCode

### Install the agent

See [opencode.ai](https://opencode.ai).

### Install skills

```bash
uip skills install --agent opencode
```

### Verify

Launch OpenCode in the project directory. Check `~/.config/opencode/skills/` (global) or `./.opencode/skills/` (local) for the installed skill files.

## Working with agents in practice

### Let the agent drive — do not specify every command

Skills encode the *sequence* of commands to use. Ask for outcomes ("deploy this Solution to production"), not specific commands. The agent will chain `pack` → `publish` → `deploy run` (or ask you to confirm each step, depending on the agent's mode).

### Share your session

Agents run `uip` on your machine, using the session `uip login` set up. If you are logged in as a personal account, the agent acts as you. Use an External App session (Flow 2 in [Authentication](./authentication.md)) if you want the agent bound to a service identity instead.

### Keep skills and tools in step

After a CLI upgrade, also run `uip skills update --agent <name>` to pick up any newly-published skills and `uip tools update` to bring tools to the matching MAJOR.MINOR line. See [Managing tools and skills](./managing-tools-and-skills.md).

### When the agent gets stuck

Ask the agent to run `uip <command> --help` and feed the output back into the conversation. The built-in help is authoritative and covers flags that skills may not yet describe. Agents typically recover on their own once given the help output.

## MCP (alternative path)

For MCP-aware clients that are not on the supported-agents list, UiPath CLI ships an MCP server via `uip mcp`. It exposes one tool, `run_command`, that lets the client execute any `uip` command. This is **not** the primary AI path for UiPath — skills are — but it is available for integrations that already speak MCP. See [uip mcp reference](./uip-mcp.md).

## See also

- [Skills](./concepts-skills.md) — what skills are, the supported agents, and the granularity model.
- [uip skills reference](./uip-skills.md) — flag reference.
- [Managing tools and skills](./managing-tools-and-skills.md) — day-to-day maintenance.
- [Installing UiPath CLI](./installing-uipath-cli.md) — one-time setup.
- [Authentication](./authentication.md) — session flows the agents inherit.

## Disclaimer

The Coding Agent does not validate the compliance of any code it generates, operational commands it executes, or troubleshooting actions it recommends — you are responsible for reviewing all generated code, operational changes, and diagnostic outputs before applying them to production. To use it responsibly: authenticate with a dedicated token scoped to minimal permissions (not your full access) for cleaner audit trails; run in attended mode to keep a human in the loop; ensure third-party agent guardrails are configured to limit scope and prevent unexpected behavior across coding, operational, and troubleshooting workflows; verify that any personal data processing complies with your organization's policies and data protection requirements; and maintain human oversight at every internal control or approval point — especially before executing operational changes or acting on troubleshooting recommendations that could affect live environments.