In Tech Thursday with SNOK we take one technology and check what it actually changes in our clients’ work. Today that technology is a product which changes not a feature, but the unit in which we think about automation.
For twenty years the unit of enterprise automation has been the process. Our entire industry grew on that assumption. You pick a process, measure its volume and cycle time, document it in a process definition document, a developer builds a robot, the Center of Excellence tracks versions and exceptions. The queue of automation candidates is a queue of processes, not of people. Metrics, licences, team roles, delivery methodology - all of it is set up around the process.
UiPath has shown the direction in which that unit is changing. It is called Delegate and it was originally announced as Project Delegate at the FUSION 2025 conference. Instead of picking a process at company scale, an employee shows their own task once, on their own computer, fills in the rest in plain words and gets an executor that does the work in the background.
This model shifts three things at once: who creates automation, what becomes the unit of licensing and oversight, and where the risk sits in the organisation. That is why we are writing about it now, while the product is still at an early stage. This is the most comfortable moment: the decisions that will determine whether such a model succeeds in your organisation can be prepared calmly before launch rather than during it.
What is actually known about Delegate
Let us start with the facts, because a layer of guesswork usually builds up around products still at the announcement stage.
Delegate is an agent that runs on the employee’s computer, in a category UiPath calls computer use: the agent sees the screen and operates applications the way a person does. The way you work with it has four steps, and the UiPath Labs page describes them plainly.
Show once. “Record a task once, so Project Delegate learns and builds a reliable flow” - you record the task a single time and Delegate learns from it and builds a repeatable flow. You do not write steps, you do not pick selectors, you do not open Studio.
Explain naturally. “Instruct with simple natural language interactions: text, voice or task recording” - you add context by text, by voice or with another recording. When something is missing, the agent asks.
Delegate. The resulting flow runs in the background, on a schedule, through the applications and services you have access to as a user. The examples UiPath gives are deliberately down to earth: settling invoices, tidying up and standardising files, splitting documents and flagging cases for further handling, coordinating a team’s work.
Stay in control. “Complete audit trail and transparency of all executions” - a full audit trail and transparency of every run.
Daniel Dines, founder and CEO of UiPath, described the product in a sentence worth reading twice: “Project Delegate brings an enterprise-grade AI desktop agent to every professional, blending intelligence with governance so work simply gets done” (UiPath blog, 3 October 2025). Delegate is meant to bring an enterprise-grade desktop agent to every professional, blending intelligence with governance. The word the whole construction rests on is governance, and it is not there as a courtesy to security teams.
The technical foundation is no accident. Raghu Malpani, CTO of UiPath, said in an interview for diginomica on 20 October 2025 that Delegate runs on users’ computers and learns tasks by demonstration, drawing on the company’s track record in user interface automation. That is twenty years of work on selectors, screen element recognition and resilience to changes in applications. The difference is that this library is now driven by a model rather than by a developer.
An early stage, which is the best moment
Delegate is at the stage where companies have the most room to manoeuvre. On UiPath Labs the product is listed as coming soon with an open waiting list, so registering interest today is a matter of decision rather than a procurement process. For comparison, two other experiments in that programme - Nucleus and Enterprise Knowledge Graph - are already at research preview, meaning participants have real access. We expect Delegate to follow the same path.
UiPath says so openly. In a piece dated 15 May 2026 Raghu Malpani named the product directly - “UiPath Delegate - our new computer-use agent that can execute enterprise work” - and added: “We will share more information in the coming months on Delegate”. More information in the coming months; the nearest natural moment is FUSION 2026, 22-25 September in Las Vegas, although the agenda published so far does not name Delegate in any session title. No licensing model has been announced yet, and there is no public product documentation yet.
The practical conclusion is encouraging: you do not have to buy anything today to get moving on this topic. It is enough to join the list and use the coming weeks for what has to be done once anyway - a catalogue of tasks at role level and the oversight layer. Whoever has that ready on launch day starts with a pilot rather than with an analysis.
Where Delegate sits in the UiPath portfolio
Here we get to the part that interests us most as an implementation partner. Delegate is not another item added alongside the existing ones. It is the missing top of a structure UiPath has been assembling for several years.
Underneath Delegate runs the same interface control mechanism as underneath ScreenPlay, the agent that builds interface automation from a natural language description and has been generally available since FUSION 2025. We know this because UiPath evaluated Google’s new model with a computer use capability, Gemini 3.5 Flash, on exactly the harness that sits behind Delegate and ScreenPlay (Google blog, 24 June 2026). Two conclusions follow: the screen control layer is shared across UiPath products and reusable, and the fact that UiPath tests another vendor’s model on it points to the controlling model being treated as interchangeable. There is no product statement on this yet.
Let us separate the categories, because in conversation they blur into one:
- Autopilot for Everyone is a conversational agent. You talk to it, it queries company data and launches existing automations. The entry point is a chat.
- Agent Builder and coded agents are build tools. They are used by someone designing a solution for the organisation, not for themselves.
- Maestro is orchestration: it ties agents, robots and people into one process with visibility and escalations.
- ScreenPlay is an agent that produces interface automation from a task description.
- Delegate is an executor on the workstation side. The entry point is neither a chat nor a description, but a demonstration: you show how you do something.
That last difference is the one with heavy consequences. A chat requires the employee to be able to describe their own work. A demonstration requires nothing beyond performing it once with recording switched on. It is the lowest barrier to entry enterprise automation has ever had.
Delegate’s second life: testing
There is a thread in this story that went almost unnoticed and is one of the most interesting to us. In the same piece from 15 May 2026, UiPath describes Delegate in a use case that has nothing to do with office work: autonomously executing manual test cases end to end, with no human at the keyboard. Through Playwright in the browser, through Appium on mobile devices and in enterprise-class systems - SAP, Oracle and Epic are named.
For anyone who has run an S/4HANA conversion or another large SAP change, that sentence is concrete. Manual test cases are usually the most expensive and least loved part of such an undertaking: hundreds of scenarios written in prose, executed by consultants and key users under deadline pressure, with coverage nobody can measure credibly. A computer-use agent that executes a scenario written in natural language attacks exactly that cost, and does so without building test automation first.
It also explains why UiPath is investing in this technology from two directions. The same mechanism serves the employee delegating their own task and the QA team that needs to work through two hundred scenarios before going to production.
What this changes in your organisation
Let us move to the consequences. Three shifts, each with its own bill to pay.
First: automation is created by the employee, not the developer. The bottleneck in RPA deployments was never the technology, but the queue to the team able to build something. The “show once” model bypasses that queue. The price is immediate: the natural filter that a brief to the CoE provided disappears. Nobody will ask whether the process is worth automating, whether it will change within the quarter and who will maintain it once the author changes jobs. We wrote recently about when not to automate, and that text takes on new meaning here: with a low barrier to entry, the judgement “this task should not exist at all” has to be built into policy, because the tool will not produce it on its own.
Second: the person becomes the unit. Everything you count today in processes changes its denominator. The portfolio is no longer a list of thirty automations with business owners, but a set of hundreds of small flows attached to roles. The maintenance model changes: an automation built by an employee lives as long as that person stays in the role, and after that it is either taken over or quietly breaks in the background. The licensing counter probably changes too, only nobody has told us yet into what.
Third: risk moves from the server room to the desk. Delegate runs in the context of the user’s permissions - in practice that means it runs everywhere that person has access. The mailbox, the shared drive, the HR system, the ERP. Three questions have to be settled before the first production run, not after the first incident:
- Identity. Who is actually performing the action: the employee or an agent acting on their behalf? If the ERP event log shows only the human login, you lose the ability to reconstruct what happened, and with it the basis for a conversation with an auditor.
- The limit of delegation. What an employee may hand over to an agent without approval, and what may not pass without a human-in-the-loop gate. Issuing a payment, changing counterparty details, an action on a production environment, a decision affecting another person - these are not candidates for silent delegation, no matter how well the agent handles a form.
- Data egress. The task “summarise these invoices for me” means the content of the invoices reaches a model. For organisations covered by NIS2, DORA or the AI Act this is a question about the place of processing, the masking of personal data and the entry in the register, not a matter of convenience.
Note that none of these three questions is about Delegate as a tool. All of them concern the oversight layer held one level above: the audit trail, the platform policy, the gates for high-risk actions. A week ago we described that layer using the example of human-in-the-loop gates in UiPath Maestro and the AI Trust Layer. The “agent for a person” model does not change a single principle in it. It changes the scale: not ten processes under CoE care, but every desk in the company.
What is still ahead
A few things will only become clear at launch: integration with Orchestrator and Maestro, the ability to move a flow from a recording into Studio, where the controlling model runs, credential handling, the licensing model and the general availability date. The first public deployments and independent measurements of effectiveness are still ahead as well.
We track this at the source, not in summaries. If one thread is of particular interest to you - licensing and testing are the most frequent questions - write to us and we will gladly walk through it with you.
What is worth doing in the coming weeks
Four things, all feasible without access to the product and all useful regardless of when Delegate reaches the market.
- Write down a catalogue of tasks at role level, not process level. Not candidates for classic RPA, but the twenty minutes a day a specific role loses on copying, tidying files and retyping data between applications. That is an entirely different list from the one in your automation portfolio, and it is the one that will determine the value of such a tool.
- Set a delegation policy before you need it. A short document: what an employee may hand to an agent on their own, what requires approval, what must never be delegated. Three pages are enough and they are better written calmly.
- Check whether your audit trail distinguishes a human from an agent acting on their behalf. That is a question for the systems you already have, not for UiPath. The answer is often uncomfortable.
- Plan competencies rather than budget. A review of automations built outside the CoE, an owner of the oversight policy, a path for reporting and taking over flows from people who change roles. It is also worth joining the Labs waiting list - it gives earlier insight, and the access terms will become clear at launch.
From what we have seen in automation projects, every next stage was won by the organisations that prepared the oversight layer before the tool, not by those that bought licences fastest. In a model where every employee builds automation by recording their own task, that pattern does not weaken. It gets stronger.
If you would like to work through this topic on the specifics of your environment - the portfolio, agent identities, gates for high-risk actions - write to us. We are a UiPath Platinum partner and a participant in the Agentic Fast Track programme, so we base the conversation on what is confirmed rather than on announcements.