Perguntas frequentes

Answers to common questions about Autopilot: what it is, what it can do, governance, data privacy, and licensing.

What is a coding agent? Is Autopilot a coding agent?

Coding agents (Claude Code, Codex, Cursor, and others) work like a developer rather than an autocomplete: given a goal in natural language, they plan an approach, take action through tools, check their own work and iterate — building, shipping and monitoring alongside developers, admins and business users.

Autopilot is UiPath's first-party coding agent. It was fully rebuilt on this foundation — earlier versions of Autopilot were assistive; it now plans and executes end to end. Available in Studio Desktop today, with rollout across the UiPath Platform underway. Studio Web is coming soon.

More broadly, UiPath for Coding Agents opens the platform to any coding agent. The skills and tools provided carry UiPath's own knowledge, best practices and instructions, so any coding agent (Autopilot, Codex, Claude Code, and others) can discover, build, troubleshoot and monitor automations.

What can Autopilot do today?

Autopilot supports developers across the entire automation lifecycle:

• Discover (for example, turn a PDD into a starting point)
• Build workflows from natural language
• Edit and improve existing projects
• Debug and fix issues
• Publish and deploy
• Manage, monitor, and troubleshoot in production

Maturity varies by stage, as Autopilot inherits it from the underlying UiPath for Coding Agents skills — as a skill matures, so does Autopilot at that stage. Today the strongest are build, edit and debug for RPA projects.

When should I use Autopilot, and when is a third-party coding agent the better fit?

It is not an either/or choice, and the strongest setups can use both. Regardless of how automations got built, everything lands on the same governed UiPath platform: audit trails, RBAC, policy enforcement and credential management.

Reach for Autopilot when:

• Granular control matters most — Autopilot is governed directly: which tools and features are available, approval mode (when it acts vs asks), available models.
• Zero setup matters — AI-ready out of the box with UiPath-managed models (nothing extra to buy) and all the skills and knowledge baked in.
• You want to stay in the same context — Autopilot works where you already are, in Studio Desktop today, extending across the platform as rollout continues.

Reach for a third-party coding agent (via UiPath for Coding Agents) when:

• The team already has a coding agent, subscription and toolchain they prefer — Claude Code, Cursor, Codex.
• The work is code-first / CLI-heavy and the developer prefers to stay there.
• Mixing UiPath and non-UiPath repos in the same session is the norm.

How does UiPath RPA compare to writing raw code when coding agents make both easy to build?

Coding agents make it easy to build either way. The real differentiator is everything that comes after the build: operating, maintaining and troubleshooting automations in production. That requires a reliable enterprise platform for orchestration, monitoring, governance, credential management, error handling and audit. Raw code does not provide that out of the box. With UiPath, the platform carries the operational weight — refined through years of real enterprise use.

RPA is the choice wherever code cannot reach: legacy systems, custom apps with no API, and any UI-only interface — and coding agents now help build and maintain those automations more easily too. Where the target is a UI, generated code is also brittle by nature: a screen changes and the script breaks. RPA is engineered for exactly that, with Object Repository, Unified Target and healing keeping automations running.

Code-first is the right call when the work is pure API orchestration, there is an engineering team to own it, and no UI is involved.

Does Autopilot only work with RPA?

No. Autopilot works across the full range of automation UiPath supports (including agents — low-code or code-first, API workflows, and Maestro Flows) and across the entire lifecycle, from discovery to build, edit, debug and publish, and all the way to managing, monitoring and troubleshooting in production.

Coverage follows the skills and toolset: where UiPath for Coding Agents has matured for a project type, Autopilot is strong with it; where a skill is newer or absent, less so.

Can I use Autopilot across the UiPath Platform, or only in Studio?

What Autopilot can act on: the platform, not just the product you're sitting in. Autopilot reaches UiPath through skills, tools and commands from wherever it runs. So from Studio you can build, publish, deploy and troubleshoot production automations without switching surfaces.

Where Autopilot appears: Studio is its home today and where it's most capable, with rollout to more surfaces underway.

Can I use Autopilot in other IDEs?

Yes. Autopilot is available as an extension that is not locked to a single IDE. It runs across VS Code, Cursor, Windsurf, VSCodium and other compatible editors, so you get the Autopilot coding agent experience inside the IDE you already work in.

How much time does Autopilot save, and where in the lifecycle?

Developers consistently report meaningful productivity gains with Autopilot — faster to a working draft, quicker to ramp on new projects, less time hunting through docs or hand-authoring expressions. Impact varies by use case and developer experience level.

Where the biggest gains are today:

• Build — generating workflows from natural language across agentic, API, and RPA/UI Automation projects; also migrating from legacy or competitor platforms.
• Debug and fix — diagnosing and resolving design-time and runtime errors. This is consistently the other top time-saver.
• Testing — for testers, Autopilot has been GA since July 2024, and it drives the biggest measured gains.
• Documentation — increasingly in scope for generating docs from workflows and building from documents (PDD to SDD to build).

How reliable is it — can it produce production-ready workflows?

Autopilot gets developers meaningfully faster to a higher-quality working draft, applying consistent patterns and best practices from the start. And just like any code written by a developer, the output goes through reviews, edits, and iterations before production — Autopilot does not change that bar. Production-readiness stays a human judgment call.

When should I rely on Autopilot, and when is working manually better?

Autopilot works best translating business intent into workflow logic, exploring how to approach a problem, and getting a solid first draft fast. Take the wheel when:

• the process involves complex exception handling or business rules that are hard to express in a prompt;
• deep domain or system knowledge is needed that the AI cannot infer from context;
• the AI is looping or producing inconsistent results after a few attempts.

General principle: let AI get you to a working draft fast, then refine with human judgment where precision matters. The boundary keeps shifting as the technology improves, but the developer's role as reviewer and decision-maker on edge cases remains essential.

Can I limit Autopilot's changes to a specific section or activity?

A hard "edit only this section" lock is not available today. The main way to keep changes contained is to scope them in the prompt: point Autopilot at the specific activity or section you want changed rather than asking broadly.

Can I see what Autopilot changed, and undo or revert?

File diff is available if your project is connected to Git: Autopilot's changes show up as file-level diffs like any other commit — review, stage, or discard through the standard Git workflow.

For non-Git projects: back it up before non-trivial prompts so there is a clean revert point.

Do I need Object Repository upfront, or can Autopilot capture elements as it works?

You do not need one upfront — Autopilot can create it. If your project has no Object Repository, Autopilot captures elements as it works, using its skills and following UI Automation best practices. If you already have one, it uses it.

A good Object Repository is the quality multiplier — it makes generated UI Automation significantly more accurate and maintainable, which is exactly why Autopilot creates one rather than targeting elements ad hoc.

How well does Autopilot handle complex, multi-layer processes?

The way large processes get built — with or without Autopilot — is by breaking them down into well-scoped parts. Autopilot is strong at building and iterating on each part.

What stays with the developer is the architecture: how to split the process, dispatcher/performer, API vs UI Automation. Autopilot's input on these decisions is directional, not production-grade yet.

Best approach: decompose the process, let Autopilot build and iterate on the parts, and keep a developer in the loop on overall structure and edge cases.

Can Autopilot migrate from other platforms, and handle upgrades and modernization?

Yes. The two paths customers ask about most:

• Legacy to Modern: migrate Classic activities and projects to Modern, which also unlocks newer capabilities (Unified Target, Healing Agent).
• Other platforms to UiPath: the coding agent reads the source automation and rebuilds it as UiPath workflows.

How does Autopilot improve consistency and maintainability?

Autopilot applies consistent patterns and UiPath best practices every time it generates or edits a workflow — eliminating the developer-to-developer variation that causes maintainability problems at scale. And since Autopilot uses shared skills, that same best-practice baseline applies whether the work happens in the Studio panel or via the CLI with a third-party coding agent.

Existing guardrails like Workflow Analyzer keep working alongside it.

What exists today for AI-assisted code reviews?

There is a dedicated code review skill: it audits a project or an entire solution — structure, quality, best practices — runs validation and Workflow Analyzer, checks the implementation against the PDD, and produces a findings report with severities and recommended fixes.

Validation and Workflow Analyzer results are deterministic. The AI's own findings are advisory: they surface candidates for human review. Treat it as a reviewer's second pair of eyes, not as sign-off.

Beyond the dedicated skill, Autopilot supports review-like activities in Studio:

• Summarize what a workflow does in plain language
• Diagnose errors and suggest fixes
• Check a project against code-quality conditions
• Answer questions about unfamiliar logic

Can Autopilot generate documentation, or build from it?

Yes, Autopilot can do both:

• Generate documentation — summarize a workflow in plain language; draft test requirements or extract requirements from existing tests; build a test plan; generate deployment instructions; produce structured design specs (for example, an SDD) from your inputs; generate other types of reports or documentation.
• Build from documentation — feed a PDD, diagram, or process description and have Autopilot generate the workflow or solution from it.

The direction is to replace the slow, manual PDD/SDD handoff with documentation that is both generated and directly actionable — specs that feed straight into the build.

Does Autopilot support multiple languages?

Yes. Autopilot handles text prompts in multiple languages through the capabilities of the underlying LLMs. You can write prompts and receive responses in your preferred language.

How do I get the best results out of Autopilot?

Autopilot is built to work with deep UiPath skills and product knowledge built in. To get the most out of that, give clear intent and context:

• Be specific about what you want — name the approach when it matters (for example, UI Automation vs API), not just the end goal. Without direction, Autopilot picks a generic path that may not be the one you would choose. For example, instead of "automate the invoice process", try "In the Process Invoice sequence, use API Automation to read invoice PDFs from the SharePoint folder and create entries in SAP via OData."
• Give it context — an Object Repository, the right packages, and a clean project structure all raise quality.
• Set your conventions once — use custom instructions to encode naming, style, and structure, so you do not repeat them every prompt.
• Iterate, then take over — if it is looping or off after a couple of tries, refine the prompt or step in manually.

For more prompting tips, refer to Writing effective prompts.

What governance controls exist for Autopilot?

Autopilot's org-level controls live in Automation Ops, with model controls also exposed through the AI Trust Layer. Beyond the master org-level enable/disable switch, admins can control:

• Models — set the default model and restrict which models users can pick from. Through the AI Trust Layer you can also route to your own model (BYOM) and disable UiPath-managed third-party models. All traffic stays audited and traceable.
• Approval behavior — how autonomously Autopilot acts: whether it runs tools on its own or asks for approval first.
• Tools and features — enable or disable individual tools and govern which MCP servers are available through an org-provisioned allowlist, including Orchestrator-provided MCPs.
• Custom instructions — admin-set instructions applied across the org.
• Custom skills — customers can author their own skills that reference UiPath's, so in-house standards extend the built-in expertise. Org-level control runs through custom instructions and the tool and feature controls above.

Most controls ship enabled by default; admins restrict where needed. For the current set and exact option names, refer to the Automation Ops documentation.

Can we use our own LLM / bring our own model (BYOM)?

Yes. Customers can bring their own model through the AI Trust Layer (for example, Azure OpenAI or other subscriptions), and disable UiPath-managed third-party models via Automation Ops policies.

Your own model stays fully governed by UiPath. Every request — even to a BYOM model — still routes through the AI Trust Layer, so you keep the same enterprise-grade security, governance, and end-to-end audit and traceability as with UiPath-managed models. Bringing your own model extends your choice without stepping outside any of UiPath's enterprise controls.

Where does our data go? Is our code collected?

• Source code and project files are not stored or uploaded to UiPath. They stay in the developer's environment. When Autopilot works on a project, relevant file content is sent to the configured model as context for that request — under AI Trust Layer routing and audit.
• Model traffic routes to the LLM provider configured for your tenant. With UiPath-managed models, customer data is not used to train models.
• Tenant traffic authenticates against your Orchestrator, Cloud, or on-premises authority and follows your existing data-residency configuration.
• Permissions — Autopilot operates with the same permissions as the logged-in user; folder-, asset- and tenant-level RBAC apply transparently.
• Audit — AI Trust Layer audit, governance and execution guarantees apply unchanged. Autopilot builds the automation; Orchestrator runs it under your existing controls.
• Telemetry — no customer code, workflow content or project data is collected in telemetry. Studio and Autopilot emit standard product telemetry (feature usage, crash reports, anonymized performance), with opt-out in Studio settings.
• Feedback — if a user chooses to send feedback on an Autopilot session, that submission includes conversation content. It is user-initiated, private information is stripped, and the user sees and approves what gets sent.

For more details, refer to Data privacy.

What does Autopilot cost?

Autopilot is not purchased separately — its usage is included in UiPath's tiered user licensing. Higher tiers include larger allowances. Each paid tier comes with a usage allowance with a monthly and daily reset. Once you exceed the allowance, admins decide whether usage falls back to platform units. Refer to Licensing for details.

Do we need our own coding agent licenses?

No. Autopilot runs on UiPath-managed third-party models, so you get the full power of coding agents inside UiPath without bringing your own coding-agent subscription. Bringing your own model is possible but optional.

If the team also wants to work through a third-party coding agent (Claude Code, Codex, Cursor), that agent's own subscription is theirs to hold. UiPath for Coding Agents opens the platform to it; it does not license it.