◆ AI Model & Data Infrastructure

Modal

1.5.5 (2026-08-28) commercial

Modal is a cloud platform for running, scaling, and deploying Python code and machine learning models serverlessly.

sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_domain_allowlist=["*"],
    outbound_cidr_allowlist=["0.0.0.0/0"],
    app=app,
)

# ... dependencies installed ...

sb._experimental_set_outbound_network_policy(
    outbound_domain_allowlist=["api.openai.com", "*.github.com"],
    outbound_cidr_allowlist=[],
)
sb = modal.Sandbox.create(
    "bash", "-c", "python3 -m http.server 8080",
    app=my_app,
)

creds = sb.create_connect_token(user_metadata={"user_id": "alice"}, port=8080)

import requests
resp = requests.get(creds.url, headers={"Authorization": f"Bearer {creds.token}"})
print(resp.text)
sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_cidr_allowlist=["52.0.0.0/8", "10.0.1.0/24"],
    app=app,
)
sb = modal.Sandbox.create(
    "python3", "-m", "http.server", "8080",
    readiness_probe=modal.Probe.with_tcp(8080),
    app=sb_app,
)
sb.wait_until_ready()
# server is now accepting connections
sb.terminate()
sb.detach()
sb = modal.Sandbox.create(
    "bash", "-c", "sleep 5 && touch /tmp/ready && sleep 3600",
    readiness_probe=modal.Probe.with_exec(
        "sh", "-c", "test -f /tmp/ready",
        interval_ms=250,
    ),
    app=sb_app,
)
sb.wait_until_ready()
p = sb.exec("cat", "/tmp/ready")
sb.terminate()
sb.detach()
sb = modal.Sandbox.create(
    app=sb_app,
    timeout=24*60*60,
    idle_timeout=30*60,
)
sb.detach()
modal --profile <profile-name> run my_app.py
modal --profile my-staging-profile run my_app.py
import modal

app = modal.App.from_name('my-app')
async for entry in app.logs.stream():
    print(entry)
HTTPS_PROXY=http://proxy.corp.example.com:8080 modal deploy my_app.py
MODAL_SANDBOX_V2=1 modal run my_sandbox_app.py
modal image logs my-app-name
modal billing rates

Summary

Modal is a cloud platform for running, scaling, and deploying Python code and machine learning models serverlessly.

Release history

docs update Aug 28, 2026 · issue 009

Modal Sandboxes gain granular outbound/inbound network controls, runtime policy updates, and HTTP/WebSocket Connect Tokens.
└──▷ USE IT
Lock down an agentic Sandbox mid-session: start with broad access for dependency installation, then narrow to only the domains the tool actually needs.
python
```
sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_domain_allowlist=["*"],
    outbound_cidr_allowlist=["0.0.0.0/0"],
    app=app,
)

# ... dependencies installed ...

sb._experimental_set_outbound_network_policy(
    outbound_domain_allowlist=["api.openai.com", "*.github.com"],
    outbound_cidr_allowlist=[],
)
```
Serve HTTP from inside a Sandbox with per-request authenticated access, forwarding verified caller metadata to the application.
python
```
sb = modal.Sandbox.create(
    "bash", "-c", "python3 -m http.server 8080",
    app=my_app,
)

creds = sb.create_connect_token(user_metadata={"user_id": "alice"}, port=8080)

import requests
resp = requests.get(creds.url, headers={"Authorization": f"Bearer {creds.token}"})
print(resp.text)
```
Restrict a Sandbox to only two IP ranges while keeping all other outbound traffic blocked, for tightly scoped egress control.
python
```
sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_cidr_allowlist=["52.0.0.0/8", "10.0.1.0/24"],
    app=app,
)
```
- ›Adds block_network=True parameter to modal.Sandbox.create() to drop all outbound traffic from a Sandbox.
- ›Adds outbound_cidr_allowlist parameter to modal.Sandbox.create() to restrict outbound traffic to specified CIDR ranges (any protocol).
- ›Adds outbound_domain_allowlist parameter (Beta) to modal.Sandbox.create() to restrict outbound TLS traffic (port 443 only) to specified domain names, with wildcard *. prefix support for subdomains; blocked connections are logged to the Sandbox system output stream.
- ›Adds inbound_cidr_allowlist parameter to modal.Sandbox.create() to restrict which source IPs can connect inbound to the Sandbox through tunnels and Connect Tokens.
- ›Adds _experimental_set_outbound_network_policy() method (Python) / sb.updateNetworkPolicy() (JS) / sb.UpdateNetworkPolicy() (Go) to replace the outbound network policy of a running Sandbox without restarting it; new policy takes effect immediately and terminates established connections that no longer match.
+3 moreshow less
- ›Adds sb.create_connect_token(user_metadata=..., port=...) (Python) / sb.createConnectToken() (JS) / sb.CreateConnectToken() (Go) to generate Sandbox Connect Tokens for authenticated HTTP and WebSocket access; tokens can be passed via Authorization header, _modal_connect_token query param, or _modal_connect_token cookie; the server receives an unspoofable X-Verified-User-Data header containing the JSON-serialized metadata.
- ›Adds h2_ports parameter to modal.Sandbox.create() to expose HTTP/2 + TLS tunnels from a Sandbox, complementing the existing encrypted_ports (HTTP/1.1) and unencrypted_ports options.
- ›Allows outbound_cidr_allowlist and outbound_domain_allowlist to be combined additively — traffic matching either list is permitted.
docs update Aug 28, 2026 · issue 009

Modal Sandboxes add readiness probes, idle timeouts, and lifecycle events for secure untrusted-code execution
└──▷ USE IT
Wait for an HTTP server inside a Sandbox to be ready before sending traffic — avoids hand-rolling polling logic.
python
```
sb = modal.Sandbox.create(
    "python3", "-m", "http.server", "8080",
    readiness_probe=modal.Probe.with_tcp(8080),
    app=sb_app,
)
sb.wait_until_ready()
# server is now accepting connections
sb.terminate()
sb.detach()
```
Gate further Sandbox work on a setup script completing by probing for a sentinel file, rather than sleeping a fixed amount of time.
python
```
sb = modal.Sandbox.create(
    "bash", "-c", "sleep 5 && touch /tmp/ready && sleep 3600",
    readiness_probe=modal.Probe.with_exec(
        "sh", "-c", "test -f /tmp/ready",
        interval_ms=250,
    ),
    app=sb_app,
)
sb.wait_until_ready()
p = sb.exec("cat", "/tmp/ready")
sb.terminate()
sb.detach()
```
Run a long-lived Sandbox (up to 24 h) that self-terminates after 30 minutes of inactivity instead of billing for idle time.
python
```
sb = modal.Sandbox.create(
    app=sb_app,
    timeout=24*60*60,
    idle_timeout=30*60,
)
sb.detach()
```
- ›Adds readiness_probe parameter to Sandbox.create(...) supporting modal.Probe.with_tcp(port) (TCP probe) and modal.Probe.with_exec(cmd, interval_ms=...) (exec probe) so you can block until a Sandbox service is ready via sb.wait_until_ready().
- ›Adds idle_timeout parameter to Sandbox.create(...) to auto-terminate a Sandbox after inactivity — a Sandbox is considered active if sb.exec(...) is running, sb.stdin.write() is being called, or a Tunnel TCP connection is open.
- ›Adds timeout parameter to Sandbox.create(...) configurable up to 24 hours (default: 5 minutes).
- ›New modal.Sandbox interface supports Sandbox.create, sb.exec(...), sb.terminate(), sb.detach(), sb.poll(), and sb.wait_until_ready() for managing secure containers at runtime.
- ›Introduces a five-stage Sandbox lifecycle — Created, Scheduled, Started, Ready (only when readiness probes are configured), and Finished — observable via the dashboard and sandbox.poll() exit codes.
+1 moreshow less
- ›TypeScript (modal npm package) and Go (github.com/modal-labs/modal-client/go) SDKs now expose the full Sandbox API including modal.sandboxes.create(...), sb.exec(...), Probe.withTcp(port), Probe.withExec(cmd, { intervalMs }), and sb.waitUntilReady().
docs update Aug 28, 2026 · issue 009

Modal 1.5.5 adds Sandbox log retrieval by time range, default RBAC role config, and a global --profile CLI flag
└──▷ TRY IT
Switch to a non-default Modal profile for a one-off command without editing config.
```
$ modal --profile <profile-name> run my_app.py
```
└──▷ BREAKING ON UPGRADE
- !Several undocumented APIs on Modal SDK object types are deprecated in 1.5.5 and will be removed in version 1.6.0 — check for deprecation warnings before upgrading.
1.5.5 (2026-08-28) Aug 28, 2026 · issue 009

Modal 1.5.5 adds Sandbox log fetching/tailing, configurable default RBAC roles for Restricted Environments, and a global --profile CLI option.
└──▷ TRY IT
Select a non-default profile on the fly without changing your config file, useful when switching between workspaces in CI.
```
$ modal --profile my-staging-profile run my_app.py
```
- ›Adds modal.Sandbox.logs API with fetch() for date/time-range log retrieval and tail() for the most recent logs from a Sandbox's entrypoint process.
- ›Adds a --profile global option to the modal CLI for ad hoc profile selection without modifying configuration.
- ›Enables configuring the default role when creating a new Restricted Environment via the CLI or SDK.
snapshot-20260820 seen Aug 20, 2026 · issue 002

Modal 1.5.4 adds a high-performance Sandbox backend, App/Image logs APIs, billing rates API, and fractional autoscaler concurrency
└──▷ USE IT
Stream live logs from a deployed App to monitor it in real time from a script.
python
```
import modal

app = modal.App.from_name('my-app')
async for entry in app.logs.stream():
    print(entry)
```
Opt into HTTP proxy support for the Modal client via environment variables when running behind a corporate proxy.
```
$ HTTPS_PROXY=http://proxy.corp.example.com:8080 modal deploy my_app.py
```
- ›Enables a new high-performance Sandbox backend via MODAL_SANDBOX_V2=1 environment variable, delivering substantially higher creation rates and concurrency; becomes the default in SDK version 1.6.0.
- ›Adds App.logs API with fetch(), tail(), and stream() methods to retrieve all logs from an App programmatically.
- ›Adds Image.logs API with fetch() and tail() methods to retrieve Image build logs programmatically.
- ›Adds modal image logs CLI command for accessing Image build logs from the command line.
- ›Adds Workspace.billing.rates() API and modal billing rates CLI to query current pricing structure for a workspace.
+33 moreshow less
- ›Function.update_autoscaler() and Server.update_autoscaler() now return the complete autoscaler configuration state after applying an update.
- ›The target_concurrency parameter in @app.server() and Server.update_autoscaler() now accepts fractional values for finer-grained autoscaling control.
- ›Adds Function.logs, Server.logs, and FunctionCall.logs APIs, each exposing stream(), fetch(), and tail() methods.
- ›Adds modal.Workspace.billing.summary() method and modal billing summary CLI to see workspace-level spend broken down by category, credit usage, and compute reservation impact.
- ›Adds modal.Environment.billing.summary() method and modal environment billing summary CLI for environment-level spend summaries.
- ›Introduces modal.Environment.roles interface and modal environment roles CLI for managing RBAC permissions, replacing the deprecated modal.Environment.members interface and modal environment members CLI.
- ›Adds --compute-region option (repeatable) to modal endpoint create to configure the region where Endpoint containers run.
- ›Adds modal.Workspace.settings.list() method and modal workspace settings list CLI to view current workspace-level settings.
- ›Adds modal.Workspace.settings.set() method and modal workspace settings set CLI to programmatically configure workspace settings.
- ›Adds modal.types module exposing dataclasses returned from public SDK methods as public API, useful for type annotations.
- ›modal.Function.with_options() now accepts a routing_region argument to configure regional routing dynamically at invocation time.
- ›Adds --graceful flag to modal container stop CLI, allowing a container to finish in-flight inputs before exiting rather than having them cancelled.
- ›modal container logs CLI now includes logs from the container startup phase.
- ›modal.Sandbox.reload_volumes() now accepts a timeout argument (default 55 seconds) and raises modal.exception.TimeoutError if the reload does not complete in time.
- ›Introduces @app.server() decorator and modal.Server object as a new serverless compute primitive optimized for low-latency HTTP applications.
- ›Introduces modal endpoint CLI for deploying production-ready LLM inference endpoints with minimal configuration.
- ›Adds workspace.billing.report() and environment.billing.report() methods with resource-level cost breakdown by CPU, memory, and GPU type.
- ›Adds modal environment billing CLI for generating environment-scoped billing reports.
- ›Adds workspace.proxy_tokens.create(), workspace.proxy_tokens.list(), and related methods on modal.Workspace, plus a modal workspace proxy-tokens CLI for managing proxy tokens.
- ›Adds modal workspace members CLI for querying workspace membership information.
- ›Adds modal curl experimental CLI command for making authenticated requests to endpoints without manually passing proxy token headers.
- ›modal app rollback now accepts a --strategy option (rolling or recreate), matching modal deploy and modal app rollover.
- ›modal.Sandbox.create_connect_token() now accepts a port= argument to scope connect tokens to a custom port.
- ›The Modal Python client now supports HTTP CONNECT and SOCKS4/5 proxies via standard HTTPS_PROXY and ALL_PROXY environment variables; install extras with uv pip install 'modal[api-proxy-support]', or opt out by setting MODAL_DISABLE_API_PROXY=1 or disable_api_proxy = true in .modal.toml.
- ›Introduces named Images via modal.Image.publish() (optionally with '{name}:{tag}' format) and modal.Image.from_name() for Modal-native image registry functionality.
- ›Adds modal image names CLI to view current name assignments for published Images.
- ›Adds version= parameter to modal.Function.from_name() and modal.Cls.from_name() to pin invocations to a specific deployed version of a Function.
- ›Adds outbound_domain_allowlist=[...] parameter to modal.Sandbox.create() to restrict which domains Sandbox processes can connect to, with denials recorded in App logs.
- ›Adds modal skills CLI with modal skills install and modal skills update subcommands for managing a foundational Modal agent skill.
- ›Introduces modal.Workspace object with workspace.members.list() method for programmatic workspace configuration management.
- ›Adds sandbox.filesystem.watch() method to the Sandbox Filesystem API for improved latency and reliability over the deprecated modal.Sandbox.watch().
- ›modal.Sandbox.snapshot_filesystem() and modal.Sandbox.snapshot_directory() now accept a ttl= keyword argument (default 30 * 24 * 3600 seconds) to configure snapshot image retention.
- ›modal.Sandbox.snapshot_directory() now accepts a timeout= keyword argument (default 55 seconds), raising modal.exception.TimeoutError if the snapshot does not complete in time.
└──▷ BREAKING ON UPGRADE
- !The new Sandbox backend (MODAL_SANDBOX_V2=1) does not support the deprecated FileIO-based Sandbox filesystem API; code currently issuing FileIO deprecation warnings must be migrated before enabling the flag.
- !modal.Sandbox.snapshot_filesystem() and modal.Sandbox.snapshot_directory() now default to ttl=30 * 24 * 3600 (30 days), replacing the previous behavior of persisting snapshot Images indefinitely; pass ttl=None to retain the old behavior.
- !modal.Sandbox.snapshot_directory() now defaults to a 55-second timeout= and raises modal.exception.TimeoutError if exceeded, replacing the previous behavior of waiting indefinitely.
- !Several deprecated static methods (.delete() and .create_deployed()) on Modal storage objects (modal.Volume, etc.) have been removed; use .objects.delete() and .objects.create() instead.
- !The existing modal.billing.workspace_billing_report function is replaced by the new workspace.billing.report() API.
1.5.4 (2026-08-12) Aug 12, 2026 · issue 005

└──▷ TRY IT
Opt into the faster Sandbox backend to handle higher concurrency workloads without any code changes.
```
$ MODAL_SANDBOX_V2=1 modal run my_sandbox_app.py
```
Stream live logs from a deployed App to monitor execution in real time.
```
$ modal image logs my-app-name
```
Check current workspace pricing rates before scaling up GPU workloads.
```
$ modal billing rates
```
- ›Adds Workspace.billing.rates() API to query current workspace pricing structure programmatically.
- ›Adds modal billing rates CLI command to query workspace pricing from the terminal.