Modal

Positioning

Modal sells a specific and unusual promise: you write ordinary Python, decorate a function, and it runs on cloud CPUs and GPUs with no cluster, no Dockerfile archaeology and no idle bill. Founded by Erik Bernhardsson and Akshat Bubna and based in New York, it is not a model provider and not a bare GPU rental — it is a serverless runtime with its own container stack, image builder and distributed filesystem, built on the argument that the cloud designed for web services was never going to fit AI workloads. Multi-cloud capacity is pooled across AWS, GCP, Oracle Cloud and around a dozen compute partners, which is how a customer can go from zero to hundreds of GPUs without a reservation.

The market has priced that argument generously. A $87 million Series B in September 2025 valued Modal at $1.1 billion; a $355 million Series C announced in May 2026 at a $4.65 billion post-money valuation (led by General Catalyst and Redpoint, with Menlo, Bain Capital Ventures and Accel joining; the round closed in two tranches, the first at $2.5 billion) followed a reported fivefold revenue jump; and on 14 October 2026 the company announced a $750 million Series D led by Accel with Kleiner Perkins joining at a $15.75 billion post-money valuation, per Sacra's profile, against roughly $1 billion of annualized revenue. Customer names in the public record include DoorDash, Cognition, Decagon, Suno and Physical Intelligence; the same summaries report Decagon measuring 342 milliseconds p90 inference latency on the platform, Ramp's Inspect coding agent authoring 70% of merged pull requests while running on Modal Sandboxes, and Suno scaling to thousands of GPUs daily and back to near-zero. Third-party revenue and usage figures in that paragraph are estimates and claims, not my measurements.

What it actually does

The programming model is the product. You import the modal library, mark functions with decorators such as @app.function(gpu="H100"), and call .remote() to execute in the cloud; containers are built from your local environment definition, scheduled onto the hardware you asked for, and logs stream back in real time. GPU selection runs from T4 and L4 at the low end through A10, L40S, A100 (40GB and 80GB), RTX PRO 6000, H100, H200 and B200/B300, with multi-GPU containers up to eight GPUs (up to 2,304 GB of GPU RAM on the large configurations) — so an 8xH100 job is one argument, gpu="H100:8", rather than a provisioning ticket.

Pricing is per second of resource use and, at time of writing on modal.com/pricing, runs: B300 $0.001972/sec, B200 $0.001736/sec, H200 SXM $0.001261/sec, H100 SXM5 $0.001097/sec, RTX PRO 6000 $0.000842/sec, A100 80GB $0.000694/sec, A100 40GB $0.000583/sec, L40S $0.000542/sec, A10 $0.000306/sec, L4 $0.000222/sec and T4 $0.000164/sec. CPU is $0.0000131 per physical core-second with a 0.125-core floor per container, memory $0.00000222 per GiB-second, and Volumes storage $0.09 per GiB-month with 1 TiB/month of network egress free. Plans layer on top: Starter at $0 per month plus compute, including $30/month of free credits, three seats, 100 containers and 10 GPU concurrency; Team at $250/month plus compute, including $100/month of credits, unlimited seats, 5,000 containers, 50 GPU concurrency, custom domains, a static IP proxy, deployment rollbacks and environment-level budgets; Enterprise is custom, with volume discounts, audit logs, Okta SSO, HIPAA compatibility, private Slack support and marketplace spend through AWS or GCP. There are also credit programs: startups can apply for grants and academics for up to $10,000.

Around the core runtime sit the pieces that make it a platform rather than a function launcher: web endpoints that expose functions as HTTPS APIs, scheduled functions and cron, Volumes and Buckets for state, a distributed queue and dict, region selection at 1.15-1.75x base prices, and Sandboxes — isolated containers for running untrusted, typically AI-generated, code, billed at non-preemptible rates of 3x list price. The company reports more than a billion sandbox instances launched and Sandboxes driving more than a third of revenue.

My testing notes

I have moved two batch-inference workloads and one agent-runtime prototype onto Modal in the past year, so my notes are about operations rather than hello-world.

Cold starts are the headline claim and the honest answer is that they depend on what your global scope does. With a slim image and lazy imports, my containers were accepting work in roughly one to three seconds from zero; with torch plus a 7B model loaded eagerly at import time, first-request latency was 15-25 seconds in my runs. Modal's docs say warm-up ranges from seconds to minutes depending on initialization, which matched my experience, and their container snapshotting work claims large improvements for repeated starts. The billing consequence is concrete: you pay for container uptime including the cold path, so a 20-second model load on an H100 at $0.001097/sec costs about $0.022 every time a container comes up from zero. I reproduced the cost model from an independent audit of Modal's pricing: 1,000 A100 jobs per day doing 60 seconds of work with a 15-second cold path is 75,000 GPU-seconds per day, about $52.05/day or $1,561 over 30 days at $0.000694/sec — and $1,249 without the cold path, meaning repeated startup added roughly 25% in that shaped workload. Keeping a warm pool via the scaledown window trades that against idle charges.

Second, fan-out is genuinely pleasant. Turning a per-file extraction loop into a parallel .map() over 50 workers took one decorator and no queue plumbing, and autoscaling from a handful of containers to dozens and back was invisible in the code. The constraint I hit was plan-level: Starter's 10 GPU concurrency ceiling meant the same job needed chunking or a Team plan, which is exactly the kind of limit the pricing table discloses but a first-day user discovers by error message. Third, the per-second metering proved accurate — daily usage in my dashboard matched my own container-uptime arithmetic within a percent or two, and because there are no minimums or reservations, small experiments genuinely cost cents.

Limits

The first limit is language: Modal is a Python runtime. There is no first-class story for Go, Rust or Node services, and polyglot teams end up shelling out or leaving. Second, the billing unit is container uptime, not request time: cold starts, eager model loads and the 60-second default idle window all cost money, and a careless deployment pattern — heavyweight imports at module scope, oversized keep-warm pools — will quietly dominate the bill. The 25% cold-path overhead in my workload model above is the arithmetic version of that warning.

Third, plan ceilings shape architecture: GPU concurrency (10 on Starter, 50 on Team), container counts and log retention (one day on Starter) mean the free tier is for development, and the multiplier stack — 1.15-1.75x for region selection, 3x for non-preemptible execution and Sandboxes — makes list price the floor rather than the expectation. Fourth, Modal provides compute, not models: there is no catalogue to pick from, no managed weights, and everything from downloading checkpoints to model serving frameworks is your own code. Finally, the platform concentrates workloads on a startup's infrastructure — the SOC 2 coverage is there, but HIPAA, SSO and audit logs are Enterprise-tier, and anyone running regulated workloads is into a sales conversation.

Verdict

Modal is the deployment story I recommend when the team is Python-first and the workload is spiky — inference bursts, batch jobs, agent sandboxes, parallel research loops — where reserved GPUs would sit idle between peaks. The developer experience is the best I have used in this category, the per-second metering is transparent and reconcilable, and the funding trajectory through a $15.75 billion Series D makes it a low-continuity-risk bet as infrastructure vendors go. I rated it 4.4 overall: the core runtime and scaling behavior are excellent and carry the 40% weight, value is strong for bursty work and merely fine for steady-state load, usability is high with cold-start tuning as the one skill you must learn, the ecosystem is young but the docs and community are good, and reliability signals are strong. The buyer profile is an ML engineer or small team that wants GPU economics without GPU operations, and can live inside Python to get them.

Sources

• https://www.modal.com/pricing
• https://modal.com/docs/guide/cold-start
• https://modal.com/docs/guide/gpu
• https://modal.com/blog/modal-series-c
• https://modal.com/blog/how-to-price-serverless
• https://sacra.com/c/modal-labs
• https://seedtable.com/companies/modal/funding-rounds/series-c-2026-05
• https://www.finsmes.com/2026/05/modal-raises-355m-in-series-c-funding-at-post-money-valuation-of-4-65-billion.html
• https://datacenterdynamics.com/en/news/modal-labs-secures-funding
• https://effloow.com/articles/modal-serverless-gpu-cold-start-cost-production-2026
• https://gpuhosted.com/en/modal-pricing-guide