Skip to main content
A sandbox’s size decides how much CPU, memory and disk it gets. The template decides what is inside it. You pick both when you create a sandbox: any template, at any size that template can run on.

The four sizes

Each plan includes the sizes up to its largest: Free and Starter up to Medium (Free runs at most two Medium sandboxes at once), Pro up to Large, Scale up to XL. See limits; prices are on the pricing page.

Choosing a size

  • The API’s create body takes size: small, medium, large or xl. The stock E2B SDK cannot send that field, so it can set the size as metadata instead: metadata={"anona.size": "large"}. That key is read as the size and is not stored with the sandbox’s metadata. The Anona SDKs above do this for you.
  • A sandbox’s info (GET /sandboxes/{id}, anona-compute info) reports the size it was created at, with its cpuCount, memoryMB and diskSizeMB.
  • Without a size, a sandbox runs at its template’s own size, exactly as before sizes existed. The console’s New sandbox dialog preselects the template’s default size from the table below.
  • The first sandbox at a new size takes longer. The first time anyone creates a template at a size it was not built at, that size is prepared, which takes about half a minute. A create that waits too long for it gets 503 sandbox_size_preparing with Retry-After, and the CLI and the console retry it for you. Every sandbox after that starts as fast as any other.

Disk is your working space

The disk figure is space for your work: files you create, packages you install, build output, /home/user and /tmp. The template’s own files do not use any of it. A sandbox’s root filesystem is two layers. The template image is a read-only layer underneath, shared by every sandbox started from that template. Your disk is a writable layer on top of it. So a 2 GB template on Medium still gives you the full 20 GB to write into, and df -h / inside the sandbox shows the disk size with almost nothing used, even though every tool in the template is there.
  • Changing a file that came with the template copies it into your layer, so that change does count.
  • When the disk is full, writes fail with No space left on device. The template’s files are never affected.
  • A small part of the disk goes to filesystem overhead, a few percent.

Which templates run on which size

Each template has a minimum size, and a sandbox can use that size or any larger one. For a template you build, the minimum is the smallest size that meets its vCPU, memory and disk (see Your own templates). For a built-in template, the minimum is set per template, as in the table below. It does not come from the template’s own size, which is what a sandbox gets without a size: base runs at 2 vCPU when no size is given, yet it can be created at Small, with 1 vCPU. anona-compute template info <template> prints the same: the template’s own vCPU, memory and disk, its minimum size and the sizes you can create it at. Why the desktops start at Medium: Small has one vCPU, and the live view (which encodes the screen) and the browser have to share it, so the desktop stutters. Memory is not the limit: desktop with Chrome and three tabs open uses about 750 MiB. agent-desktop adds the coding-agent toolchain on top, so it defaults to Large for agents that build and test while they drive the browser; Medium works for light use. Use Medium or larger for python, node and code-interpreter when the work is heavier than scripts and small builds: data analysis on real datasets, large monorepos, or test suites that run in parallel.

Your own templates

When you build a template, its --cpu, --memory and --disk are its minimum requirements. Sandboxes from it can run at any size that meets all three, or, without a size, at exactly what it was built with.
template_minimums.sh
That template runs at Medium, Large and XL, and the console preselects Medium, the smallest size that meets all three minimums. A template built without those flags gets 2 vCPU, 2 GiB and 1 GiB of disk, so its minimum is Medium (for the 2 vCPU). Set --disk to the writable space the template needs to run, such as caches, downloaded models or build output. The image itself is separate: it is limited to 10 GiB and counts toward your plan’s template storage (see Templates). The rules:
  • Eligible sizes are the sizes that meet every minimum and that your plan includes.
  • A size below the template’s minimum is refused with 400 sandbox_size_not_available, naming the size the template needs. A size above your plan’s largest (Free and Starter: Medium; Pro: Large; Scale: XL) is refused with 403 plan_limit_exceeded, and so is a sandbox created without a size from a template registered above it. A sandbox is never quietly given less than its template needs. See limits.
  • A template whose minimums exceed XL (more than 8 vCPU, 16 GiB of memory or 80 GB of disk) is refused when it is built, not when a sandbox is created.
  • Templates you have already built keep working: their current vCPU, memory and disk become their minimums.

How a size is chosen