Contents
Fast answer
UiPath meters four different things in four different units, and reconciling them is the whole exercise. Robot Units meter automation runtime: on serverless, production robots consume 1 Robot Unit per minute at Small, 2 at Standard, 4 at Medium and 10 at Large, with testing robots at half those rates. A VM machine instead carries a monthly allocation, 6,000 Robot Units a month for a Standard production machine and 3,000 for testing, plus 500 for the Fast cost profile or 1,000 for Always. Agents are metered per LLM call, and here the unit depends on which contract you signed. Under Unified Pricing an agent call costs 0.4 Platform Units on a premium model, 0.2 on standard, 0.16 on basic, and customer-managed models cost 0.2 Platform Units once per run. Under Flex Licensing the identical call costs 2 Agent Units, 1, 0.8, and 1 per run. That is a 5x divergence in the metered number for the same work. UiPath publishes no dollar price for any of these units. Verified 1 September 2026.
Facts last verified 2026-09
Quick facts
- Serverless production RU/min
- Small 1, Standard 2, Medium 4, Large 10 (checked 2026-09-01)
- Serverless testing RU/min
- Small 0.5, Standard 1, Medium 2, Large 5
- VM production monthly RU
- Small 5,000, Standard 6,000, Medium 7,500, Large 10,000
- VM testing monthly RU
- Small 2,000, Standard 3,000, Medium 5,500, Large 9,000
- Cost profiles
- Fast adds 500 RU/month, Always adds 1,000 RU/month
- Unified Pricing (Platform Units)
- 0.4 premium, 0.2 standard, 0.16 basic per LLM call; 0.2 per run customer-managed
- Flex Licensing (Agent Units)
- 2 premium, 1 standard, 0.8 basic per LLM call; 1 per run customer-managed
- Divergence
- Every Flex rate is 5x the Unified rate in raw units for the identical call
- Dollar price per unit
- Not published for Robot Units, Platform Units or Agent Units
On this page
What this page covers
A comparison visitor should understand the tradeoff, the best-fit scenario, and the next diagnostic tool to confirm the choice.
- 01Four units, one platform
- 02Robot Units: the runtime meter
- 03Platform Units versus Agent Units
- 04The same action, two contracts, 5x apart
- 05Computing consumption without a price
- 06What to ask before you sign
Why does this matter now?
UiPath is the clearest example in enterprise automation of a vendor that has documented consumption exhaustively and price not at all. You can compute, to the minute and to the call, exactly how many units a workload will burn, and still have no idea what your invoice will say. Worse, the same workload produces two different unit counts depending on your licensing model, which makes vendor-published examples and third-party comparisons almost impossible to apply to your own contract without first establishing which unit you are counting in.
Internal path
Where to go next from this page
These links are part of the A8gent learning and conversion path. Use them to move from concept, to diagnosis, to workflow build, to course.
What you should be able to do after this
- Tell UiPath's four consumption units apart
- Convert robot runtime into Robot Units
- See the 5x Platform Unit versus Agent Unit divergence
- Compute your consumption even though the price is unpublished
How do you do it, step by step?
1. Establish which licensing model you are on first
Nothing downstream makes sense until you know whether you are on Unified Pricing, which meters agents in Platform Units, or Flex Licensing, which meters them in Agent Units. The rates differ by a factor of five for identical calls. Any number you read anywhere about UiPath agent consumption is meaningless until you have attached it to one of these two models.
2. Convert robot runtime into Robot Units
On serverless, multiply runtime minutes by the size rate: 1 Robot Unit per minute for Production Small, 2 for Standard, 4 for Medium and 10 for Large. Testing robots run at half: 0.5, 1, 2 and 5. Runtime is the meter, not the number of jobs, so a slow process on a Large robot is the most expensive shape of work on the platform.
3. Treat VM machines as a monthly allocation, not a per-minute meter
A VM machine consumes a fixed monthly Robot Unit allocation by size. Production is 5,000 for Small, 6,000 for Standard, 7,500 for Medium and 10,000 for Large. Testing is 2,000, 3,000, 5,500 and 9,000. Cost profiles add on top: 500 Robot Units a month for Fast and 1,000 for Always. A lightly used VM machine therefore costs the same as a heavily used one.
4. Count agent LLM calls, then apply your contract's rate
Agents meter per LLM call, and one agent run usually makes several. Under Unified Pricing that is 0.4 Platform Units per premium call, 0.2 standard, 0.16 basic, and 0.2 once per run for a customer-managed model. Under Flex Licensing it is 2 Agent Units, 1, 0.8, and 1 per run. Model tier is defined by which model you selected, so a model choice is directly a pricing choice.
5. Ask for the dollar rate, because it is not published
UiPath publishes no price per Robot Unit, Platform Unit or Agent Unit. The agent licensing documentation tells you to work with a sales representative to assess your use case and predicted consumption. Arrive with your computed unit totals for both models and ask for the rate on each, plus the included allocation and the overage rate.
Four units on one platform, and nobody puts them side by side
UiPath does not have a pricing model. It has several, running in parallel, metering different parts of the same platform in units that do not convert into one another. Robot Units meter automation runtime. Platform Units meter agent LLM calls for customers on Unified Pricing. Agent Units meter the identical calls for customers on Flex Licensing. AI Units meter the AI Center and document understanding workloads that predate the agent products. A single automation that runs a robot, calls an agent and processes a document touches three of those meters, and no public page reconciles them, which is why so many UiPath cost conversations go in circles.
The reconciliation matters most where two of the units overlap in purpose, because that is where comparison silently breaks. Platform Units and Agent Units meter exactly the same event: one LLM call made by an agent. They are not two different things being measured. They are two different numbers produced by the same measurement, depending on a contract term. Any figure you read about UiPath agent consumption is therefore uninterpretable until you know which of the two units it is denominated in, and most sources do not say.
The clean way to hold this is to separate the meter from the money at every step. UiPath's documentation is genuinely excellent on the meter. It tells you precisely how many Robot Units a Large production robot burns per minute, precisely how many Platform Units a premium model call costs, and precisely how a customer-managed model is charged once per run rather than per call. It tells you nothing whatever about what any of those units cost in dollars. That is a deliberate and consistent split, and once you see it, the documentation becomes very useful rather than very frustrating.
For anyone coming from the per-task or per-execution world, this will feel unfamiliar in a specific way. A Zapier task and an n8n execution are units you can price to the cent from a public page in about ninety seconds. A UiPath Robot Unit is a unit you can count to the minute and cannot price at all without a sales conversation. Neither approach is dishonest; they are aimed at different buyers. But the enterprise version demands that you do the consumption modelling yourself, up front, because nobody is going to hand you a total.
Robot Units meter runtime, and the shape of the work decides the bill
On serverless robots, Robot Units accrue by the minute at a rate set by machine size. A Production Small robot consumes 1 Robot Unit per minute, Standard 2, Medium 4 and Large 10. Testing robots run at exactly half those rates: 0.5, 1, 2 and 5. The consequence is worth stating bluntly because it is the most expensive thing people get wrong. Because Large costs ten times Small per minute and slow processes run for more minutes, over-sizing a robot for a job that does not need the resources is a multiplicative mistake rather than an additive one.
VM machines work on a completely different principle and mixing the two mental models is the second common error. A VM machine does not meter per minute; it consumes a fixed monthly Robot Unit allocation by size. Production is 5,000 Robot Units a month for Small, 6,000 for Standard, 7,500 for Medium and 10,000 for Large. Testing is 2,000, 3,000, 5,500 and 9,000. That allocation is consumed whether the machine runs constantly or sits idle, which means a lightly used VM machine is expensive per unit of work done and a heavily used one is cheap.
Cost profiles sit on top of the machine allocation as a flat monthly addition. The Fast profile adds 500 Robot Units a month and the Always profile adds 1,000, in both production and testing environments. These are frequently switched on during a proof of concept for convenience and then never reviewed, which produces a small permanent charge attached to a decision nobody remembers making. Auditing cost profiles across your machines is one of the quickest consumption reductions available on the platform.
Put those two mechanics together and the design guidance falls out on its own. Bursty, infrequent, short-running work belongs on serverless, where you pay for the minutes you use and a Small robot costs a single Robot Unit a minute. Continuous, high-utilisation work belongs on VM machines, where the fixed allocation is amortised across far more executions. Choosing the wrong one is not a rounding error; it is the difference between paying for idle capacity and paying for work.
The same call, two contracts, five times apart
Here is the reconciliation that no public page appears to have made. Under Unified Pricing, an agent's LLM call consumes 0.4 Platform Units on a premium model, 0.2 on a standard model, 0.16 on a basic model, and a customer-managed model consumes 0.2 Platform Units charged once per run rather than per call. Under Flex Licensing, the identical calls consume 2 Agent Units, 1 Agent Unit, 0.8 Agent Units, and 1 Agent Unit per run. Line those up and the ratio is constant: every Flex rate is exactly five times the corresponding Unified rate in raw numbers.
That is not a five-times price difference, and it is important to be exact about this because getting it wrong in either direction is costly. It is a five-times difference in the metered number, because Platform Units and Agent Units are different denominations. Whether it is also a price difference depends entirely on the dollar value of each unit in your contract, and UiPath publishes neither. What it definitively is, is a trap for comparison: quote an agent's consumption as 1 unit per call and you have said nothing until you say which unit, and a procurement spreadsheet that mixes the two is off by 5x on those rows.
The model tier split is the other half of the agent meter, and it is a design decision with a direct consumption consequence. Premium models are the most expensive tier per call, standard sits in the middle and basic is the cheapest, and UiPath defines each tier by naming the specific models in it. Routing straightforward extraction and classification steps to a basic-tier model while reserving the premium tier for genuinely hard reasoning is the same optimisation you would make on a raw model API, expressed in UiPath's units instead of tokens.
Customer-managed models deserve their own note because their metering rule is structurally different. Under both licensing models a customer-managed model is charged once per run rather than per LLM call. For an agent that makes many calls inside a single run, that is a materially different curve from the per-call tiers, and it interacts with the fact that you are separately paying your own model provider for the tokens. UiPath also notes that input tokens are charged in 64,000-token increments for UiPath-hosted models, while customer-managed models are not metered by token count at all.
None of which tells you what any of it costs. UiPath's agent licensing documentation says to work with your sales representative to assess your use case and predicted consumption, and there is no dollar figure for a Robot Unit, a Platform Unit or an Agent Unit anywhere in the public documentation. So the deliverable from this page is a consumption model, computed in both denominations, that you hand to your account team and ask them to price. That is more preparation than most buyers do, and it is the only thing that makes the resulting quote checkable.
At a glance
UiPath consumption units reconciled, read from UiPath Orchestrator and Agents documentation on 1 September 2026
| Unit | What it meters | Published rate | Which plan |
|---|---|---|---|
| Robot Unit | Serverless robot runtime, production | 1 RU/min Small, 2 Standard, 4 Medium, 10 Large | All Orchestrator plans |
| Robot Unit | Serverless robot runtime, testing | 0.5 RU/min Small, 1 Standard, 2 Medium, 5 Large | All Orchestrator plans |
| Robot Unit | VM machine, production | 5,000 / 6,000 / 7,500 / 10,000 RU per month by size | All Orchestrator plans |
| Robot Unit | VM machine, testing | 2,000 / 3,000 / 5,500 / 9,000 RU per month by size | All Orchestrator plans |
| Robot Unit | Cost profile add-on | Fast +500 RU/month, Always +1,000 RU/month | All Orchestrator plans |
| Platform Unit | Agent LLM call, premium model | 0.4 per call | Unified Pricing |
| Platform Unit | Agent LLM call, standard model | 0.2 per call | Unified Pricing |
| Platform Unit | Agent LLM call, basic model | 0.16 per call | Unified Pricing |
| Platform Unit | Customer-managed model | 0.2 per run, not per call | Unified Pricing |
| Agent Unit | Agent LLM call, premium model | 2 per call | Flex Licensing |
| Agent Unit | Agent LLM call, standard model | 1 per call | Flex Licensing |
| Agent Unit | Agent LLM call, basic model | 0.8 per call | Flex Licensing |
| Agent Unit | Customer-managed model | 1 per run, not per call | Flex Licensing |
| Token handling | UiPath-hosted model input | Charged in 64,000-token increments; customer-managed models not metered by token count | Both |
| Dollar price | Any of the above units | Not published | Both |
What mistakes should you avoid?
- Comparing a Platform Unit figure against an Agent Unit figure as if they were the same unit
- Counting agent runs when the meter is LLM calls, which are usually several per run
- Assuming a VM machine is metered per minute when it consumes a fixed monthly allocation
- Forgetting that the Fast and Always cost profiles add Robot Units on top of the machine allocation
- Sizing robots Large for headroom when Large costs ten times Small per minute
- Assuming a published unit count implies a published price, which it does not
FAQ
- How much does UiPath cost per Robot Unit?
- UiPath does not publish a dollar price per Robot Unit. Its consumption documentation specifies the number of Robot Units each robot size and cost profile consumes and stops there. As of 1 September 2026 the price is available only from a UiPath sales representative, so we do not print an estimate.
- What is the difference between a Platform Unit and an Agent Unit?
- They are the agent meters for two different licensing models. Unified Pricing meters in Platform Units at 0.4 per premium LLM call, 0.2 standard, 0.16 basic and 0.2 per run for customer-managed models. Flex Licensing meters in Agent Units at 2, 1, 0.8 and 1 per run. The same call costs 0.2 Platform Units or 1 Agent Unit, a 5x divergence in the metered number.
- How many Robot Units does a robot consume per minute?
- On serverless: Production Small 1, Standard 2, Medium 4, Large 10 Robot Units per minute. Testing runs at half: Small 0.5, Standard 1, Medium 2, Large 5. VM machines are different, consuming a fixed monthly allocation by size rather than a per-minute rate.
- Do UiPath cost profiles change consumption?
- Yes, for VM machines. The Fast cost profile adds 500 Robot Units a month and the Always profile adds 1,000, on top of the machine size allocation, in both production and testing environments. That is a fixed monthly addition rather than a usage-driven one.
- Can I forecast a UiPath bill from the public documentation?
- You can forecast consumption exactly and cost not at all. The documentation gives you every unit rate you need to compute Robot Units, Platform Units and Agent Units for a workload. It gives no dollar value for any of those units, so the last multiplication has to come from your account team.
Sources & further reading
Done for you
Want this built for your business?
Tell us the workflow. We scope, build, and ship the agent with guardrails and the numbers to prove it worked. The scoping call is free.
Free scoping call. You own the code.
Was this page helpful?

