# Skills > Skills concept in UiPath CLI, explaining how skills differ from tools and how coding agents install and use them. Skills are instruction packages that teach AI coding agents how to build UiPath automations with `uip`. They are **not tools**. Tools extend the CLI with new commands; skills extend a coding agent with UiPath-specific knowledge. A developer types `uip or jobs start`; a coding agent that has a skill installed knows *when* to reach for that command, what inputs it needs, and how to sequence it with `uip solution pack`, `uip or packages upload`, and the rest. ## What is a skill A skill is a bundle of Markdown files — instructions, examples, decision rules — that an agent reads alongside your conversation to decide how to accomplish a UiPath task. The bundle covers patterns like "how to pack and deploy a Studio project", "how to run a test set in CI", or "how to configure an Orchestrator trigger from the command line". The agent uses the skill the same way a developer would use documentation, except the skill is narrowly scoped to the tasks the skill author considered relevant. UiPath publishes a skill catalog on GitHub. `uip skills install` downloads the whole catalog and installs it into the agents you choose. ## Supported agents The following coding agents are supported today: | Agent | Flag value | Install location | |---|---|---| | Claude Code (plugin) | `claude` | Managed by the Claude Code plugin system — global only | | Cursor | `cursor` | `~/.cursor/skills//` (global) or `./.cursor/skills//` (local) | | GitHub Copilot | `copilot` | `~/.github/skills//` (global) or `./.github/skills//` (local) | | Gemini CLI | `gemini` | `~/.gemini/skills//` (global) or `./.gemini/skills//` (local) | | Codex | `codex` | `~/.agents/skills//` (global) or `./.agents/skills//` (local) — the open Agent Skills standard directory | | OpenCode | `opencode` | `~/.config/opencode/skills//` (global) or `./.opencode/skills//` (local) | Exact destinations are printed by `uip skills install --agent ` before any files are written. Run `uip skills --help` to see the live table for your installation. ## Granularity: agents, not skills `uip skills install` is **all-or-nothing on the skill catalog**. You pick one or more *agents*, and the CLI installs every skill UiPath currently publishes into each of those agents. You do not pick individual skills. Why: the skill set is small enough that cherry-picking would produce more inconsistency than benefit, and the agent itself decides which skill applies to a given task based on its own reasoning — the skill catalog is effectively a reference the agent consults when a task is UiPath-related. Providing the agent with extra skills it will not use has low overhead. What you *do* pick: - **Which agents** (via `--agent `, or interactively from a checkbox when the flag is omitted — multi-select). - **Global or local scope** (via `--local`, where the agent supports it). ## Global versus local installs Two scopes: - **Global** (default) — skills are installed once per user, on the user's agent profile. Available in every project on that machine. - **Local** (`--local`) — skills are installed into the current directory. Tracked alongside the project; available only when the agent is running in that directory. Use local for a project that pins skills to a specific UiPath CLI version, or for a repo where a specific set of skills should ship to every contributor regardless of what they have installed globally. :::note Not every agent supports `--local`. **Claude Code** is global-only (the Claude Code plugin system is user-scoped); running `uip skills install --agent claude --local` produces a `ValidationError`. The other five agents support both scopes. ::: When you run `uip skills install --local`, the CLI also adds the on-disk store (`.uipath/.skills/`, under the walk-up root) to `.gitignore` so cached skill bundles are not committed. ## Installing, updating, uninstalling Three commands manage the lifecycle: ```bash uip skills install --agent claude # install globally for Claude Code uip skills install --agent cursor --local # install into this project for Cursor uip skills install # interactive: pick agents from a checkbox uip skills update --agent claude # re-fetch and reinstall uip skills uninstall --agent claude # remove skills for Claude Code only ``` All three prompt for the target agent interactively when `--agent` is omitted, which is convenient at a workstation and a problem in CI — always pass the flag in pipelines. `update` also removes skills that have been dropped from the remote catalog since your last install, so an installed agent tracks the catalog as it evolves. Per-agent skill files are written or overwritten on install and update. ## How the agent uses the skills Once installed, each agent reads skill files through its own mechanism: - **Claude Code** loads skills via the plugin system — they become tool-use plugins the agent can invoke. - **Cursor**, **Gemini CLI**, **Codex**, **OpenCode** load skill Markdown as context rules attached to every conversation. - **GitHub Copilot** reads skills from its user-rules directory. From the developer's perspective, the difference is invisible. You ask the agent "pack and deploy this project", and if a skill covers it, the agent follows the recipe — calling `uip solution pack`, `uip solution publish`, `uip solution deploy run` in order, handling flag selection, and reporting back. ## What skills are not - **Skills do not replace documentation.** They distill task-oriented recipes; the full reference lives in the `uip` docs (this site). An agent with skills still benefits from reading per-command reference pages. - **Skills do not give the agent access to your UiPath tenant.** They instruct the agent how to use `uip`; actual authentication happens via `uip login` on your machine the same as when you run commands yourself. - **Skills are not tools.** `uip tools` and `uip skills` are distinct command groups. Tools ship commands; skills teach agents how to use them. - **Skills are not Model Context Protocol (MCP) servers.** `uip mcp` exposes a separate MCP surface for MCP-aware clients. The skills system is the primary AI integration path in 1.x; MCP is available for specialized setups but is not the primary integration. ## What to read next - **[Using UiPath CLI with Coding Agents](./coding-agents.md)** — walkthroughs for setting up each agent, verifying the install, and running a task end-to-end. - **[uip skills reference](./uip-skills.md)** — flags, exit codes, and full examples. - **[Managing tools and skills](./managing-tools-and-skills.md)** — day-to-day lifecycle, pinning, auditing what is installed. - **[Tools (plugins)](./concepts-tools.md)** — the other extension mechanism; explains the distinction between "tools" and "skills".