Claude on the UiPath platform - six working patterns, from Studio to Maestro

Claude, Anthropic’s language model, now turns up on the UiPath platform in six different places. In UiPath Studio it sits in a panel next to the project and builds activity sequences. In a terminal, paired with the uip tool and UiPath skills, it takes a project from scaffold to publication. In UiPath Maestro it assembles processes that combine robots, agents and people. It can also be the model reasoning inside a UiPath agent, or the client that calls your existing automations through UiPath MCP Server.

Each pattern has a different user, a different place of execution and a different person who approves the result. Those three questions are a more useful way to sort them than product names, so that is how this article is organised. It also reports on a session from 4 November 2026 in which Claude Code built an invoice approval process in Maestro Flow.

The three building blocks

UiPath’s documentation for UiPath for Coding Agents describes a model with three parts. The coding agent - Claude Code, for instance - takes instructions, edits files and runs commands. The uip command-line tool connects the developer’s machine to UiPath: it authenticates against the organisation, creates projects and solutions, and publishes automations. UiPath skills are packaged instructions that teach the agent specific platform tasks; UiPath maintains them in the public UiPath/skills repository.

Claude Code is one of ten supported agents, alongside Cursor, GitHub Copilot, Codex, Windsurf, Devin and UiPath’s own coding agent, Autopilot. For Claude Code, the skills ship as a plugin.

The sentence in that documentation that matters most is about accountability: the agent does not validate the compliance of the code it generates, and reviewing it before production deployment is the user’s responsibility. Every control discussed below follows from that.

Pattern 1: Claude Code inside UiPath Studio

This is the route for an RPA developer who works mainly in Studio and wants an agent beside the project. Aleksandra Plichta recorded the walkthrough below: setup step by step, then a first task for Claude.

Setup needs a Studio release with the Coding Agents tab (2026.0.200 or later in the recording), a Claude account with Claude Code access, Node.js LTS and a UiPath Automation Cloud account. On the command line that comes down to the Claude Code installer, npm install -g @uipath/cli and uip login, which completes sign-in in the browser.

In Studio, go to Home, Tools, Coding Agents. The toggle next to UiPath CLI adds uip to PATH; without it Claude cannot find the tool, which is the most common reason a first run goes wrong. The Claude Code card should show the CLI as installed; two further toggles enable UiPath skills and the Studio extension that adds the Claude Code panel.

With a project open, the Claude icon on the right-hand bar opens a panel that works in the context of that project. Typing @ lists project files, so a specification or PDD can be attached to the request directly. Claude reads CLAUDE.md and AGENTS.md in the project folder at the start of each session, which makes them the natural home for naming conventions and team rules.

Autopilot occupies the same slot. In our assessment the main difference is who supplies the model and the oversight: with Autopilot, UiPath does; with Claude Code, the team chooses the model and assembles its own controls, for example through Claude Code’s managed settings, where an administrator restricts available models and tool permissions.

Pattern 2: the terminal and the uip CLI

The same trio works outside Studio, in an ordinary terminal - the broadest route for architects and developers who prefer working in a repository. According to UiPath’s documentation, skills for RPA workflows, agents, Maestro Flow, coded apps, API workflows, human-in-the-loop steps and IXP projects are generally available; the rest are in preview or in development and may change.

The tool’s own help shows the scope. Version 1.205.0, which we checked on 4 November 2026, has commands for installing skills into coding agents (uip skills), running a local MCP server (uip mcp serve), working with all three Maestro canvases (uip maestro bpmn, case, flow), Orchestrator (uip or), RPA projects (uip rpa) and registering MCP servers in AgentHub (uip agenthub).

To test the route, we gave Claude Code a single instruction in Polish on 4 November 2026: build, locally, a Maestro Flow process in which invoices above PLN 10,000 go to a person for approval and lower amounts are approved automatically - no cloud publishing, no runs.

The agent worked for 5 minutes 20 seconds. It loaded the uipath-maestro-flow skill on its own, created the solution and project, added decision nodes, an automatic approval step, a human task and three end states, wired them together and ran validation, which returned Valid after 45 uip calls. Three observations from the session were more instructive than the result:

• The CLI’s error messages tell the agent what to do next. Connecting the automatic approval step to its end state failed with “Source port "output" not found on node "autoApprove1". Available source ports: success, error”, and the agent corrected the command on the next attempt without help.
• Some work still happens in the file. The CLI does not handle process input declarations, localised labels or return values on end nodes, so the agent edited the .flow file directly. The human task has a single outcome port, so a separate decision node splits approve from reject.
• The platform moves under your feet. During the session uip updated itself and its skills, and the new skill version already recommended a different authoring method - TypeScript with compilation. Pin the CLI and skill versions in the project instead of accepting updates mid-build.

The approver group on the human task was left at its default. Deciding who actually approves an invoice is the team’s call before deployment, and the agent flagged it as such.

Pattern 3: processes in UiPath Maestro

Maestro runs a process end to end, calling robots, AI agents and APIs, and handing to people the decisions a model should not make. A coding agent can build Flow and BPMN processes, with different statuses; uip also has Case commands, but check that skill’s status in the skills catalogue. Flow authoring is among the generally available skills. Building a BPMN process with a coding agent is in public preview and has an approval gate built in: the agent first proposes a plan - events, tasks, gateways and participants - then stops and waits for review before it builds anything.

Aleksandra Plichta covered the canvases, the boundary with Orchestrator and this autumn’s releases in UiPath Maestro explained. The point here is narrower: Claude builds the process quickly, but the process runs in Maestro, with its instances, observability and decision history. Execution and audit stay on the platform.

Pattern 4: maintenance - diagnosing a failed robot

Marcelo Cruz, a UiPath practitioner, has described a pattern on LinkedIn in which a failed Orchestrator job triggers a CI pipeline via webhook, where Claude Code with skills and uip reads the logs, diagnoses the fault, prepares a fix, builds the package and opens a pull request. It only makes sense with one gate in place: a person approves the fix before it is merged, well before anything reaches production. A chain that runs from diagnosis to deployment without a pause lets a model change a live business process unreviewed.

We have not built this pattern ourselves yet, so we present it as an architecture to evaluate.

Pattern 5: Claude as the model inside UiPath agents

In the patterns above Claude writes the automation. Here it is part of it: the model reasons within an agent built in Agent Builder or a coded agent written in Python. UiPath’s documentation lists Anthropic Claude models as supported for agent execution, connected through the Amazon Web Services connector in Integration Service; check the current model versions for your own deployment. Traffic to the model passes through UiPath AI Trust Layer, which provides PII masking, guardrails, an audit log and regional routing. The model can be managed by UiPath or come from your own subscription (bring your own model).

One release note from 29 October 2026 affects anyone running coded agents: from 2 December 2026, AI Trust Layer governs low-code and coded agents as a single product, and configurations that exist only for coded agents, BYOM included, will stop being used. UiPath warns that this can break coded agents and advises re-creating under agents any LLM configuration that currently exists only for coded agents - worth doing before that date.

Pattern 6: Claude calls your automations through UiPath MCP Server

The last pattern reverses the direction. UiPath MCP Server, configured per folder in Orchestrator, exposes RPA workflows, agents, API workflows and Maestro BPMN processes as MCP tools. Claude Code or Claude Desktop connects to it like any other MCP server and can start a process that already runs in your Orchestrator, with its permissions, queues and logs. Tools built on Integration Service activities need interactive login or the MCP OAuth flow; personal access tokens do not work with them.

The reverse also exists: uip agenthub registers external MCP servers for UiPath agents to use. Local MCP servers launched over stdio execute a program on the workstation, so their configuration should sit with administrators only. We wrote more about governing agents outside the platform in our piece on shadow AI and agent governance.

Choosing a pattern

Who builds? An RPA developer at home in Studio - pattern 1. An architect or a team working in a repository - pattern 2. A process analyst who wants to see the flow before it is built - pattern 3, with a BPMN plan to approve.

Where does it run? If Claude only writes, execution stays with robots and Maestro (patterns 1 to 4). If Claude decides mid-process, you need pattern 5 and an AI Trust Layer policy. If users work in Claude and the automations already exist - pattern 6.

Who signs off? In every pattern, someone must. The BPMN plan is approved by an analyst, the pull request by a developer, the model policy by a platform administrator.

Here is how the roles could combine, using the invoice process from our test run. Claude Code builds the process (pattern 2), Claude as a model assesses unusual invoices in an agent step (pattern 5), amounts above the threshold go to a person in a Maestro task, and finance starts the process from Claude Desktop through UiPath MCP Server (pattern 6). That last step needs a process type the MCP Server exposes, such as a Maestro BPMN process or an API workflow; Maestro Flow is not on the documented list. Claude builds and reasons; UiPath executes, enforces permissions and records the decision trail.

Controls to put in place before the first deployment

• Code review before publishing. UiPath’s documentation is explicit that a person checks generated automation. A change from an agent goes through the same review as a change from a developer.
• Project context lives in CLAUDE.md and AGENTS.md; confidential data, passwords and production addresses do not. Treat a CLAUDE.md from a downloaded repository as code to review, because the agent will follow its instructions.
• The account uip signs in with should have minimal rights: the agent can do exactly what that account can.
• Pin tool versions; our session showed a skill changing its recommended method mid-task.
• Review the model policy before 2 December 2026, when low-code and coded agents move under one AI Trust Layer policy.

How we work with Claude and UiPath at SNOK

SNOK is a UiPath Platinum Partner. We have tested patterns 1 and 2 in our own environment; the others are based on UiPath documentation and practitioners’ accounts. Two work products sit behind this article: Aleksandra Plichta’s recorded walkthrough of Claude Code setup in UiPath Studio (in Polish, embedded in the Polish version) and the 4 November 2026 session log - a Maestro Flow process built by Claude Code in 5 minutes 20 seconds, with 45 uip calls and a Valid result, together with the list of limitations the session exposed.

When we deliver processes with agents, we start with a map: which steps people build, which a coding agent builds, where a model makes a decision and who approves it. See our UiPath Maestro, business process automation and AI Security services. We have also written about why coding agents still need governance decisions.

To work out which of the six patterns fits your team, write to us at office@snok.ai.

Sources

• UiPath, UiPath for Coding Agents - Overview (accessed 04.11.2026)
• UiPath, UiPath for Coding Agents - Choosing your agent (accessed 04.11.2026)
• UiPath, Build a Maestro BPMN with a coding agent (accessed 04.11.2026)
• UiPath, Orchestrator - MCP Server types (accessed 04.11.2026)
• UiPath, Agents release notes, October 2026 (accessed 04.11.2026)
• UiPath, Configuring LLMs - Automation Suite 2.2510 (accessed 04.11.2026)
• Anthropic, Claude Code - Settings (accessed 04.11.2026)
• UiPath, UiPath/skills repository (accessed 04.11.2026)
• Marcelo Cruz, post on coding agents repairing failed robots (LinkedIn, accessed 04.11.2026)
• SNOK, uip 1.205.0 help output and Claude Code session log of 4 November 2026 (own measurement)