Modal

Executes arbitrary Python functions on cloud infrastructure with automatic hardware selection and provisioning. Users define functions with @app.function() decorators specifying GPU type, memory, and CPU requirements; Modal's scheduler intelligently allocates resources from a multi-cloud capacity pool (AWS/GCP) and launches containers in seconds with sub-second cold starts. The platform handles container lifecycle, dependency management, and teardown automatically without requiring infrastructure configuration.

Charges only for actual compute time used (per-second granularity) with no idle fees or minimum commitments. Containers automatically scale down to zero when not processing requests, and scale back up instantly when new work arrives. Pricing varies by GPU type (T4 at $0.000164/sec to H200 at $0.001261/sec) and CPU/memory are billed separately at $0.0000131/core/sec and $0.00000222/GiB/sec respectively. Starter plan includes $30/month free credits; Team plan includes $100/month credits.

Provides built-in logging, metrics collection, and execution tracing for all functions without external instrumentation. Function logs are automatically captured and queryable via web dashboard; metrics (execution time, memory usage, GPU utilization) are collected per-invocation. Log retention varies by plan (1 day on Starter, 30 days on Team, custom on Enterprise). Real-time metrics and logs available on Starter+ plans; audit logs (Enterprise only) track secret access and deployment changes.

Exposes 10 Nvidia GPU types with transparent per-second pricing, enabling cost-aware hardware selection for different workload characteristics. Users specify GPU type in function decorators (e.g., @app.function(gpu='A100')); Modal's scheduler allocates from available capacity. Pricing ranges from T4 ($0.000164/sec) for inference to H200 ($0.001261/sec) for training. Platform provides cost estimation and usage dashboards to track per-GPU spending.

Maintains multiple versions of deployed functions with ability to instantly rollback to previous versions without redeployment. Each function deployment creates a new version; Team plan retains 3 versions, Enterprise retains custom count. Rollback is instantaneous and requires no code changes or recompilation. Deployment history is queryable via CLI and web dashboard with timestamps and change metadata.

Provides ephemeral, isolated execution environments for running untrusted code with resource limits and automatic cleanup. Sandboxes are separate from production functions, with independent billing ($0.00003942/core/sec CPU, $0.00000672/GiB/sec memory) and no access to secrets or persistent volumes by default. Useful for running user-submitted code, LLM-generated code, or third-party plugins without risk to main application.

Mounts cloud storage buckets (AWS S3, GCP Cloud Storage) and persistent volumes directly into function containers, enabling efficient model loading and data sharing across invocations. Volumes are attached at container startup and persist across function executions within the same deployment, reducing repeated download overhead. Users specify volume paths in function decorators; Modal handles mounting, lifecycle, and cleanup automatically.

Converts Python functions into production-grade HTTP APIs with automatic request routing, load balancing, and horizontal scaling. Functions decorated with @app.web_endpoint() are exposed as REST endpoints with automatic HTTPS, request/response serialization, and concurrent request handling. Modal automatically scales the number of container replicas based on incoming request volume, with intelligent request distribution across available containers.

Executes Python functions on a schedule using cron expressions, enabling periodic batch jobs, data pipelines, and maintenance tasks. Functions decorated with @app.function(schedule=modal.Cron(...)) are automatically invoked at specified intervals (e.g., daily, hourly, custom cron patterns). Modal handles scheduling, execution, logging, and retry logic; failed jobs can be configured with exponential backoff or custom retry policies.

Provides a distributed queue primitive (@app.queue()) for asynchronous task processing with automatic worker scaling. Tasks are enqueued from web endpoints or other functions and processed by worker functions that scale horizontally based on queue depth. Modal manages queue persistence, task ordering, and worker lifecycle; supports both FIFO and priority queue semantics with configurable concurrency per worker.

Provides a distributed key-value store (@app.dict()) for sharing state between concurrent function invocations without external databases. Distributed dicts are accessible across all function instances within an app, supporting atomic operations, TTL-based expiration, and concurrent access patterns. Data is persisted within the Modal execution environment and survives individual function invocations but not app redeployments.

Enables distributed training across multiple GPUs with automatic process group initialization, gradient synchronization, and collective communication. Functions can spawn multiple GPU workers using @app.function(gpu='A100', n_gpu=4) syntax; Modal handles NCCL setup, rank assignment, and inter-GPU communication transparently. Supports PyTorch DistributedDataParallel and similar frameworks without manual process group configuration.

Provides secure storage and injection of sensitive credentials (API keys, database passwords, tokens) into function execution environments. Secrets are encrypted at rest and decrypted only within function containers; accessed via environment variables or Modal SDK methods. Secrets are scoped to Modal apps and can be managed via CLI or web dashboard; Enterprise plans support Okta SSO for centralized secret management.

Provides cloud-hosted Jupyter-like notebooks that execute on Modal infrastructure with access to GPUs, persistent volumes, and distributed primitives. Notebooks run in ephemeral containers with separate billing tier ($0.00003942/core/sec CPU, $0.00000672/GiB/sec memory, standard GPU pricing). Code cells execute with full access to Modal functions, queues, dicts, and mounted volumes; notebooks can be shared via URL with read-only or execution permissions.