# Runtime vs Daytona Runtime gives every agent sandbox its own microVM kernel. For an agent that mostly waits on a model, it costs **77% less than Daytona**. **The saving:** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost **$0.64 on Runtime and $2.76 on Daytona**. At 100,000 runs a month, that is $63.89 against $276.00, **$212 a month saved**. Your Daytona code keeps working. Change one import. Comparing more than two providers? [Daytona alternatives](/compare/daytona-alternatives) ranks the other providers by the cost of the same job. ## Where Runtime is better - **You pay for the CPU you use.** Daytona bills every vCPU for as long as the sandbox runs. Runtime measures the CPU your code actually uses. Time spent waiting on a model costs only a small floor, a twentieth of a vCPU. - **It pauses itself when idle.** After 300 seconds with no request, command, connection, traffic or CPU use, a Runtime sandbox pauses. While paused, it pays only paused storage, $0.08 per GB (10⁹ bytes) a month. The next request wakes it. Its processes keep running. - **An uptime promise that pays itself.** Paid accounts get 99% API uptime each month. A month below that returns 10% of that month's charges as credit. No claim is needed ([Uptime Promise](/legal/sla)). - **Lower rates on both meters.** $0.025 per vCPU-hour, against Daytona's $0.0504, and $0.0075 per GiB-hour of memory, against $0.0162. Even with every CPU busy the whole time, the example job costs $1.33 on Runtime and $2.76 on Daytona. - **A microVM every time.** Every Runtime sandbox is a Firecracker microVM with its own kernel, and every one can pause with its memory. Daytona's default sandbox is a container. Pausing with memory needs its VM class. - **Disk included while running.** Daytona charges for disk past 5 GiB whether the sandbox runs or not. Runtime's disk is part of a running sandbox. - **A one-line switch.** `withruntime/daytona` runs code written for Daytona's SDK, in JavaScript and Python: sessions, files, git, snapshots built from Daytona's `Image`, and the code interpreter. Credit you add within 30 days of signing up is matched, up to $1,000 in total. - **Teams at no extra charge.** Single sign-on over SAML or OIDC (Okta, Microsoft Entra ID, Google Workspace), SCIM, roles and an audit log come with every account ([single sign-on](./single-sign-on)). Daytona's single sign-on is OIDC, on its Enterprise plan. - **Custom domains built in.** A paid account serves a sandbox port at your own hostname, with HTTPS, from one command ([custom domains](./networking#custom-domains)). On Daytona, a preview under your own domain needs a preview proxy you deploy and run yourself. - **Your agent sets itself up.** It runs `npx withruntime sandboxes run -- ...`, shows you a link, and starts once you approve in the browser. No API key goes into a prompt or a config file. The [MCP server](./mcp) reuses the same connection. - **Guardrails for agents.** Give an agent a read-only key or a daily spending limit per key. Cap any sandbox's total cost with `maxTotalCostMicros`. Every write takes an idempotency key, and the SDKs retry with it. A lost response never creates a second sandbox. **Also included:** a code interpreter, network allow and deny lists, secrets the sandbox never sees, custom images, volumes backed up daily, snapshots and forks with memory, private previews, a Linux desktop, metrics, webhooks, OpenTelemetry export, S3, R2 and GCS bucket mounts, MCP servers from a catalog, and identity tokens for AWS and Google Cloud. Paid accounts add TCP ports, dedicated outbound addresses and WireGuard private networks. See [products](./products). ## At a glance Daytona's figures come from its public pricing and documentation, checked 25 October 2026. | | Runtime | Daytona | | ---------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | | Isolation | Firecracker microVM for every sandbox | Containers by default; VM sandboxes as a separate class | | CPU billing | $0.025 per vCPU-hour of measured CPU, with a small floor | $0.0504 per allocated vCPU-hour | | Memory billing | $0.0075 per reserved GiB-hour | $0.0162 per GiB-hour | | Disk | Included while running; paused storage $0.08 per GB (10⁹ bytes) a month | First 5 GiB free, then $0.000108 per GiB-hour, stopped or not | | Plan fee | None; prepaid credit from $10 | None published | | Free start | 100 free hours of a 1 GB machine in the first 30 days, no card | $200 of compute | | Pause and resume | Files and memory, every sandbox | Files and memory on VM sandboxes | | Snapshots, forks | Copies of a running sandbox, with memory and processes | Memory snapshots on VM sandboxes | | Agent sign-in | Browser approval; no key in the agent's config | API key | | Port URLs | Private with a token by default | Private to your organization unless the sandbox is public | ## Cost for the same job Take 1,000 runs of a 2 vCPU, 4 GiB sandbox. Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds. This is an agent that spends most of its time waiting for a model. ``` Runtime CPU 1,000 × 20 s / 3,600 × $0.025 = $0.14 Memory 1,000 × 60 s / 3,600 × 4 × $0.0075 = $0.50 Total $0.64 Daytona CPU 1,000 × 60 s / 3,600 × 2 × $0.0504 = $1.68 Memory 1,000 × 60 s / 3,600 × 4 × $0.0162 = $1.08 Total $2.76 ``` - **Saving:** 77%, or $2.12 per 1,000 runs. - **Per month:** at 100,000 runs, $63.89 on Runtime against $276.00 on Daytona. - **Busier work:** with both CPUs busy for the whole minute, $1.33 on Runtime against $2.76 on Daytona. At this size, Runtime is cheaper however busy the sandbox is. Disk, network, taxes and free credits are excluded from both. `runtime compare --from daytona` prices your own usage the same way. It prices sandboxes the free usage paid for at the standard rates, so free usage never counts as a saving. On Runtime, inbound traffic is free. Each account's first 100 GiB out a month is free, then $0.02 per GB (10⁹ bytes). See [pricing](./pricing) for Runtime's terms. ## How to switch Give your coding agent the one instruction in [migration](./migrate). It replaces the Daytona calls on a branch, tests them on the free usage, and tells you what you save each month. Your old code stays on the main branch until you merge. ### Change one import Runtime's SDK runs code written for Daytona's SDK. Change the import and set `RUNTIME_API_KEY`, or run `npx withruntime login` once: ```ts no-run import { Daytona } from "withruntime/daytona"; // was: from "@daytona/sdk" ``` ```python no-run from withruntime.daytona import Daytona # was: from daytona import Daytona ``` Sandboxes get Daytona's defaults: 1 vCPU, 1 GiB of memory and a 3 GiB disk, pausing after 15 minutes without calls. `stop()` pauses a sandbox with its files and its memory, and `start()` carries on. Sandboxes use the free usage first, then prepaid credit. PTY sessions, computer use, a `user` from your image, an `autoStopInterval` over an hour (or `0`), and list filters and sorting work as on Daytona. A call Runtime handles differently, such as GPUs or other regions, throws `NotSupportedError` before anything happens. It names what to use instead. `DAYTONA.md` in the package lists every mapping. ### Or port the calls The calls map one to one. Daytona: ```js import { Daytona } from "@daytonaio/sdk"; const daytona = new Daytona(); const sandbox = await daytona.create(); const response = await sandbox.process.executeCommand("python3 -c 'print(sum([125, 250, 375]))'"); await sandbox.delete(); ``` Runtime: ```ts import { Sandbox } from "withruntime"; const box = await Sandbox.create(); try { await box.files.write("/workspace/invoice.py", "print(sum([125, 250, 375]))\n"); console.log((await box.exec("python3 /workspace/invoice.py", { check: true })).stdout); } finally { await box.stop(); } ``` ## When Daytona may fit better - **GPUs and Windows.** Daytona offers GPU sandboxes and Windows machines. Runtime runs Linux on CPUs. - **Regions.** Daytona runs in the US and the EU. Runtime runs in one US region. ## Sources Checked 23 September 2026; single sign-on and custom domains checked 27 September 2026; port URLs checked 3 November 2026. - [Daytona pricing](https://www.daytona.io/pricing) - [Daytona organization SSO](https://www.daytona.io/docs/en/sso) - [Daytona custom preview proxy](https://www.daytona.io/docs/en/custom-preview-proxy) - [Daytona sandboxes](https://www.daytona.io/docs/en/sandboxes) - [Daytona on microVMs, pause and fork](https://www.daytona.io/dotfiles/vms-pause-and-fork) - [Daytona preview links](https://www.daytona.io/docs/en/preview) - Runtime [pricing](./pricing), [security](./security) and [products](./products)