Modal
Serverless Python compute with per-second GPU billing, sub-second cold starts and gVisor Sandboxes for agent code. H100 at $0.001097/s, scale to zero when idle.
Overview
Serverless compute aimed squarely at Python people who do not want to operate infrastructure. You decorate a function, declare its container image and GPU in the same file, and the platform builds, ships and bills it per second of execution with scale to zero in between. Cold starts are the engineering centre of gravity here: a custom filesystem and container stack put pre-cached burst starts around 0.88 seconds, and Memory Snapshots checkpoint a process after its imports so a heavy model load runs once rather than on every container.
The GPU menu runs from T4 at $0.000164/s up to B300 at $0.001972/s, with H100 SXM5 in the middle at $0.001097/s, roughly $3.95 an hour. Around that sit the pieces a real application needs: volumes, a network file system, queues, cron, web endpoints and Sandboxes, which are gVisor-isolated containers for agent-generated code with filesystem, directory and alpha memory snapshots. The platform advertises 50,000-plus concurrent sandbox sessions, which is the number that matters if you are fanning out one environment per agent turn.
A $355M Series C closed in May 2026, led by General Catalyst and Redpoint with Menlo, Bain Capital Ventures and Accel joining, at a $4.65B post-money valuation on roughly $300M of annualised revenue, up from about $60M the previous September. Stated priorities for the money are low-latency inference primitives, reinforcement-learning loops and sandbox scale. None of it is open source, and that is the trade being offered: unusually good ergonomics in exchange for total dependence on one vendor's SDK.
Key Features
- ✓ Per-second billing across B300, B200, H200, H100, A100, L40S and T4 with scale to zero between requests
- ✓ Python decorators define the deployment: mark a local function, declare its image in code, and it runs remotely without a Dockerfile
- ✓ Modal Sandboxes give agents gVisor-isolated containers with filesystem and directory snapshots, and Sandbox memory snapshots in alpha
- ✓ Memory Snapshots checkpoint post-import CPU state so a slow model load happens once instead of on every cold start; GPU memory snapshots are alpha
- ✓ Burst cold starts measured near 0.88 seconds for pre-cached containers, with support claimed for 50,000-plus concurrent sandbox sessions
- ✓ Volumes, a network file system, queues, cron scheduling and web endpoints in the same SDK as the compute
Where it holds
- • Shortest path in this category from a local Python script to a GPU endpoint, with no Kubernetes and no Dockerfile to maintain
- • Per-second granularity plus scale to zero makes spiky inference genuinely cheaper than a reserved instance sitting idle
- • Sandboxes and Functions share one runtime, so an agent needing both a code sandbox and a GPU model call stays on one bill and one SDK
- • Revenue moved from roughly $60M to about $300M annualised inside a year, a reasonable proxy for the platform still being here in three years
Where it breaks
- • Fully proprietary. No self-hosted build, no open-source escape hatch, and the decorator-shaped SDK does not port to anything else.
- • Headline rates are a floor. Region pinning applies a 1.5x to 1.75x multiplier, and steady round-the-clock load costs well above a reserved H100 elsewhere.
- • Python only. A Node or Go service has to call it over HTTP like any other API.
- • Team tier carries a $250/month base before a single second of compute, an awkward step for a two-person team that just wants concurrency headroom
My Take
A decorator on a local Python function, one CLI command, and it is running on an H100 that bills at $0.001097 per second and vanishes when idle. That ergonomics gap over raw Kubernetes is the entire pitch and it holds up. Cost discipline is where it gets awkward: advertised rates assume no region pinning, switching that on multiplies by 1.5x to 1.75x, and a steady 24/7 training job is cheaper almost anywhere with reserved capacity. Sandboxes also arrived later than E2B's and use gVisor rather than microVMs, a thinner boundary if your threat model is genuinely hostile code.
Quick Info
- Pricing:
- freemium
- Openness:
- Proprietary
- Starting at:
- Starter is $0/month with $30 of free credits each month, 100 containers and 10 concurrent GPUs. Team is $250/month plus compute with $100 monthly credits, 5,000 containers and 50 concurrent GPUs. Enterprise is custom with volume discounts. Compute meters per second: B300 $0.001972, B200 $0.001736, H200 SXM $0.001261, H100 SXM5 $0.001097 (about $3.95/hour), A100 80GB $0.000694, A100 40GB $0.000583, L40S $0.000542, T4 $0.000164. CPU is $0.0000131 per physical core per second with a 0.125-core floor, memory $0.00000222/GiB/s, volumes $0.09/GiB-month after 1 TiB free. Pinning a workload to a region multiplies base rates by 1.5x to 1.75x.
- Added:
- Aug 2026
- Updated:
- Aug 2026
Use Cases
Judge it on your own work
The notes above say where Modal holds and where it breaks. The fastest check is your own workload.
Visit website ↗Alternatives to Modal
E2B
freemiumFirecracker microVM sandboxes for running AI-generated code. Python and JS SDKs, 24-hour sessions, pause and resume with full memory state, Apache 2.0 core you can self-host.
Databricks Mosaic AI
paidThe AI layer inside Databricks: Agent Bricks, model serving, vector search and MLflow, all resolving back to Unity Catalog governed data.
Huawei Cloud ModelArts
paidHuawei Cloud's full-lifecycle AI platform. Training and serving on Ascend NPUs through CANN, with Lite Server, Lite Cluster and a MaaS layer. Proprietary and quote-priced.