---
title: "AI agent skills"
description: "Install the skill of UnderAutomation.Robotics in Claude Code, Codex, GitHub Copilot or Cursor, for C# or Python. The agent then answers with the documentation, the routes of each brand and the Python or C# names of your library version."
---

# AI agent skills

This page explains how to install the agent skill of UnderAutomation.Robotics in an AI coding agent: Claude Code, Codex, GitHub Copilot, Cursor and about 70 other agents that read skills. There is one skill for C# and one for Python, and each skill documents one version of the library.

## What the skill does

A skill is a folder with a `SKILL.md` file and reference files. The agent loads it when a question or a task is about UnderAutomation.Robotics or its common API, `RobotController`. The skill contains:

- the pages of this documentation, with the code samples in the language of the skill;
- the routes of each method on each brand, and what each route needs on the controller;
- the exceptions of the common API and what to check;
- the rules of the routing, the native names of each brand, the motion safety rules, and the rules that stop the agent from inventing members.

With the skill, the agent answers questions such as "why do I get a `RouteUnavailableException`?" or "which protocol starts a program on my Yaskawa controller?", and writes code such as "read R[5] on my Fanuc and the same on my Yaskawa".

The skill does not list every type and member of the library yet: it gives the members of the pages and the code samples, and tells the agent to read the XML documentation of the NuGet package or the installed Python package for the others.

| Language    | Skill                             | Plugin            | Package                          |
| ----------- | --------------------------------- | ----------------- | -------------------------------- |
| C# and .NET | `underautomation-robotics-csharp` | `robotics-csharp` | NuGet `UnderAutomation.Robotics` |
| Python      | `underautomation-robotics-python` | `robotics-python` | pip `UnderAutomation.Robotics`   |

Install the skill of the language of your project only: the .NET API uses PascalCase and the Python API uses snake_case. The skills are generated from this documentation at each release of the library and published in the repository [underautomation/skills](https://github.com/underautomation/skills), under the MIT license. Installing a skill does not give a license of a brand: see [Licensing](/robotics/documentation/license).

## Ask your agent to install it

Open your agent in the folder of your project and paste this prompt:

```plaintext
Install the UnderAutomation Robotics skill: follow https://underautomation.com/robotics/documentation/ai-skills.md
```

The agent reads the Markdown version of this page and follows its last section, "Instructions for AI agents". It finds the language of the project, installs the skill and checks its version. It asks a question only when the project has no C# or Python file to find the language.

You can also install the skill yourself, with one of the 4 methods below. Replace `csharp` with `python` for the Python skill.

## Install with Claude Code

```bash
claude plugin marketplace add underautomation/skills
claude plugin install robotics-csharp@underautomation
```

Inside a Claude Code session, the same commands are `/plugin marketplace add underautomation/skills` and `/plugin install robotics-csharp@underautomation`. Add `--scope project` to `claude plugin install` to share the plugin with the other developers of the project.

## Install with Codex

```bash
codex plugin marketplace add underautomation/skills
```

Then open Codex, run `/plugins`, select the UnderAutomation marketplace and install `robotics-csharp`.

## Install with npx skills

With Node.js installed, [skills](https://github.com/vercel-labs/skills) installs the skill for GitHub Copilot, Cursor, Gemini CLI, OpenCode and about 70 other agents, Claude Code and Codex included:

```bash
npx skills add underautomation/skills --skill underautomation-robotics-csharp
```

Add `-y` to skip the questions, `-a <agent>` to choose the agent (`claude-code`, `codex`, `github-copilot`, `cursor`...) and `-g` to install for the user instead of the project.

## Install manually

Download the zip of the skill from the latest release of [underautomation/skills](https://github.com/underautomation/skills/releases/latest):

- C#: [underautomation-robotics-csharp.zip](https://github.com/underautomation/skills/releases/latest/download/underautomation-robotics-csharp.zip)
- Python: [underautomation-robotics-python.zip](https://github.com/underautomation/skills/releases/latest/download/underautomation-robotics-python.zip)

The zip contains one folder, for example `underautomation-robotics-csharp/`. Extract it into the skills folder of your agent:

| Agent          | Project folder    | User folder                                 |
| -------------- | ----------------- | ------------------------------------------- |
| Claude Code    | `.claude/skills/` | `~/.claude/skills/`                         |
| Codex          | `.agents/skills/` | `~/.agents/skills/`                         |
| GitHub Copilot | `.agents/skills/` | `~/.copilot/skills/` or `~/.agents/skills/` |
| Cursor         | `.agents/skills/` | `~/.cursor/skills/` or `~/.agents/skills/`  |

A project folder is relative to the root of the project, and is shared with the other developers when you commit it. On Windows, `~` is `%USERPROFILE%`. After the extraction, the file `.claude/skills/underautomation-robotics-csharp/SKILL.md` (or the same path in the folder of your agent) must exist.

The link of the zip always gives the last version. To install the skill in claude.ai, upload the same zip in the skills settings.

## Check the version

The frontmatter of `SKILL.md` gives the version of the library that the skill documents, for example:

```yaml
metadata:
  sdk-version: 1.0.0
```

Compare it with the version of the package of your project:

- C#: `dotnet list package`, line `UnderAutomation.Robotics`
- Python: `pip show UnderAutomation.Robotics`, line `Version`

When the versions differ, update the skill (`claude plugin update robotics-csharp@underautomation`, `npx skills update`, or download the zip again), or update the package. The agent also does this check before it writes code for the library.

## Instructions for AI agents

This section is for an AI agent that a user asked to install the UnderAutomation Robotics skill. Follow the 4 steps in order. Do not run any script other than the commands of this section. Ask the user a question only in step 1, and only when the language cannot be found.

### Step 1: find the language

Look at the files of the current project folder and of its subfolders:

- a `*.csproj` file (or a `*.sln` or `*.slnx` file) means C#: the skill is `underautomation-robotics-csharp`;
- a `pyproject.toml` or `requirements.txt` file means Python: the skill is `underautomation-robotics-python`;
- with both, install the two skills;
- with neither, ask the user: "C# or Python?". Ask nothing else.

### Step 2: install with npx skills when Node.js is installed

Run `node --version`. If it works, run this command at the root of the project, with the skill of step 1 and the identifier of the agent that you are:

```bash
npx --yes skills add underautomation/skills --skill underautomation-robotics-csharp -a claude-code -y
```

| Agent          | `-a` identifier  | Skills folder of the project |
| -------------- | ---------------- | ---------------------------- |
| Claude Code    | `claude-code`    | `.claude/skills/`            |
| Codex          | `codex`          | `.agents/skills/`            |
| GitHub Copilot | `github-copilot` | `.agents/skills/`            |
| Cursor         | `cursor`         | `.agents/skills/`            |

For another agent, use its identifier in `npx skills`, or leave out `-a`. The first `--yes` answers the download question of npx, the last `-y` the questions of `skills`. If Node.js is not installed or the command fails, go to step 3. Otherwise, go to step 4.

### Step 3: otherwise, download the zip

Download the zip of the skill from the latest release and extract it into the skills folder of the project of the table above. The zip contains the folder of the skill. Example for Claude Code and the C# skill, with Bash:

```bash
curl -L -o underautomation-robotics-csharp.zip https://github.com/underautomation/skills/releases/latest/download/underautomation-robotics-csharp.zip
mkdir -p .claude/skills
unzip -o underautomation-robotics-csharp.zip -d .claude/skills
rm underautomation-robotics-csharp.zip
```

The same with PowerShell on Windows:

```powershell
Invoke-WebRequest -Uri https://github.com/underautomation/skills/releases/latest/download/underautomation-robotics-csharp.zip -OutFile underautomation-robotics-csharp.zip
New-Item -ItemType Directory -Force .claude/skills | Out-Null
Expand-Archive -Path underautomation-robotics-csharp.zip -DestinationPath .claude/skills -Force
Remove-Item underautomation-robotics-csharp.zip
```

For the Python skill, replace `csharp` with `python`. For Codex, GitHub Copilot or Cursor, replace `.claude/skills` with `.agents/skills`. If you cannot run commands, give the user the link of the zip and the table of the section "Install manually".

### Step 4: check the installation

1. Check that `SKILL.md` exists in the skills folder, for example `.claude/skills/underautomation-robotics-csharp/SKILL.md`.
2. Read `sdk-version` under `metadata` in the frontmatter of `SKILL.md`.
3. Read the version of the package installed in the project:
   - C#: `dotnet list package`, line `UnderAutomation.Robotics`, column `Resolved`;
   - Python: `pip show UnderAutomation.Robotics`, line `Version`, in the virtual environment of the project when there is one.
4. Tell the user: the skill installed, its folder, the version of the library it documents, and the version of the package. If the versions differ, or if the package is not installed, say it and give the command that installs the documented version: `dotnet add package UnderAutomation.Robotics --version <sdk-version>` or `pip install UnderAutomation.Robotics==<sdk-version>`. Do not install or update the package yourself.

If the agent does not list the new skill, tell the user to start a new session in the project.

## What to read next

- [Get started with .NET](/robotics/documentation/get-started-net) and [Get started with Python](/robotics/documentation/get-started-python): install the library and write a first program.
- [Connect to your robot](/robotics/documentation/connect): the connection parameters of each brand and the settings of the controllers.
- [underautomation/skills](https://github.com/underautomation/skills): the repository of the skills, and its issues to report a wrong answer of the skill.