Sandscale vs Modal Sandboxes: a purpose-built sandbox or a feature of a bigger platform
Originally published on sandscale.dev. Modal is a serverless compute platform for AI workloads: functions, batch jobs, GPUs, model serving, and Sandboxes for running code you don't trust. Sandscale does one thing: isola
Originally published on sandscale.dev.
Modal is a serverless compute platform for AI workloads: functions, batch jobs, GPUs, model serving, and Sandboxes for running code you don't trust. Sandscale does one thing: isolated boxes for AI agents, with governance built in. So this is less a head-to-head than a question of which shape of product fits your workload. The two also bill differently, and the details are worth reading.
Modal facts are from Modal's public pricing page and docs, read on 20 November 2026. Sandscale facts are from sandscale.dev. "Not published" means we did not find it on the pages we read. Both products change, so check the linked pages before you decide.
Isolation: what Modal actually uses
Modal describes Sandboxes as "secure containers for executing untrusted code". Under that, there are two runtimes:
- gVisor, which Modal describes as "a container runtime developed by Google" providing "strong isolation" for most workloads. gVisor is an application kernel written in user space that intercepts the sandboxed program's system calls.
- VMs, which run the Sandbox "in a virtual machine with its own Linux kernel", recommended for workloads that expect a full Linux environment, such as Docker inside the sandbox, FUSE filesystems or nested cgroups.
You pick the runtime with a runtime parameter, or leave it unset and let Modal choose. GPU sandboxes are only supported on the gVisor runtime. Modal's security page says each container runs in its own sandbox "using primitives like gVisor or microVMs". The hypervisor behind Modal's VM runtime is not named on the pages we read: not published. Which runtime Modal uses when runtime is unset is not stated on the page we read.
Sandscale runs every sandbox as a Firecracker microVM with its own kernel.
gVisor and microVMs are different designs. gVisor reimplements a subset of the Linux interface in user space, which gVisor's own documentation says comes with some reduced application compatibility and higher per-system call overhead, in exchange for a smaller exposed surface and a light footprint. A microVM runs a real guest kernel behind hardware virtualization. For a longer comparison, see our post on isolating agent-run code. Modal's own docs reflect the trade: its VM runtime exists for "workloads that expect a full Linux environment".
Billing: request versus actual use
Modal bills sandboxes by the second, on CPU and memory, at the greater of what you request and what the sandbox actually uses (max(request, actual)). By default a sandbox requests only 0.125 CPU cores and 128 MiB and bursts above that as needed, so an idle sandbox at defaults is billed at that small minimum. If you set a larger request, you pay for it "for the lifetime of your Sandbox, regardless of whether the resources are being used." Published sandbox rates are $0.00003942 per physical core-second (a physical core is 2 vCPU) and $0.00000667 per GiB-second; Modal says these are non-preemptible rates, 3x its list price for preemptible functions. Sandboxes have a default maximum lifetime of 5 minutes and can be set to up to 24 hours.
Sandscale bills awake vCPU-hours: paused time and idle time between tool calls are not counted, and memory is included at 4 GiB per vCPU. Plans include monthly hours, and usage beyond them is $0.05 per awake vCPU-hour or $10 per 500-hour pack.
For how Sandscale metering works in detail, see pricing. The two models are closer than a typical "idle billing vs always-on" comparison. Modal does not charge a large reservation for an idle sandbox at defaults. The difference is the unit: Modal meters CPU and memory use against a request, Sandscale meters vCPU awake time for the size you picked.
A worked example (hypothetical workload)
This is an invented workload, not a measurement. An agent run lasts 60 minutes: 10 minutes of real work, then 50 minutes waiting for a model or a person. Disk and network egress are left out on both sides.
Modal. Using Modal's published sandbox rates, with a request set:
1 physical core (2 vCPU): $0.00003942 × 3600 = $0.1419 per hour
4 GiB memory: 4 × $0.00000667 × 3600 = $0.0960 per hour
Sum, requested and held: $0.2380 per hour
- (a) Request 2 vCPU and 4 GiB, sandbox lives 60 minutes: $0.2380 per run, because requested resources are billed for the sandbox's lifetime.
- (b) Same request, terminated after 10 minutes: 10/60 × $0.2380 = $0.0397 per run.
These two cases use only requests and published rates. Modal bills actual use when it exceeds the request, and we do not know how hard your sandbox works, so this post does not model the no-request case.
Sandscale, 2 vCPU box:
2 vCPU × (10 / 60) h = 0.333 awake vCPU-hours per run
At 1,000 runs a month, that is 333.3 awake vCPU-hours, inside Pro's 1,500 included.
| 1,000 runs a month | Usage cost | Plan basis | Notes |
|---|---|---|---|
| Modal (a): requested 2 vCPU / 4 GiB, held 60 min | $238.00 | Starter $0 + compute ($30 monthly credit); Team $250/mo + compute ($100 credit) | Plan details from Modal's pricing page |
| Modal (b): same request, terminated at 10 min | $39.66 | same | |
| Sandscale, awake only | within 1,500 included hours (333.3 used) | Pro: $20/mo billed annually, $25 monthly | 8 GiB included at 2 vCPU |
Read it carefully. Cases (a) and (b) set a request, which Modal bills for the sandbox's lifetime. If you set no request and your sandboxes use little CPU, Modal bills actual use above a small minimum (0.125 core and 128 MiB by default), and the result could be lower than either case; we have not modelled it because it depends on usage we do not have. Modal's own docs say sandbox usage is often bursty and that its burst model "tends to result in prices far lower than most sandbox providers", a claim we have not tested. On Sandscale the cost depends on awake time and size, not on how hard the CPU works during it. The plans also include different things: Modal Starter limits you to 100 containers and 3 seats, and Sandscale Pro to 30 boxes at once.
Limits and plans
Modal's plans are Starter ($0 plus compute, with $30 of monthly credits, 3 seats and 100 containers), Team ($250 a month plus compute, $100 of credits, unlimited seats and 5,000 containers) and Enterprise. Modal lists audit logs, Okta SSO and HIPAA under Enterprise, and SOC 2 as included on all plans; its security page says a SOC 2 Type II report is available through its Trust Center. Choosing a region carries a published price multiplier of 1.15 to 1.75 times base prices. Network egress is $0.04 per GiB, with 1 TiB a month free on Starter and 10 TiB on Team.
Sandscale's plans are Free (100 awake vCPU-hours), Pro ($20 a month billed annually, 1,500 hours) and Team ($40 per member billed annually, 2,000 hours per member, pooled), with limits listed on pricing. Sandscale does not claim a SOC 2 or ISO certification.
Networking and secrets
Modal sandboxes accept no incoming connections by default and can reach any public IP outbound by default. You can block all outbound traffic, allow only listed CIDR ranges, or (in beta) allow only listed domains on TLS port 443. Modal's docs note that DNS traffic is allowed unless all outbound traffic is blocked. Its index also lists beta features for sidecars and for injecting secrets into outbound requests.
Sandscale's network default follows plan: Free runs with an egress allowlist; Pro and Team can open it (see pricing). Sandscale keeps secrets in Vault, scans prompts and tool calls with DLP, and routes risky actions to human approval.
Where Modal is ahead or more mature
- GPUs. Modal lists a wide set of GPU types on its pricing page, and GPU sandboxes are supported (on the gVisor runtime). Sandscale has no GPU option on the pages we read.
- A larger platform around the sandbox. Functions, scheduled jobs, volumes, model APIs and GPU inference live in the same account. If sandboxes are one part of a bigger workload on Modal, a separate vendor adds work.
- Compliance. SOC 2 Type II available via Trust Center, and HIPAA on Enterprise.
- Scale numbers. 5,000 containers on Team, published.
- Resource model. Elastic CPU and memory with a published eviction target: Modal states a service objective of under 0.0001% per minute for sandboxes above their request and under 8 GiB. That is Modal's own stated target.
- Snapshots. Filesystem, directory and memory snapshots, with documented retention (30 days for filesystem and directory snapshots by default; 7 days for memory snapshots, currently flagged alpha).
- SDKs. Python, JavaScript and Go clients are documented. Sandscale's TypeScript SDK is available now; Python is coming soon.
Where Sandscale differs
- One isolation model for every sandbox: a Firecracker microVM with its own kernel.
- Built for agent governance: approvals, DLP on prompts and tool calls, Vault, and a hash-chained audit log on every plan, with policies on Team and above. Modal documents network allow lists, secrets and (beta) secret injection, and audit logs on Enterprise; approval workflows and prompt-level DLP are not published.
- Awake-hour pricing with included hours, and a flat plan fee starting at $20 a month.
- Workspaces and build hosts in the same plan, designed for coding agents and CI.
Limits on our side: US only today, no GPU, no certification claimed, and a narrower product than a general-purpose compute platform.
Fact table
| Sandscale | Modal Sandboxes | |
|---|---|---|
| Isolation | Firecracker microVM | gVisor, or VM runtime with own kernel; default when unset not stated |
| Billing basis | Awake vCPU-hours; idle and paused free | Per second on max(request, actual) CPU and memory |
| Idle sandbox cost | Not billed while idle between tool calls | Minimum 0.125 core / 128 MiB at defaults; requested resources billed for the sandbox's lifetime |
| Published rate | $0.05 per awake vCPU-hour beyond plan; $10 per 500 hours | $0.00003942 per core-s and $0.00000667 per GiB-s, sandbox (non-preemptible) rates |
| Memory | 4 GiB per vCPU included | Billed separately |
| Plans | Free $0; Pro $20/mo annual; Team $40/member annual | Starter $0 + compute ($30 credit); Team $250/mo + compute ($100 credit) |
| Concurrency | Free 3, Pro 30, Team 30 | Starter 100 containers; Team 5,000 |
| Max lifetime | Free 4 h, Pro 24 h, Team 24 h | Default 5 min; up to 24 h |
| Max size | Free 2 vCPU; Pro 16; Team 16 (32 on request) | Not found on the pages read |
| GPU | Not published | Yes; gVisor runtime only for sandboxes |
| Snapshots | Snapshots; pause with memory kept | Filesystem, directory, memory (alpha); 30/30/7-day default retention |
| Regions | US now; EU coming soon | Multi-region; region parameter on Sandbox.create; price multiplier 1.15-1.75x |
| Network default | Allowlist on Free; open on Pro and Team | Outbound to any public IP; no inbound |
| Governance | Vault, DLP, approvals, audit log on every plan | Allow lists, secrets, injection (beta); audit logs on Enterprise |
| Compliance | No certification claimed | SOC 2 Type II via Trust Center; HIPAA on Enterprise |
| Own cloud | AWS, Enterprise | Not published |
| Start time | Not compared | Not published for sandboxes on the pages read |
When to pick Modal
- You need GPUs in or next to your sandboxes.
- Sandboxes are one part of a larger Modal workload (inference, batch, scheduled jobs).
- Your sandboxes are bursty and light on CPU and you set no request, so Modal's max(request, actual) billing could cost less than a fixed size (we have not modelled this).
- You need a published SOC 2 Type II report or HIPAA today.
- You want a published concurrency in the thousands.
- gVisor's isolation model fits your threat model and you want a managed choice of runtimes.
When to pick Sandscale
- You want every sandbox to be a microVM and do not want to choose a runtime.
- You want approvals, DLP, Vault and an audit log as built-in platform features for coding agents.
- You want simple size-based billing where idle time between tool calls is free.
- You want persistent workspaces and build hosts alongside sandboxes.
If neither settles it, run your real agent on both free tiers and compare the invoices. See pricing, how pause and resume work and the security overview.
Sources
Competitor pages read on 20 November 2026:
- https://modal.com/pricing
- https://modal.com/docs/guide/sandboxes
- https://modal.com/docs/guide/sandbox-resources
- https://modal.com/docs/guide/resources
- https://modal.com/docs/guide/sandbox-networking
- https://modal.com/docs/guide/sandbox-snapshots
- https://modal.com/docs/guide/security
- https://modal.com/docs/guide/region-selection
- https://modal.com/llms.txt
Sandscale pages: pricing, FAQ, security, regions, pause and resume.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.