Skip to main content
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.
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.
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 and TypeScript.
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.
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 so it stops using them. See Lifecycle.
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.
  • 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.
Plan limits

Every plan limit is enforced, and says which

Each plan’s limits are now enforced as published on Regions and limits: 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.
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.
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.
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 (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.
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. 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, 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.
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.
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 move to /docs; dashboard password reset

Docs live at compute.anonalabs.com/docs

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

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.
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.
idle_pause_changelog.sh

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.
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.
vault_quickstart.sh
See Credentials without exposing them.
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.
  • 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.
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.
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.
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.
Preview links, idle pause
  • 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)).
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.
  • 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.
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.
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