- Overview
- Quickstart
- Delegate
- Trust and compliance
- Governance
- Features
- Cartographer
- Cartographer overview
- The Cartographer interface
- Getting started with Cartographer
- Working with existing automations
- AS-IS (Current Process) documentation
- Providing documents to Cartographer
- Delegating a task
- TO-BE design and PDD generation
- Refining your PDD and the quality checklist
- Generating an SDD
- Sending SDDs to Automation Hub
- Delegate for Testing
- Reference
- Troubleshooting
- Backup and restore
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 |
| A repository you add | Wherever you point it, such as a GitHub-hosted skills repository | You, from Add-ons & Integrations → Plugins — see Repository sources |
Every skill published from Delegate is in Orchestrator under Tenant → Packages → Libraries → Tenant.
See Skills reference 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 |
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:
- You're connected to Orchestrator. If you're offline, there's nothing to browse and nowhere to publish.
- 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.
- You hold the
Libraries.Createpermission in Orchestrator. Without it, the Publish button isn't rendered at all — you'll only see Submit for review.Libraries.Viewis 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 |
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 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:
- In Add-ons & Integrations → Skills → Discover skills, find your skill under Installed. It reads Not published until you share it.
- Open the card and check the Overview tab — this description is what people will judge the skill by before you publish it.
- Select the upload icon on the card, or Publish local changes on the detail page.
- 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.
- 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.
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:
- The catalogue marks the skill Modified, and the Changes tab reappears on the detail page showing what changed.
- 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.
- 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:
- In Discover skills, find it under Available. Narrow the list with search, role, and type filters.
- Open the card and check Overview and Files before installing anything you didn't build yourself.
- 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.
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 |
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 — What a skill is, and the Skills / Discover skills / Review queue views
- Repeating work with Routines — How a routine relates to a skill
- Extending functionality with plugins — Bundling skills, MCP servers, and credentials together
- Troubleshooting — Fixes for publish, install, and review issues
- Where skills are published: feeds
- Creating a skill
- Adding a skill
- Before you publish
- Roles and permissions
- Publishing a skill
- Updating a published skill
- Skill quality guidelines
- Installing a skill
- Getting review and approval
- Publishing and installing skills from a chat
- Sharing skills outside your organization
- Publishing to a shared feed
- Receiving a skill from a shared feed
- Removing a skill
- Best practices
- For users
- For publishers
- Next steps