by Modal Labs
AI infrastructure that developers love: serverless compute for ML inference, training, and batch processing
Modal suits ML engineers and startups who want GPU compute without touching Kubernetes: write a normal Python function, add one decorator, and Modal handles the container, scaling, and orchestration, with cold starts landing in under 1 second. It replaces hand-rolled Docker and Terraform pipelines for teams that would rather ship models than maintain infrastructure themselves.
Sub-second cold starts combined with Python-first infrastructure—developers can write serverless functions like normal code and scale to hundreds of GPUs without DevOps overhead
Modal has built proprietary infrastructure (custom container runtime using gVisor, VolumeFS, memory snapshots, multi-cloud orchestration) that is difficult to replicate. The developer experience moat (Python decorators, local-like iteration) is strong but replicable. Network effects are emerging as enterprises standardize on the platform. However, the Python-only positioning and lack of BYOC limit total addressable market compared to generalist platforms like AWS Lambda.
Main trade-off
Python-only ecosystem and vendor lock-in with managed-only deployment model; limited for polyglot teams or those requiring on-premise/BYOC options
| Plan | Monthly price | What it includes |
|---|---|---|
| Starter | Free | Per-second CPU/GPU/Memory usage with $30/month free credits; 100 containers max, 10 GPU concurrency |
| Enterprise | Free | Custom pricing with volume-based discounts, usage-based compute on top of platform fee, unlimited seats, higher GPU concurrency, dedicated support |
| Team | $250/mo | Per-second CPU/GPU/Memory usage with $100/month in credits on top of $250/month subscription; 1000 containers, 50 GPU concurrency, unlimited seats |
Free Starter tier with $30/month in compute credits. Team plan at $250/month (includes $100/month in credits, unlimited seats, 1000 containers, 50 GPU concurrency). Enterprise plan with custom pricing for volume-based discounts and higher concurrency. On top of subscription fees, usage is pay-as-you-go: CPU at $0.0000131/core/sec (min 0.125 cores), Memory at $0.00000222/GiB/sec, GPUs ranging from $0.000164/sec (T4) to $0.001097/sec (H100). Multipliers apply for regional selection and non-preemptible sandboxes.
Modal runs containers up to 100x faster than Docker, giving AI teams serverless compute for inference, training, and batch jobs without managing servers. It automatically scales from zero to hundreds of GPUs across multiple clouds, targeting ML teams that need infrastructure to expand and shrink with demand rather than staying provisioned around the clock.
Sub-second Cold Starts
Spin up GPU-enabled containers in as little as one second with custom infrastructure optimized for rapid iteration and scaling, eliminating cold start latency that plagues traditional serverless platforms.
Elastic GPU Scaling
Autoscale from zero to hundreds of GPUs on-demand based on workload, with deep multi-cloud capacity and intelligent scheduling that ensures access to CPUs and GPUs without managing quotas or reservations.
Python-First Infrastructure
Define entire environments, hardware requirements, and deployment logic in pure Python using simple decorators (@app.function, @app.cls) without YAML files or complex configuration, keeping environment and hardware requirements in sync.
Unified Observability
Integrated logging and full visibility into every function, container, and workload with built-in dashboards, real-time logs, and first-party integrations with Datadog and OpenTelemetry for monitoring and debugging.
Multi-workload Support
Deploy inference for LLMs and generative models, fine-tune open-source models, run large-scale batch jobs, execute untrusted code in sandboxes, and collaborate in real-time with shareable notebooks, all from a unified platform.
Memory Snapshots
Dramatically reduce cold start latency (up to 10x) by capturing container state after initialization and restoring it for subsequent starts, enabling GPU snapshots for even faster LLM deployments.
Most users expect these and they are not currently supported.
| Tool | Price from | Free plan | Runs on | Rating |
|---|---|---|---|---|
| $250/mo | Yes | Web | -- | |
| Free | Yes | Web | -- | |
| -- | Trial | Web | -- | |
| -- | Yes | Web | 4.4 |
| Plan | Architecture |
|---|---|
| Starter | Serverless container orchestration |
| Team | Serverless container orchestration with advanced features |
| Enterprise | Serverless container orchestration with enterprise controls |
MIT (modal-client), Apache-2.0 (libmodal)
Modal has three tiers: Starter is free, Team costs $250 a month, and Enterprise is custom-priced with volume discounts. Beyond the included credits, usage is billed per second for CPU, memory, and GPU time, with extra multipliers applied for regional selection or non-preemptible sandboxes.
Modal's free Starter tier includes $30 a month in compute credits, capped at 10 concurrent GPU workers. It does not include the Team plan's unlimited seats or 50-GPU concurrency, and any usage beyond the included credits bills at the same per-second rates as the paid tiers.
Replicate is the simpler choice for calling a pre-packaged open-source model through an API rather than writing custom deployment code. Together AI offers a managed catalog of open-source models to fine-tune without building a container pipeline from scratch. Fireworks AI is worth a look when the need is pay-per-token LLM inference rather than general-purpose Python compute.
Modal is purpose-built for ML workloads, offering direct GPU access and support for long-running jobs that Lambda cannot handle. AWS Lambda caps out at a 15-minute timeout and a 50MB deployment package, making it a fit for short, event-driven glue code rather than model inference or training. Choose Modal for AI workloads and Lambda for lightweight application backends.
A first deployment usually takes minutes: install the Python client and wrap any existing Python function with the @app.function decorator instead of writing a Dockerfile or YAML config, and Modal handles containerization and scaling automatically. New accounts default to the free Starter tier, so early deployments cost nothing until the included credits run out. The official Getting Started guide at modal.com/docs/guide walks through that first deployment step by step.
Modal Labs, founded in 2021, raised a $111M Series B in July 2025. The company built a serverless compute platform purpose-built for AI, ML, and data teams: developers run compute-intensive workloads without managing infrastructure, with sub-second container cold starts, instant autoscaling, and a developer experience that feels local. Define everything in code using Python decorators (no YAML, no Dockerfiles) and Modal handles containerization, resource allocation, scaling, and orchestration automatically.
The platform is engineered from the ground up for heavy AI workloads, with multi-cloud GPU capacity, globally distributed storage, and integrated observability. Whether deploying LLM inference at scale, fine-tuning models on multi-node clusters, running massive batch jobs, or executing untrusted code in sandboxes, Modal abstracts away operational complexity so teams can focus on model development rather than infrastructure management.
Product facts on this page (pricing, plans, integrations, compliance) are read from Modal Labs's own pages and documentation. The verdict is Hokai's reading of them, not the vendor's claim.