> ## Documentation Index
> Fetch the complete documentation index at: https://vetta.sh/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Limits & billing

> Concurrency caps, runtime ceilings, output limits, and the exact metering model for compute.

Compute is metered from the seconds a computer actually ran, booked against your [budget](https://vetta.sh/docs/concepts/budgets.md) at the end of each turn and drawn from the organization's real-USD balance. This page is the reference for the caps and the exact per-unit rates.

> [!NOTE]
>
> Every rate on this page is **the price you pay** — the number booked to the [ledger](https://vetta.sh/docs/platform/billing.md) and reported on your spend breakdown. Model inference is priced separately; see [Model router & inference](https://vetta.sh/docs/concepts/model-router.md).

## The compute meter

While a computer is **running**, it is metered **per second** on its *provisioned* resources — vCPU and memory. There is **no creation fee**, and **disk is not metered**: the boot disk is inside the allowance the computer ships with. Billing granularity is per-second.

| Resource | Per second | Per hour |
| - | - | - |
| vCPU | `$0.000014` | `$0.0504` |
| Memory (per GiB) | `$0.0000045` | `$0.0162` |

| State | Billed |
| - | - |
| `running` | Per-second vCPU + memory. |
| `sleeping` / paused | **Nothing** — no vCPU, no memory, no storage charge. |
| `destroyed` | Nothing further. |

A session's computer is **`1 vCPU / 1 GiB`**, so a full hour of *running* time is **`$0.0504 + $0.0162 = $0.0666`**. Because idle maps onto the [runtime's](https://vetta.sh/docs/concepts/runtime.md) wake/sleep cycle, a computer waiting between turns is metered for nothing at all — the mechanism behind Naive Managed Agents' low cost on multi-hour tasks.

## The browser

The optional [browser](https://vetta.sh/docs/computer/browser.md) is metered **per session minute, open to close** (rounded up, minimum one minute), as one `browser` line on the [ledger](https://vetta.sh/docs/platform/billing.md) debited when the session closes — there is no up-front hold, because a session's cost is knowable only at close. The model-driven actions (`act`, `extract` with an instruction, `observe`) add their spend to the same `browser` line, one entry per action. A browsing agent also pays the tokens it spends driving the browser and the computer time of the session driving it.

Its limit is the per-session timeout below; a session past it is closed and billed by the platform clock within a minute.

## Mobile devices

A [mobile device](https://vetta.sh/docs/computer/mobile.md) is metered **per device-minute, create to end** (rounded up, minimum one minute), at `$0.030` a minute. It is one `mobile` line on the [ledger](https://vetta.sh/docs/platform/billing.md), debited once when the device ends, with no up-front hold. Actions add nothing. A device that failed to provision bills nothing. A device stopped at its `max_duration_minutes` is billed for the minutes it actually ran until it ended, at most 5 minutes past its maximum.

There is no limit on how many devices an organization runs, only on what it can pay for: a create needs a balance that covers 10 minutes (`$0.30`) for every live device and the new one, plus what the live ones have run so far (`402 insufficient_credits` otherwise). The platform checks running devices every minute: an organization whose plan has lapsed, or whose balance no longer covers what its devices have accrued, has them ended with `termination_reason: "unfunded"`, billed for the minutes they ran. A `past_due` plan keeps its devices through the payment grace period.

## Concurrency

Every computer counts toward your organization's concurrency cap the entire time it is not `destroyed` — `running`, `sleeping`, and `parked` all occupy a slot; only a destroy frees one. The defaults below are per organization and are **raised on request** — they are safety rails, not hard product ceilings.

| Concurrency limit | Default | Notes |
| - | - | - |
| Concurrent computers per org | `25` | Counts every non-`destroyed` computer (`running` + `sleeping` + `parked`). |
| Live mobile devices per org | No count limit | Bounded by the balance: 10 minutes of runway per live [mobile device](https://vetta.sh/docs/computer/mobile.md) and the new one (above). When the platform's phones are all in use, a create is `429 rate_limited`. |

## Boot & wake latency

Only cold boots pay the full provisioning cost; the wake/sleep cycle the [runtime](https://vetta.sh/docs/concepts/runtime.md) uses between turns is near-instant, which is what makes idle cheap.

| Transition | Typical latency | What happens |
| - | - | - |
| Cold boot (fresh `create`) | \~2 s | A micro-VM is provisioned from a clean image. |
| Boot from a [snapshot](https://vetta.sh/docs/computer/snapshots-and-volumes.md#checkpoints) | \~3 s | Disk state is restored before the VM runs. |
| Wake from `sleeping` | \~300 ms | Disk and memory are preserved; the next exec or file op resumes it. |
| Resume from `parked` | \~300 ms | Same as a wake, but requires an explicit `resume`. |

> [!NOTE]
>
> The fully virtualized **isolate** mode (`mode: "isolate"`, **coming soon**) targets near-instant boot and near-zero idle; the numbers above describe the micro-VM that ships today.

## Limits

| Limit | Value | Notes |
| - | - | - |
| Max runtime | `max_duration_hours` per computer (default 12h) | A computer exceeding its ceiling is auto-destroyed. |
| Idle auto-pause | `idle_timeout_minutes` per computer | Optional; pauses to storage-only after idle. |
| Auto-destroy on credit exhaustion | balance ≤ 0 | Protects against runaway spend. |
| Shell output | 262,144 chars each for stdout/stderr | See [Shell](https://vetta.sh/docs/computer/shell.md). |
| File read/write | 4 MiB per call | See [Filesystem](https://vetta.sh/docs/computer/filesystem.md). |
| `publish_file` / `fetch_file` | 5 GiB per file | Moved in slices; see [Files](https://vetta.sh/docs/capabilities/files.md). |
| Persistent volume size | 1 MiB – 100 GiB | See [Snapshots & volumes](https://vetta.sh/docs/computer/snapshots-and-volumes.md). |
| Browser session timeout | 1 min – 6 h (`timeout_minutes`, max 360) | Hard per-session TTL. |

> [!NOTE]
>
> `max_duration_hours` bounds a computer's **total lifetime from create to destroy** — it is wall-clock, not billed compute-seconds, so a computer that sleeps most of that window still hits the ceiling on schedule. Only `running` seconds are metered; the ceiling is a safety cap on how long the computer may exist.

> [!WARNING]
>
> A computer is **auto-destroyed** when it exceeds its max runtime or the organization's balance reaches zero. Persist anything you need to keep with [`publish_file`](https://vetta.sh/docs/capabilities/files) or a [volume](https://vetta.sh/docs/computer/snapshots-and-volumes.md) before then.

## Inspecting spend

Compute spend appears as the `computer` component of the [agent's spend breakdown](https://vetta.sh/docs/concepts/budgets.md) and as a line item on the organization [ledger](https://vetta.sh/docs/platform/billing.md).

```bash CLI theme={"system"}
vetta agent spend agt_01j8rf6tq2m4vz9xkp3n7c5hwd --by component
```

Spend is reported on the wire as integer **micro-USD** (`1 USD = 1_000_000`); the CLI renders dollars for humans.

```json theme={"system"}
{ "by_component": { "model": 11902000, "computer": 481000 } }
```

> [card] [Back to the computer overview](https://vetta.sh/docs/computer/index.md)
>
> The full computer surface at a glance.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.