# Sharing skills with your team

> Publish, install, review, and share skills and routines in Delegate and Cartographer, including permissions and how feeds work.

A skill you build lives only on your machine until you publish it. Since a routine is a skill marked user-invocable, everything on this page applies to routines too.

## Where skills are published: feeds

Publishing a skill uploads it to a feed — a place a skill package can be read from and written to. You switch between feeds with the source selector in Discover skills:

| Feed | Reach | Who sets it up |
|---|---|---|
| **Your Orchestrator tenant's Libraries feed** | Everyone in that tenant | Your own Orchestrator admin — this is the default target every tenant has |
| **A shared feed** | Several organizations at once | Configured separately by UiPath, outside Orchestrator entirely, and only if your organization has one — see [Sharing skills outside your organization](#sharing-skills-outside-your-organization) |
| **A repository you add** | Wherever you point it, such as a GitHub-hosted skills repository | You, from **Add-ons & Integrations** → **Plugins** — see [Repository sources](plugins.md#repository-sources) |

:::note
Every skill published from Delegate is in Orchestrator under **Tenant** → **Packages** → **Libraries** → **Tenant**.
:::

See [Skills reference](skills.md) for the Skills, Discover skills, and Review queue views these feeds populate.

## Creating a skill

Whether you describe it to the agent or write it by hand, a skill needs:

- A clear **trigger** — when should the agent reach for this skill?
- Clear **instructions** — what should it do, step by step?

These become the skill's **Overview** and **When to use** fields when you publish it.

You can also turn something you did in a chat into a reusable skill by asking for it directly, by using the suggested prompt **Turn my current task into a reusable automation skill**, or by selecting **Create recording** to capture the steps by performing them yourself.

Either way, the result is a skill folder on your machine — nobody else can see it until you publish it. Find it under **Add-ons & Integrations** → **Skills** → **Discover skills**, listed under **Installed** as **Not published**.

## Adding a skill

In **Add-ons & Integrations** → **Skills**, select **Add skill** and choose one of three options:

| Option | What it does |
|---|---|
| **Create a new skill with Delegate** | Describe what you want and let the agent build the skill |
| **Import skill from zip** | Add a skill package from a `.zip` file |
| **Open skills folder** | Open your local skills folder directly, to add or edit files yourself |

:::note
A skill folder you create by hand is only picked up when Delegate starts — the **Sync skills** option won't find it. Restart Delegate after adding one this way.
:::

## Before you publish

Three things need to be true, or publishing won't work:

1. You're connected to Orchestrator. If you're offline, there's nothing to browse and nowhere to publish.
2. Your tenant accepts library uploads. An Orchestrator admin sets this under **Tenant** → **Settings** → **Deployment**, in the **Libraries** card — set **Feeds** to **Both host and tenant feeds** (or **Only tenant feed**) and save. If it's set to **Only host feed**, publishing is disabled tenant-wide and the **Discover skills** section becomes browse-and-install only.
3. You hold the `Libraries.Create` permission in Orchestrator. Without it, the **Publish** button isn't rendered at all — you'll only see **Submit for review**. `Libraries.View` is enough to browse and install.

## Roles and permissions

Two separate permission layers apply here, and they control different things:

| Layer | Controls | Where |
|---|---|---|
| **Orchestrator (`Libraries.View` / `Libraries.Create`)** | Whether you can see and use the feed at all — browse and install with **View**, publish with **Create** | Orchestrator roles, set by your admin |
| **Tool permissions** | What an installed skill can actually do on your machine once it runs — Allow, Ask, or Block per tool | **Settings** → **Security**, or centrally through [Governance with Automation Ops](centralized-configuration.md) |

Holding `Libraries.Create` only means Orchestrator lets you publish — it says nothing about what the skill itself is allowed to do at runtime. That's controlled entirely by [Tool permissions](security-settings.md#tool-permissions) and your Approval mode, the same as any other action Delegate takes.

Before installing a skill you didn't build yourself, check its **Files** tab for what tools, connections, and file system or network access it uses, and whether that matches its stated purpose. Be cautious of a skill that asks for tools unrelated to its purpose, broad file system access without justification, or a connection to a sensitive service (banking, HR systems) it has no obvious reason to need.

In terms of roles, **Automation User** is enough to browse, install, and run skills. Publishing needs a role carrying `Libraries.Create`, typically **Automation Publisher** or a custom tenant role.

## Publishing a skill

To publish a skill you built, take the following steps:

1. In **Add-ons & Integrations** → **Skills** → **Discover skills**, find your skill under **Installed**. It reads **Not published** until you share it.
2. Open the card and check the **Overview** tab — this description is what people will judge the skill by before you publish it.
3. Select the upload icon on the card, or **Publish local changes** on the detail page.
4. Fill in the required fields: **Version** (must be higher than any version already published for this skill), **Role**, **Type**, and **Overview**. **Change notes** is optional on a first publish. **Generate with AI** can draft the descriptive fields from the package for you.
5. Select **Publish** to go live immediately, or **Submit for review** to send it to a reviewer first — whichever the footer offers you.

Your **Role** and **Type** choices become properties on the resulting package, your tags become labels, and your **Overview** becomes its description.

To confirm it published, check the detail page: a tenant name now appears next to the version, and the action changes from **Publish local changes** to **Republish**. For a definitive answer, check **Tenant** → **Packages** → **Libraries** → **Tenant** in Orchestrator — this is the actual package listing.

Once your skill is published, your team can find it under **Available** in Discover skills and select **Install** to download it into their own skills folder. It's ready for the agent to use starting with their next conversation. Refer to [Installing a skill](#installing-a-skill).

### Updating a published skill

Edit the skill — in a chat, or by changing its files directly. There's no in-place edit of a published version; every change ships as a new version. Once you've made a change:

1. The catalogue marks the skill **Modified**, and the **Changes** tab reappears on the detail page showing what changed.
2. Select **Publish update**. The version number is pre-filled one step higher than what's published, and **Change notes** is required this time — describe what changed.
3. Select **Publish update** again to ship it.

Versions only ever go forward — reusing a version number is rejected.

### Skill quality guidelines

A skill you're publishing for others is more useful — and more likely to be trusted — when it meets these criteria:

| Criterion | Description |
|---|---|
| **Clear purpose** | Does one thing well, described in one sentence |
| **Well documented** | The Overview explains what it does, when to use it, and what it needs |
| **Tested** | Works reliably across different machines and configurations |
| **Secure** | Doesn't request unnecessary permissions, handles credentials safely |
| **Maintainable** | Instructions are readable, dependencies are minimal |
| **Versioned** | Uses semantic versioning (1.0.0, 1.1.0, etc.) |

## Installing a skill

To install a skill someone else has published, take the following steps:

1. In **Discover skills**, find it under **Available**. Narrow the list with search, role, and type filters.
2. Open the card and check **Overview** and **Files** before installing anything you didn't build yourself.
3. Select **Install**. The skill card moves to the **Installed** section of **Discover skills**.

Installing, enabling, or disabling a skill only takes effect in new conversations. When a newer version is published, the card shows **Update available**. If you've edited your own copy, updating warns you first and offers to keep your changes or overwrite them.

To remove your own copy without affecting the published package, use **Uninstall from this device**. To remove the package entirely — for everyone — use **Delete from Orchestrator** from the same menu; see [Publishing a skill](#publishing-a-skill).

## Getting review and approval

If you don't hold the `Libraries.Create` permission, the publish form offers only **Submit for review**. Fill in the same fields as a normal publish and submit — nothing goes live yet.

Track your submission from **Add-ons & Integrations** → **Skills** → **Review queue**, under **My submissions**. It moves through a few states:

| Status | Meaning | What you can do |
|---|---|---|
| **Pending** | Waiting for a reviewer | Withdraw it, or delete it to free the staged package |
| **Publishing…** | Approved; upload in progress | Wait |
| **Published** | Live — it leaves this list | Confirm it in Discover skills or Orchestrator |
| **Rejected** | Declined, with a reason attached | Read the reason, fix it, submit again |
| **Publish failed** | Approved, but the upload itself failed | Nothing to do — the reviewer retries |

:::important
A submission at **Pending** has no owner — no assignment, no reminder, no escalation, no SLA. It sits there until someone happens to check the queue. Before you rely on review for a team, make sure at least one person holds `Libraries.Create` and knows the queue exists.
:::

If you hold the publish permission, a second lane in the Review queue shows submissions waiting on you. Opening one gives you version, submitter, description, and where it will land.

- **Run review** gives you an automated read of the package — a recommendation, its reasoning, and any risk flags — before you decide; it's advisory only and never uploads or deletes anything itself.
- **Approve** publishes the package under your own account;
- **Reject** requires a reason, which travels back to the submitter.

## Publishing and installing skills from a chat

Everything above is also available by asking, in your own words:

| Say | What happens |
|---|---|
| "list skills" or "what's available?" | Queries your tenant feed and prints every published skill with versions and dates |
| "publish my skill X" | Packages and uploads it, working out on its own whether it's a first publish or a new version |
| "install X" or "download X" | Fetches the package and installs it |
| "check for updates" | Compares the feed against what you have installed |

Use the chat route when you're already in one, want it done in one sentence, or are surveying many skills at once. Use the Discover skills UI when you want to review or edit every field before it goes out, need **Submit for review** (the chat route publishes directly), or want **Generate with AI** to draft a description.

## Sharing skills outside your organization

A shared feed is what lets a skill reach other organizations, not just your own tenant.
Shared feeds are configured by UiPath at deploy time, not self-service — if your organization doesn't have one, you won't see any of this, and publishing and installing within your own tenant work exactly as described above.

### Publishing to a shared feed

If your organization has a shared feed configured, the publish form grows a **Share to feed** section with a checkbox per feed alongside your own tenant. Check the boxes before publishing — whichever are selected, your skill goes there too.

Publishing to several destinations at once can partly succeed. Delegate reports exactly which ones failed — for example, "Published to org. Could not publish to: \<feed\>." Whichever destinations did succeed stay published.

### Receiving a skill from a shared feed

Someone in another organization who receives your skill through a shared feed can:

- **Test in chat** (runs it in a sandbox, installs nothing)
- **Add to library** to copy it into their own tenant (if they can publish)
- **Request to add to Orchestrator**, which asks their admin to review and add it

None of these options installs the skill directly from another organization's feed. The receiving organization always decides — either an admin brings a copy in under their own governance, or someone tries it out first without installing anything at all.

## Removing a skill

The trash icon's menu on the skill details page has two actions with two different outcomes:

| Action | Removes | Does not touch |
|---|---|---|
| **Uninstall from this device** | Your local copy | The published package and everyone else's copies |
| **Delete from Orchestrator** | The published package, for the whole tenant | Copies people have already installed |

Uninstalling asks for confirmation first: "Are you sure you want to uninstall '\<skill\>'? This will remove it from your local machine."

## Best practices

### For users

- Review permissions before installing — don't accept blindly
- Test a new skill on a non-critical task first
- Keep skills updated for the latest fixes and compatibility
- Uninstall skills you're not using

### For publishers

- Request only the permissions you need — don't ask for UI automation if your skill only reads files
- Handle errors gracefully — explain to users what went wrong and how to fix it
- Respect user data — don't exfiltrate data, and respect privacy settings

## Next steps

- [Skills reference](skills.md) — What a skill is, and the Skills / Discover skills / Review queue views
- [Repeating work with Routines](routines.md) — How a routine relates to a skill
- [Extending functionality with plugins](extend-functionality-with-plugins.md) — Bundling skills, MCP servers, and credentials together
- [Troubleshooting](troubleshooting.md#publishing-installing-and-reviewing-skills) — Fixes for publish, install, and review issues