- Getting started
- Capabilities
- RPA workflows
- Operate
- Troubleshoot
- Data privacy and governance
- Product availability
- Earlier Autopilot capability sets
- User scenarios
- Prompting guide
- Example prompts
- Best practices and limitations
- Supported models and limits
- Quality-check requirements
- Generate tests for requirement
- Import manual test cases
- Find obsolete tests
- Generate tests for SAP transactions
- Generate synthetic test data
- Generate test reports
- Generate coded test cases
- Search Test Manager project
- Troubleshooting
- Autopilot for Everyone
- About Autopilot for Everyone
- Licensing
- User types
- Data sources
- Toolset automations
- Localization
- Prerequisites
- Autopilot widget
- The Autopilot for Everyone tenant card
- Prerequisites for installation
- Enabling Anthropic models
- Installing Autopilot for Everyone
- Updating Autopilot for Everyone
- Uninstalling Autopilot for Everyone
- Configuring Autopilot for Everyone
- Disabling the Autopilot welcome screen in Assistant
- Configuring an LLM for Autopilot for Everyone
- Deploying toolset automations
- Prompt-to-response flow
- Launching Autopilot for Everyone
- Autopilot settings for business users
- Using a specialized Autopilot
- Using a starting prompt
- Uploading and analyzing files
- Running automations
- Interacting with Autopilot answers
- Using suggested prompts
- Starting a new chat
- Chat history
- Providing general feedback
- Clipboard AI Enterprise version
- Designing relevant automations for Autopilot for Everyone
- Troubleshooting
RPA with Autopilot: what RPA is good for, how to brief a workflow, the role of UI Automation, and where human review matters most.
Robotic Process Automation (RPA) automates repetitive, rule-based work across the systems people use every day. With Autopilot, you describe the work in plain language and it produces a runnable workflow. Your part is to describe it well and review what comes back.
What RPA is good for
RPA is best for well-defined, deterministic work, especially where systems have no usable API:
- Reading and transforming files and spreadsheets.
- Moving data between systems and updating records.
- Calling APIs as part of a larger process.
- Driving desktop, web, and virtual applications through their interface.
What you can ask for
Building a new workflow is only the starting point. Autopilot works across the whole life of an automation, so common requests include:
- Building a new workflow from a description, a set of manual steps, a process document, or a template such as the Robotic Enterprise Framework (REFramework).
- Refactoring and extending a workflow you already have, by restructuring it, adding a step, or swapping an activity.
- Working in legacy projects, recognizing older project types and operating within their constraints.
- Adding tests, generating test cases with assertions and running them to confirm behavior.
- Reviewing an existing automation for quality, missing error handling, and risky choices, without changing anything.
- Debugging a failing workflow by reading the error, finding the cause, and proposing a fix.
- Packaging and reuse, by publishing a project to Orchestrator or extracting shared logic into a reusable library.
What makes a good RPA request
Autopilot produces more accurate output when you describe the outcome you want rather than listing activities. Provide the business context — what the process does, what triggers it, and what success looks like — and Autopilot determines the implementation.
A good brief includes:
- The steps, in order.
- The systems and applications involved.
- The inputs and outputs, with their types.
- The screens or data the workflow touches.
For general prompting guidance, refer to Writing effective prompts. An existing process document is a strong starting point, as long as real customer data is removed first.
Choosing low-code or coded
A UiPath RPA workflow can be built as a low-code workflow or as a coded one, and you guide which:
- Low-code workflows (
.xaml) are the reviewable, auditable default. They have the widest activity coverage, and cross-platform projects can be edited in Studio Web as well. Most automations fit here. - Coded workflows (
.cs, C#) suit logic-heavy components, such as complex data transforms, parsing, or custom types.
Both can also be mixed in one project. Choosing the shape up front, rather than mid-build, avoids a restructure later; without direction, Autopilot defaults to low-code.
Driving applications with UI Automation
The hardest and most valuable RPA work is driving an application's interface the way a person would — by clicking, typing, reading values, and moving through screens — for systems that offer no API. UiPath's UI Automation is what makes this reliable, and Autopilot uses it directly.
How it captures the interface
Rather than guessing how to find each element, Autopilot explores the application at design time: it captures the screen, identifies the elements to act on, and builds the steps to navigate and fill them. Captured elements are stored as stable targets in an Object Repository, so the same button or field can be reused across workflows and maintained in one place.
Staying resilient
Interfaces change, and UI Automation is built to absorb that:
| Capability | What it does |
|---|---|
| Selector healing | Adapts a target when the interface shifts, rather than breaking outright. |
| Diagnosis | Reads logs, recordings, and screenshots after a failure and explains what went wrong in plain language. |
| Screenplay | UiPath's AI-powered computer vision; adapts to the application and data at runtime, as a fallback on critical paths for unpredictable screens. |
When there is no live application
If the target application is not available to capture against, Autopilot still produces the real workflow, leaving each interaction marked for a developer to finish the capture in Studio. Generated selectors are best treated as drafts either way, and confirmed against the real application.
UI automation is also the most expensive kind of RPA to build. It takes more time and effort than file, data, or API work, so an API is the better path wherever one exists.
RPA conventions worth capturing
RPA projects have house rules worth stating once, rather than repeating every session. Common examples:
- Modern design activities rather than the classic set.
- UI activities kept inside a Use Application/Browser scope.
- Native activities in preference to Invoke Code.
- Existing configuration files and recorded workflows left intact rather than overwritten.
You can capture these conventions in an AGENTS.md file at the project root. Autopilot reads and follows the instructions defined there — folder naming rules, architecture decisions, coding standards — for the duration of the session.
Strengths and limits
Autopilot is strong at greenfield, well-structured RPA and at the first version of a workflow. It is weaker, and needs closer review, on:
- Complex or fragile selectors.
- Bespoke enterprise connectors.
- Unusual activity choices, where a generic fallback can creep in.
How Autopilot generates RPA workflows
Starting with Studio Desktop STS build 2026.0.197, Autopilot generates and edits RPA workflows through an iterative reasoning loop. On each request, Autopilot works in three phases:
- Discovery — Autopilot reads your project structure, existing workflows, and relevant activity examples to gather context.
- Generation — Autopilot creates or edits the XAML based on your request and the gathered context.
- Validation and refinement — Autopilot checks for errors and applies fixes, repeating the cycle if needed.
Because Autopilot reads your project during the Discovery phase, it can reference and reuse workflows already in your project. Autopilot is aware of your current file, selected activity, and variable definitions — you do not need to explain your project structure before asking a question or making a request.
Context is also maintained across messages in the same session: a follow-up request such as "undo the last change" applies to the most recent operation, not the entire workflow.
For complex, multi-step tasks, allow Autopilot to complete its execution cycle before sending a follow-up message. Interrupting mid-task may leave the project in an intermediate state.
Tools
Autopilot leverages a range of tools to support your automation work. By default, all tools are enabled. Autopilot can:
- Understand, create, edit, debug, publish, and deploy automations.
- Install and update dependencies.
- Fix errors.
- Create and manage test cases.
- Troubleshoot production errors.
- Run PowerShell commands or search the web.
- Make a plan, spin up subagents, and maintain persistent memory for your specific user account.
Skills
Autopilot automatically loads relevant skills from the UiPath skills catalog based on the task context. Skills are instruction bundles that teach Autopilot how to perform specific UiPath tasks using platform conventions.
For the full list of skills, refer to the UiPath skills repository.
More prompts to try
- Create a new RPA project from the REFramework template called
BankStatementReconciliation. - Create an RPA workflow that downloads attachments from the latest Outlook email matching subject "Invoice" and saves them to
./inbox/. - Add a Try Catch around the Submit Order step so business exceptions are logged and the transaction is set to Failed.
- Validate this project and fix any analyzer warnings.
- What RPA is good for
- What you can ask for
- What makes a good RPA request
- Choosing low-code or coded
- Driving applications with UI Automation
- How it captures the interface
- Staying resilient
- When there is no live application
- RPA conventions worth capturing
- Strengths and limits
- How Autopilot generates RPA workflows
- Tools
- Skills
- More prompts to try