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

# Changelog

> What changed, newest first.

**2026-11-17**

Billing

## Billed per second, with a 1-minute minimum

* A sandbox that runs less than a minute is now billed one minute of the vCPU and memory it is
  given. After the first minute nothing changes: every second is billed, so a sandbox that runs
  90 seconds is billed 90 seconds.
* A sandbox deleted within its first few seconds used to get no usage record at all, so it was
  never billed and `anona-compute usage --sandbox <id>` said it had no usage. Every sandbox that
  ran now gets one.
* The minimum is worked out a few minutes after a sandbox ends, and applies to sandboxes that
  end from today. A sandbox ended by a platform fault is not billed a minimum.

**2026-11-16**

CLI 0.4.1

## CLI 0.4.1

`npm install -g @anona-labs/anona-compute` installs 0.4.1.

* `anona-compute login` with no `--web-url` opened a sign-in page that answered `404`: the
  default dashboard URL was `https://app.<domain>`, which does not exist. It is now
  `https://<domain>`, where the dashboard and the device sign-in live. On 0.4.0, pass
  `--web-url https://compute.anonalabs.com`.
* The `vault --help` example now passes `--allow-out` with `--no-internet`: a vault rule injects
  into requests to its host but does not open that host, so without `--allow-out` the request is
  refused.

**2026-11-14**

SDK 0.3.0

## SDK 0.3.0: creates wait for capacity

In `anona-compute` 0.3.0 (Python) and `@anona-labs/compute-sdk` 0.3.0 (TypeScript).

* `Sandbox.create` and `Sandbox.connect` wait when the fleet is full instead of failing at
  once: a `503` marked `Should-Retry: true` (`sandbox_capacity_unavailable` while a host starts,
  and the platform starting) is retried after its `Retry-After`, held between 1 and 30 seconds,
  for up to 10 minutes. Set `wait_for_capacity` / `waitForCapacityMs` per call or in
  `configure()`, or `ANONA_COMPUTE_CAPACITY_WAIT`; `0` turns it off. `on_capacity_wait` /
  `onCapacityWait` is called before each wait. Plan limits and every other error are not
  retried. See [Python](/docs/sdk/python.md#waiting-for-capacity) and
  [TypeScript](/docs/sdk/typescript.md#waiting-for-capacity).

**2026-11-14**

CLI 0.4.0

## CLI 0.4.0

`npm install -g @anona-labs/anona-compute` installs 0.4.0.

* `resume` waits for capacity like `create`, with `--capacity-wait` (default 10 minutes) and
  progress lines on stderr. Both also wait out `sandbox_size_preparing`, and hold each wait's
  `Retry-After` between 1 and 30 seconds with a little jitter.
* A plan limit (`error_code` `plan_limit_exceeded`) exits 5, like a rate limit, whether the
  gateway answered `429` or `403`; `--size` help says Free defaults to the smallest size.
* `anona-compute usage` shows the month against what your plan includes: vCPU-hours, memory,
  egress and storage, what is over, and whether Free has stopped.

**2026-11-14**

No maximum lifetime

## No plan has a maximum sandbox lifetime

Free and Starter no longer cap a sandbox at one hour and 24 hours. Every plan accepts
`timeout=-1`, which means no deadline, and any longer timeout. Free is still bounded by its
month's included vCPU-hours: running sandboxes pause when those are used up. Let a sandbox
without a deadline [pause when idle](/docs/concepts/lifecycle.md#pause-when-idle) so it stops using
them. See [Lifecycle](/docs/concepts/lifecycle.md#no-time-limit).

**2026-11-13**

New plans and pricing

## Plans include usage every month

Free, Starter, Pro and Scale now cost $0, $19, $99 and $399 a month and include 100, 330,
1,800 and 7,500 vCPU-hours (each with 2 GiB of memory per vCPU) and 5, 25, 100 and 250 GB
of egress every calendar month. Usage is billed on the vCPU and memory a sandbox is given,
per second: $0.04 a vCPU-hour and $0.01 a GiB-hour, so 1 vCPU and 2 GiB is $0.06 an hour.
    Paused sandboxes and snapshots are $0.0000685 per GiB-hour, egress \$0.12 per GB. See
[Pricing](/docs/pricing.md).

* Free stops when its month's included usage is used up: new sandboxes and resumes get
  `403` `plan_limit_exceeded` and running sandboxes are paused until the month ends. Paid
  plans keep running and are billed for what is over on the next invoice.
* Free's public internet egress stays off for now; its 5 GB a month applies once a real-time
  cap is in place.
* Owners and admins get an email at 80% and 100% of the month's included vCPU-hours and egress.
* Credit you already have keeps paying for usage over the included amount until it is spent.
  New credit codes, sign-up credit, invites and referral rewards are no longer given; discount
  codes still work.
* `GET /v1/usage` and the dashboard show the month against what the plan includes;
  `anona-compute usage` does too from the next CLI release.

**2026-11-13**

Plan limits

## Every plan limit is enforced, and says which

Each plan's limits are now enforced as published on [Regions and limits](/docs/concepts/limits.md):
sandboxes and vCPU at once, the largest size (Free and Starter Medium, Pro Large, Scale XL;
Free at most two Medium at once), sandbox creates and API requests per minute, API keys,
custom templates (Free: 2), template storage and paused sandboxes. A refusal has
`error_code` `plan_limit_exceeded` with `limit_name`, `limit`, `current` and `plan`: `429`
for what runs at once, `403` for the rest. Rate limits stay `429` `rate_limited` with
`Retry-After`. Nothing you already have is stopped if your plan's limits are lower; new
things are refused until you are under them.

* On Free, a sandbox created without a size runs at the smallest size its template allows:
  Small for `base`, `python`, `node` and `code-interpreter`, Medium for the desktops.
* Template storage counts each template's current build only.
* At the paused-sandbox limit, a pause you ask for is refused, and an idle pause or a pause
  on timeout deletes the sandbox instead (end reason `paused_limit`).
* Free deletes a paused sandbox 14 days after it was paused, after emailing the team's
  owners and admins three days before.
* With the next CLI release, `anona-compute` exits 5 on a plan limit.

**2026-11-13**

CLI 0.3.1

## CLI 0.3.1

* `anona-compute usage --top N` reads as many pages of `GET /v1/usage` as it needs, and
  `--sandbox <id>` shows one sandbox's row wherever it ranks.
* When a template's newest build fails while an earlier build still serves it, `template list`
  shows `ready (last build failed)`, and `template info` adds a `Last build` line with the build ID
  and the error. With `--json`, `last_build_id`, `last_build_status` and `last_build_error`.

**2026-11-13**

Usage API: every sandbox, documented rows

## Every sandbox in GET /v1/usage

`GET /v1/usage` used to list only the 50 most expensive sandboxes of a period. It now
pages: `limit` (up to 1000) and `cursor`, with `nextCursor` in the response, or
`sandboxId` for one sandbox's row. The API reference describes every field of the
sandbox and template rows, and which are allocated (size times running time) and
which are consumed. In the CLI, `anona-compute usage --top N` reads as many pages
as it needs and `--sandbox <id>` shows one row; both come with the next CLI release
(not 0.3.0).

## Running time matches the sandbox's lifetime

Running time is now clipped to a sandbox's start and delete times and no longer misses
the seconds before its first sample, so it lands within a few seconds of start to delete
instead of anywhere from about 15 seconds short to a minute over. See
[What counts](/docs/usage-and-billing.md#what-counts).

**2026-11-13**

CLI 0.3.0

## CLI 0.3.0

`npm install -g @anona-labs/anona-compute` installs 0.3.0. It is also the first CLI release
with binaries on the public [releases page](https://github.com/anonalabs/anona-compute-sdk/releases)
(`cli-v0.3.0`, with `SHA256SUMS`) and through
`go install github.com/anonalabs/anona-compute-sdk/cli/cmd/anona-compute@latest`.

* **Breaking for scripts:** with `--json`, `list`, `ps`, `template list` (with or without
  `--all`) and `config list` print one JSON array, `[]` when there is nothing to list, instead
  of one object per line. An empty list used to print nothing, which is not JSON. Read items with
  `jq '.[]'`, or a field with `jq -r '.[].sandbox_id'`. Other commands still print one object
  per line.
* `template info` shows a built-in template's vCPU, memory and disk from the template catalog,
  as `template list --all` does. It used to show a new build's defaults (2 vCPU and 2048 MiB for
  both `base` and `desktop`). Its "Minimum size" line now says that a built-in's minimum is set
  per template.

**2026-11-13**

Open-source CLI and SDKs

## The CLI and SDKs are open source

The `anona-compute` CLI, the Python `anona-compute` and TypeScript `@anona-labs/compute-sdk`
SDK extras, the agent skill and the examples are public under Apache-2.0 in
[anona-compute-sdk](https://github.com/anonalabs/anona-compute-sdk). npm stays the main way to
install the CLI, and there are now two more:

* Download the binary for your platform from the
  [releases page](https://github.com/anonalabs/anona-compute-sdk/releases), with `SHA256SUMS`.
* `go install github.com/anonalabs/anona-compute-sdk/cli/cmd/anona-compute@latest`.

The SDK extras are on PyPI (`pip install anona-compute`) and npm
(`npm install @anona-labs/compute-sdk e2b`). See [Install the CLI](/docs/cli/overview.md#install).

**2026-11-12**

CLI 0.2.0

## CLI 0.2.0 on npm

`npm install -g @anona-labs/anona-compute` now installs 0.2.0:

* `create` and `run` take `--size small|medium|large|xl`; `info` and `template info` show sizes.
* `create --count` runs creates independently, up to `--parallel` at once (default 4), each with its own `--create-timeout`, and prints a created and failed summary. One failing create no longer holds up the batch.
* A create held while a host starts is waited out for up to `--capacity-wait` (default 10 minutes, or `ANONA_COMPUTE_CAPACITY_WAIT`) with progress lines, instead of failing after 60 seconds.

**2026-11-12**

Sandbox sizes

## Sandbox sizes: Small, Medium, Large and XL

Create a sandbox at a size that sets its vCPU, memory and disk:
Small (1 vCPU, 2 GiB, 10 GB), Medium (2, 4 GiB, 20 GB), Large (4, 8 GiB, 40 GB)
or XL (8, 16 GiB, 80 GB). `anona-compute create --size large`, `size` in the create
body, `Sandbox.create(..., size="large")` in Python, `withSize("large")` in
TypeScript, or the size picker in the console.

A template's own vCPU, memory and disk are now its minimum requirements, so one
template runs at every size at or above them. Without a size, nothing changes: a
sandbox runs at its template's own size. See [Sandbox sizes](/docs/concepts/sizes.md).

**2026-11-09**

Docs move to /docs; dashboard password reset

## Docs live at compute.anonalabs.com/docs

The docs are now at [compute.anonalabs.com/docs](https://compute.anonalabs.com/docs).
The agent setup prompt, the welcome email and the `llms.txt` links all point there:

```text
Set up Anona Compute for me. Fetch https://compute.anonalabs.com/docs/agents/onboarding-prompt.md and follow it.
```

## Dashboard

* **Forgot password.** Email and password accounts can reset a lost password from the
  sign-in page. The link works once and expires after an hour; resetting signs out
  your other sessions.
* **Feedback on actions.** Pause, resume, extend, delete and key changes confirm with a
  short toast.
* **Phones.** Sign out is reachable on narrow screens, and there is a skip link for
  keyboard users.
* **Billing and usage.** The usage chart stays readable
  when one day dwarfs the rest, with a **Show as a table** view of exact values.

**2026-11-05**

Idle pause everywhere; timeouts are enforced

## Pause a sandbox when nothing is using it

A sandbox can already pause itself once nothing has used it for a while, but until
now only the dashboard and raw API could ask for it, and the dashboard offered one
fixed time. It is now in every surface, with the time your choice.

* **SDKs**: `sandbox.idle_pause.set(15)` in Python, `sandbox.idlePause.set(15)` in
  TypeScript, plus `get()` and `off()`. Neither SDK could reach the feature before.
* **CLI**: `--idle-pause 15m` on `create` and `run`, and `anona-compute idle-pause
  SANDBOX_ID 1h` (or `off`) on a sandbox that is already running.
* **MCP**: `create_sandbox` takes `idle_pause_minutes`.
* **Dashboard**: picking the lifetime **No limit (pauses when idle)** now shows an
  idle time beside it - team default, 5 minutes, 15, 30, 1 hour, 2, 6 or 24 - and
  the same times are in **Extend** on a running sandbox.

Idle means no request to any port, no open terminal, live view, SSH session or byte
pipe, and no process `envd` started still running. **Work the sandbox started by
itself does not count**, so a background loop nobody is watching will still pause.
A paused sandbox costs no compute, only snapshot storage.

```bash idle_pause_changelog.sh
SANDBOX_ID=$(anona-compute create -t base --timeout never --idle-pause 15m --json | jq -r .sandbox_id)
anona-compute idle-pause "$SANDBOX_ID" 1h
```

## Sandbox timeouts are now enforced

The gateway's timeout controller ran in report-only mode: it logged what it would
do and did nothing. A sandbox whose timeout had passed could stay listed as running
indefinitely. It now acts, so a sandbox ends at its deadline - deleted, or paused if
it was created with pause-on-timeout.

See [Lifecycle](/docs/concepts/lifecycle.md).

**2026-11-05**

CLI: credential vault and egress rules

## Manage the credential vault from the CLI

* **`anona-compute vault`**: `list`, `create`, `rotate`, `allowed-hosts`, `delete` and `unbind`. Until now the vault was reachable only from the dashboard or by calling the API yourself.
* There is no `vault get`. No response from the API carries a secret's value - the sandbox that uses it does not see it either - so there is nothing for such a command to print.
* Values are read from `--value-file` or from stdin, never from an argument: an argument is kept in your shell's history file and is visible in the process table. A single trailing newline is stripped, so a token saved from an editor does not carry one into the header.
* **Egress rules on `create` and `run`**: `--allow-out <host>`, `--vault-inject HOST:HEADER=[bearer:|basic:]SECRET`, and `--network-file <file>` for the whole policy document.

```bash vault_quickstart.sh
anona-compute vault create github_token --host api.github.com --value-file token.txt
anona-compute create --no-internet \
  --allow-out api.github.com \
  --vault-inject api.github.com:Authorization=bearer:github_token
```

See [Credentials without exposing them](/docs/concepts/networking.md#credentials-without-exposing-them).

**2026-11-04**

CLI: stdin, exit codes, JSON keys, doctor

## CLI: stdin, background output, exit codes, snake\_case JSON, doctor

* **Breaking for scripts that read `--json`**: every key is now snake\_case (`sandbox_id`, `template_id`, `exit_code`, `api_url`), as in the MCP server. `jq -r .sandboxID` becomes `jq -r .sandbox_id`. Errors are `{"error":{"message","exit_code","status","error_code","request_id"}}`.
* **Exit codes**: `exec` and `run` pass the remote command's exit code through unchanged and exit 125 when the CLI itself fails, so a remote 2, 3 or 4 no longer looks like a usage, sign-in or not-found error. Other commands keep 1-5. See [Output and exit codes](/docs/cli/overview.md#output-and-exit-codes).
* `exec -i` and `run -i` send stdin to the command. Without `-i`, a piped stdin now gets a warning instead of being dropped silently.
* `exec -b` keeps the command's output in the sandbox: `anona-compute output <id> <pid>` prints it (`-f` follows it) and `anona-compute ps <id>` lists processes.
* `anona-compute doctor` checks the configuration, the credential, the gateway and the built-in templates. `template list --all` lists the built-in templates next to yours. `timeout <id> never` removes a sandbox's deadline. `--version` works on the root command.
* Checked before anything is sent: `template build --cpu/--memory`, `view --ttl`, `preview --ttl`, `mcp --http`, and a desktop view of a sandbox without a desktop. `login --with-api-key` verifies the key it saves; `config get api_key` masks it unless `--reveal`.
* The npm package's wrapper no longer dies before the CLI on Ctrl-C, so `logs -f` exits 0 and `run` prints its summary.

**2026-10-31**

Delete, not Kill

## "Kill" is now "Delete"

* The dashboard, the CLI and these docs say **Delete** where they said Kill. `anona-compute delete` is the command; `anona-compute kill` and `rm` still work, and the JSON they print is unchanged.
* Nothing in the API changed: the E2B-compatible `DELETE /sandboxes/{id}`, the SDK's `kill()`, the MCP tool `kill_sandbox` and the `sandbox.lifecycle.killed` webhook event keep their names, so existing code runs as before.

**2026-10-30**

Fork

## Fork a running sandbox

* **Fork**: copy a running sandbox, with its memory, files and running processes, into up to 20 new sandboxes (`POST /sandboxes/{id}/fork`, the stock E2B SDK's `fork`, `anona-compute fork`, and **Fork** on the dashboard's sandbox page - the raw API accepts up to 100, but the SDK, CLI and dashboard all cap at 20). The original is frozen only while its memory delta is written - about 0.1 s - and then keeps running with the same ID and deadline.
* Each fork is a new sandbox: it takes a slot of your concurrent-sandbox limit, inherits the original's template, metadata, timeout policy and network policy, and is billed like any other sandbox. A batch larger than your plan has room for creates the forks that fit and reports the reason for each of the others, rather than failing as a whole.
* The dashboard's dialog asks how many copies and how long they live, prices the batch from your own rates before you commit, and lists the outcome of every copy. See [Fork](/docs/concepts/lifecycle.md#fork).

**2026-10-29**

Custom templates

## Build your own templates

* **Template builds**: `anona-compute template build` from a Dockerfile, and the stock E2B SDK's `Template.build` and `e2b` CLI commands, served by the gateway (`/v3/templates`, file uploads, build status, logs, list, get, delete, aliases). Each build runs in its own rootless BuildKit container with no credentials and only proxied egress, gets the Anona runtime layer, and is registered for `create -t <name>`.
* **Templates page** in the dashboard: list, build status, build log, delete. MCP tool `list_templates`.
* Template, build-concurrency and context-size quotas per organization.

**2026-10-28**

Preview links, idle pause

## Preview links, public ports, pause when idle

* **Preview links**: signed, expiring links to one port of a sandbox (`anona-compute preview`, `POST /v1/sandboxes/{id}/preview-links`, MCP `get_preview_url`, the dashboard's **Share preview**), revocable at once.
* **Public ports**: make one port public without opening the rest (`anona-compute preview <id> <port> --public`).
* **Pause when idle**: a sandbox pauses itself after a set time with no traffic, sessions or processes (`PUT /v1/sandboxes/{id}/auto-pause`, `autoPause: {"idleMinutes": n}` on create, or the dashboard's **No limit (pauses when idle)**).

**2026-10-28**

Webhooks, telemetry, DOM view

## Webhooks, OpenTelemetry export, DOM live view, thumbnails

* **Webhooks**: signed (Standard Webhooks) callbacks for sandbox lifecycle events, with retries, a delivery log and resend. See [Webhooks and telemetry](/docs/guides/webhooks.md).
* **OpenTelemetry export**: per-sandbox CPU, memory and network metrics and lifecycle spans to your OTLP/HTTP endpoint.
* **DOM live view**: the page open in a sandbox's Chrome, replayed in your browser.
* **Thumbnails**: a WebP of each sandbox every 3 seconds, on the dashboard and at `GET /v1/sandboxes/{id}/thumbnail`.
* New API key scope `integrations:manage` for the webhook and export settings.

**2026-10-28**

Network, vault, usage

## Network settings, credential vault, usage

* **Team egress settings**: the default network policy of new sandboxes, on the dashboard's **Network** page or `GET`/`PUT /v1/network`, with `GET /v1/sandboxes/{id}/network/effective` to see which layer a sandbox's policy came from.
* **Change a running sandbox's network**: E2B's `update_network` (`PUT /sandboxes/{id}/network`) now works.
* **Credential vault**: store API tokens once and reference them in header rules as `${vault.<name>}`; the egress proxy injects them and the sandbox never sees the value.
* **Usage and billing**: `anona-compute usage`, the MCP `get_usage` tool, and `GET /v1/usage` and `/v1/billing` with the new `usage:read` and `billing:read` API key scopes.
* **CLI & agent sessions**: a dashboard page lists every machine signed in with `anona-compute login` and revokes them; sign-outs, revocations and role changes now reach the API within seconds.

**2026-10-28**

Preview

## Developer preview

**Sandboxes**

* E2B-compatible API: create (v1 and v2), list, get, kill, connect, pause, resume, timeout and refresh, with E2B-shaped errors. Checked with the stock `e2b` SDK 2.20.3, 2.51.0 and 2.61.0.
* Long-running sandboxes: `timeout=-1` for no deadline on plans without a maximum lifetime, and pause instead of kill at timeout.
* Templates `base`, `python`, `node`, `code-interpreter`, `desktop` and `coding-agent`.
* Egress policy at create: plan defaults, allow and deny lists, and a platform floor that always blocks private ranges and cloud metadata.
* Every sandbox request passes the gateway, which checks a per-sandbox token.

**Access**

* Live view of the terminal and the desktop, embeddable in your page, with short-lived viewer tokens and revoke-all.
* SSH with 10-minute certificates: `anona-compute ssh`, `scp`, `--print-config` for editors.

**Tools**

* `anona-compute` CLI: browser sign-in, lifecycle, `exec`, `run`, `connect`, `ssh`, `scp`, `view`, `desktop`, profiles.
* `anona-compute mcp`: an MCP server for Claude Code, Codex, Cursor and other clients, over stdio or loopback HTTP.
* SDK extras `anona` (Python) and `@anona-labs/compute-sdk` (TypeScript): `sandbox.live` and `sandbox.ssh`.
* Dashboard: organizations and roles, scoped API keys with expiry and sandbox lists, sandboxes with live view, usage and billing.

## Coming soon

| Area | What |
| - | - |
| Sandboxes | Named snapshots, sandbox logs and metrics, resume on incoming traffic |
| Access | SSH host certificates |
| Account | Self-set spend caps, team invitations |
| Platform | More regions |


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