# Managing tools and skills

> Install, update, and remove UiPath CLI tools and skills using the built-in `uip tools` and `uip skills` commands.

Tools and skills are the two extension systems that sit beside the core `uip` host. **Tools** add commands that talk to UiPath services; **skills** teach AI coding agents how to drive those commands. Both are installed, updated, and removed through the CLI itself. This page covers the day-to-day workflows — not the conceptual split (see [Tools (plugins)](./concepts-tools.md) and [Skills](./concepts-skills.md)) and not the full command reference (see [uip tools](./uip-tools.md) and [uip skills](./uip-skills.md)).

## Tools — day-to-day

### See what's installed

```bash
uip tools list --output table
```

Returns a table of `name`, `version`, `commandPrefix`. Use this to spot drift between a developer laptop and a build server.

To capture a snapshot you can diff later:

```bash
uip tools list --output json --output-filter "Data[*].{name: name, version: version}" > tools.json
```

### Install a tool

Three identifier forms work — pick whichever reads best in context:

```bash
uip tools install or                                # alias (shortest)
uip tools install orchestrator-tool                 # short name
uip tools install @uipath/orchestrator-tool         # full npm name
```

Explicit version (for CI reproducibility):

```bash
uip tools install orchestrator-tool@1.0.2
```

Preview channel:

```bash
uip tools install flow-tool@beta
```

In CI, always install the tools you need as a dedicated step — auto-install pays a one-time download cost on whichever command runs first, and there is no env-var opt-out ([details](./installing-uipath-cli.md#controlling-tool-auto-install)):

```bash
uip tools install @uipath/orchestrator-tool \
                  @uipath/solution-tool \
                  @uipath/test-manager-tool
```

### Upgrade tools after a CLI bump

When you upgrade `@uipath/cli`, installed tools stay at their previous version. Run `uip tools update` to bring them to the latest version within the CLI's new MAJOR.MINOR line:

```bash
npm install -g @uipath/cli@1.1.0
uip tools update
```

Update a single tool:

```bash
uip tools update --name orchestrator-tool
```

Pin a specific tool to an exact version:

```bash
uip tools update --name orchestrator-tool --version 1.0.3
```

The `Data` in `UpdateResult` gives you per-tool `from` → `to` diffs — useful for audit logs.

:::tip
**Refresh shell completion after an upgrade**

The shell-completion script is a static snapshot of the verbs and flags known when `uip completion` last ran. After `npm install -g @uipath/cli@<new>`, `uip tools install`, or `uip tools update`, re-run `uip completion` so newly added commands and flags appear in `<TAB>`. See [uip completion — Static snapshot](./uip-completion.md#static-snapshot-re-run-after-every-upgrade).
:::

### Remove a tool

```bash
uip tools uninstall or
```

After uninstall, the next `uip or …` invocation will trigger auto-install again unless auto-install is blocked (offline runner, whitelist pinning). To keep a tool gone on a stateless runner, pre-install only the tools you want and don't call the uninstalled ones.

### Audit drift between environments

On each environment, capture the installed set:

```bash
uip tools list --output json --output-filter "Data[*].{name: name, version: version}" | jq -S . > tools.$(hostname).json
```

Diff the files across environments. Any delta is a source of "works on my machine" — resolve by pinning in CI.

## Skills — day-to-day

### See what's installed

```bash
ls ~/.uipath/.skills         # the on-disk skill catalog cache
cat ~/.uipath/.skills/manifest.json   # manifest of installed skills per agent
```

For a local install, the store lives under the project root at `./.uipath/.skills/`. Alternatively, ask an agent to list its installed skills — every supported agent exposes this through its own UI / command.

### Install skills into a coding agent

By agent:

```bash
uip skills install --agent claude        # Claude Code (global only)
uip skills install --agent cursor        # Cursor
uip skills install --agent copilot       # GitHub Copilot
uip skills install --agent gemini        # Gemini CLI
uip skills install --agent codex         # Codex
uip skills install --agent opencode      # OpenCode
```

Interactively (multi-select via checkbox):

```bash
uip skills install
```

Scope:

- Default is **global** — installed into the agent's user profile. Available everywhere the agent runs.
- `--local` installs into the current directory instead. Good for project-pinned skills or when you don't want to clutter the user profile. **Claude Code is global-only** — passing `--local` with `--agent claude` errors out.

### Keep skills fresh

`uip skills update` re-fetches the UiPath skills catalog and reinstalls:

```bash
uip skills update --agent claude
```

Update also removes skills that have disappeared from the remote catalog since the last install — agents stay in step with UiPath's released set.

### Remove skills

```bash
uip skills uninstall --agent claude
```

Does not remove the agent itself, and does not affect other agents' skills. Run once per agent you want to remove skills from.

## Combining tools and skills in a project

A common pattern for a repository that uses AI coding agents for UiPath work:

1. Pin `@uipath/cli` in project documentation (not in `package.json` — the CLI is a dev dependency on the operator's machine, not a project runtime dep).
2. Document the External Application and tenant the project targets in your README. Each contributor sets the corresponding environment variables on their machine and signs in with `uip login`.
3. Install the project-relevant tools on each contributor's machine:
   ```bash
   uip tools install or solution tm
   ```
4. Install skills locally for the coding agent used by the project:
   ```bash
   uip skills install --agent cursor --local
   ```
5. Add the local skills-store directory to `.gitignore` (the install command prints the path on first run).

Agents running in the repo authenticate with the contributor's session, the skills teach them how to use `uip`, and the pinned tools keep builds reproducible.

## When things go wrong

### A tool's commands don't show up in uip --help

Either the tool isn't installed or it failed to load. Check:

```bash
uip tools list                  # is it installed?
uip --log-level debug or folders list   # what does the host say during tool load?
```

A tool that loads with an error is skipped silently by the completion tree and by the command dispatcher.

### A tool is installed but commands fail with "unknown option"

Likely a version mismatch — the tool was built against a different CLI minor line. Fix with `uip tools update --name <tool>`.

### Skills don't show up in my coding agent

Each agent handles skill files through its own plugin / rules system. After `uip skills install --agent <name>`:

- **Claude Code** — restart Claude Code; skills appear under the plugin picker.
- **Cursor** — skills auto-load on next conversation; check `~/.cursor/skills/` (global) or `./.cursor/skills/` (local).
- **GitHub Copilot** — open the Copilot panel; skills live under `~/.github/skills/` (global) or `./.github/skills/` (local).
- **Gemini CLI** — skills are written to `~/.gemini/skills/` or `./.gemini/skills/`.
- **Codex** — skills are written to `~/.agents/skills/` or `./.agents/skills/` (the open Agent Skills standard directory).
- **OpenCode** — skills are written to `~/.config/opencode/skills/` (global) or `./.opencode/skills/` (local).

Run `uip skills install --agent <name> --print` (or the equivalent checkbox in interactive mode) to see the exact destination.

## See also

- [Tools (plugins)](./concepts-tools.md) — the host-plus-plugins model.
- [Skills](./concepts-skills.md) — the AI-agent extension system.
- [uip tools reference](./uip-tools.md) — full flag list.
- [uip skills reference](./uip-skills.md) — full flag list.
- [Installing UiPath CLI — Controlling tool auto-install](./installing-uipath-cli.md#controlling-tool-auto-install) — how auto-install behaves in CI.
- [Using UiPath CLI with Coding Agents](https://docs.uipath.com/coding-agents/standalone/latest/user-guide/overview) — per-agent setup walkthroughs.