Modal

Modal is a serverless cloud platform with a dedicated Sandbox API for executing untrusted user or agent code. It's Python-native — you define a container in code, it autoscales from zero, and you get GPUs when you want them. The Sandboxes API exposes that same machinery as "define a container at runtime and exec arbitrary commands inside it", making Modal a strong fit for agent workloads that also need inference, batch, or GPU compute.

Key Features

• Sandbox API: Define a container at runtime and execute arbitrary commands inside it — purpose-built for agent tool calls and code execution.
• gVisor Isolation: Google's user-space kernel intercepts syscalls — stronger than vanilla containers, thinner than full microVMs.
• Massive Scale: Up to 100K+ concurrent sandboxes; 1B+ sandboxes run; Lovable ran 1M sandboxes in 48 hours.
• GPU Access: T4 through B200 at per-second rates — the only GPU-accelerated provider in the OpenAI Agents SDK.
• Scale to Zero: Compute charges drop to zero when idle; per-second billing for active compute.
• Persistence Primitives: Distributed volumes, filesystem/memory snapshots, queues, and distributed dicts for stateful agents.
• Compute as Code: Python decorators define functions, jobs, and sandboxes — infrastructure lives in your repo.
• Broad Integrations: LangGraph, OpenAI Agents SDK, and Python/TypeScript/Go SDKs.

Use Cases

Who Should Use This Tool?

• AI Platform Teams: Teams already on Modal for inference or batch who want sandboxed agent execution on the same platform.
• GPU-Heavy Agent Builders: Agents that need local model inference, RL training, or image generation inside the sandbox.
• High-Concurrency Products: Vibe coding platforms and agent products that must run millions of sandboxes.

Problems It Solves

1. Vendor sprawl: One platform for inference, batch, GPU, and agent sandboxes instead of several vendors.
2. Idle cost: Scale-to-zero billing means you don't pay while agents wait.
3. GPU scarcity: Broad GPU access (T4-B200) without cloud quota friction.

Pricing

Billing is per-second and unbundled: CPU per core-second, memory per GiB-second, GPU on top.

Advantages & Unique Selling Points

Compared to Competitors:

1. One compute story: Sandboxes alongside inference, batch, and GPU — no second vendor relationship.
2. GPU-native: T4 through B200 per-second; the only GPU-accelerated sandbox in the OpenAI Agents SDK.
3. Active-compute billing: Scale to zero means bursty interactive agents pay a fraction of wall-clock competitors.

What Makes It Stand Out:

• $355M Series C at $4.65B valuation (May 2026), ~$300M annualized revenue.
• "Compute as code" — infrastructure defined in Python in your repo.
• 1B+ sandboxes run in production.

Getting Started

Quick Start Guide

1. Install: pip install modal and set up an account.
2. Define an app: Use modal.App() and modal.Image in Python.
3. Run a sandbox: with modal.Sandbox.create(image=img) as sbx: sbx.exec("echo hello").
4. Attach GPUs: gpu="A100" in the image or sandbox spec.

Integration

Integrates with:

• OpenAI Agents SDK, LangGraph, and other agent frameworks
• Python, TypeScript, Go SDKs
• Existing Modal inference and batch workloads

Frequently Asked Questions

Is Modal open source?

The platform is managed SaaS only — no self-hosted or BYOC option.

How strong is the isolation?

gVisor intercepts syscalls in user space, which is a real boundary but a software one — thinner than a full microVM.

Can I use GPUs in a sandbox?

Yes — T4 through B200 at per-second rates, ideal for model inference or RL training inside agent sandboxes.

Alternatives

If Modal isn't the right fit, consider these alternatives:

• E2B: Firecracker microVM isolation purpose-built for agent code execution.
• Daytona: Persistent full dev environments with computer use.
• Cloudflare Computer: Edge-native isolates with Durable Object persistence.

Tips & Best Practices

1. Model your billing: Per-second unbundled pricing means you should estimate your own usage, not trust sticker prices.
2. Use snapshots for stateful agents: Filesystem/memory snapshots give ~10x faster restarts.
3. Scale to zero is automatic: Idle sandboxes stop billing — keep them warm only when latency matters.

Conclusion

Modal is the serverless platform where sandboxes ride alongside real compute — GPU access, scale to zero, and per-second billing in one Python-native system. If your agents need GPUs or you're already on Modal for inference, the Sandbox API is a natural extension with proven scale.