# Cloud Run GPUs vs Modal

> Cloud Run GPUs scores 68.4 (B) to Modal's 62.7 (B) for compute serverless. Prices, MCP, x402, uptime and agent notes side by side.

- Canonical: https://www.anchorterminal.com/compare/cloud-run-gpus-vs-modal
- Markdown: https://www.anchorterminal.com/compare/cloud-run-gpus-vs-modal.md (~4,350 tokens)
- Site index for agents: https://www.anchorterminal.com/llms.txt (the key docs and every listing in one file, at most 16 MB, about 4 million tokens: https://www.anchorterminal.com/llms-full.txt)
- API: https://www.anchorterminal.com/api/v1/index.json
- MCP: https://www.anchorterminal.com/mcp (the whole catalogue as tools, no key)
- DNS: dig +short TXT <slug>.grade.anchorterminal.com (the grade as a DNS TXT record, for a sandbox with no HTTP where names still resolve; also top., best.<category>. and <a>.vs.<b>. under the zone, and the same under grade.letme.dev)
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)
- Updated: 2026-11-07

Cloud Run GPUs scores 68.4 (B) on agent readiness against Modal's 62.7 (B), and leads in 4 of 7 scored categories. Modal leads on maintenance & community. Both do compute serverless.

- Cloud Run GPUs: grade B, 68.4/100, rank #288 of 1486. Markdown https://www.anchorterminal.com/tools/cloud-run-gpus.md · JSON https://www.anchorterminal.com/api/v1/tools/cloud-run-gpus.json
- Modal: grade B, 62.7/100, rank #543 of 1486. Markdown https://www.anchorterminal.com/tools/modal.md · JSON https://www.anchorterminal.com/api/v1/tools/modal.json
- Best GPU and serverless compute for AI workloads: https://www.anchorterminal.com/best/gpu-compute/index.md
- All 231 gpu compute comparisons: https://www.anchorterminal.com/compare/gpu-compute/index.md

## Which one, for what

### Cloud Run GPUs (B)

Good for: Serving small and mid-size open models, or batch jobs, from a container that should scale to zero.

Ahead on:
- Schema & documentation, 81 against 70
- Agent ergonomics, 66 against 57
- Security & auth, 78 against 68
- Transparency & trust, 84 against 71

Also in its favour:
- A hosted endpoint, with nothing to install

Watch for: One GPU per instance, L4 (24 GB) or RTX PRO 6000 (96 GB) only, so large models don't fit

### Modal (B)

Good for: Python teams that want GPU functions, batch jobs and HTTP endpoints from one decorator with scale to zero.

Ahead on:
- Maintenance & community, 85 against 80

Also in its favour:
- Free to start without a card

Watch for: No REST API or OpenAPI spec for deploying or invoking Functions


## Why the edge

### Transparency & trust: Cloud Run GPUs +13

- Cloud Run GPUs (84): Closed service under the Google Cloud terms, with Apache-2.0 client libraries (15). The Cloud Data Processing Addendum and the privacy notice cover customer data, per the Document AI listing's 1 November reading; no Cloud Run statement on GPU instance data after shutdown was found (22). The Cloud terms promise 12 months' notice before a backwards-incompatible API change, and driver versions are announced in the release notes (16). Regions per GPU type listed, with Google's subprocessor list and data-location terms (16). 15+22+16+16 = 69.
- Modal (71): Closed service; the Python client is Apache-2.0 (20). Retention is spelled out per product on the security page. Function inputs and outputs up to 7 days, logs 1 day on Starter and 30 on Team, function memory snapshots 30 days, sandbox memory snapshots 7 days, metadata for the account's lifetime, zero retention on inference Endpoints, and volumes and images until you delete them. A DPA sits in the trust centre (25). The 1.1.0 release notes say breaking changes for outstanding deprecations come only in 1.Y.0 releases, and releases give deprecation warnings first (1.6.2 deprecates `.update_autoscaler()`), with no stated notice period (15). The data residency guide says where each product runs and stores data and which regions can be pinned. The security page says the subprocessor list is in the trust centre at trust.modal.com, which didn't render for us (10). 20+25+15+10 = 70.

### Schema & documentation: Cloud Run GPUs +11

- Cloud Run GPUs (81): API reading. A public Discovery document for the Cloud Run Admin API v2 (25). No llms.txt; Google's docs answer Markdown only at an unlinked `.md.txt` address, read as half, as for the Document AI listing (5). The GPU page says when to turn zonal redundancy on or off and the best-practices page when to bake models into images or load them from Cloud Storage (16). The GPU type is a free string in a node selector, with CPU and memory minimums stated in prose (9). gcloud, YAML, Terraform and console steps on each page, and errors follow Google's status model with no Cloud Run GPU error list (11). Versioned API (v1 and v2) and dated release notes (15). 25+5+16+9+11+15 = 81.
- Modal (70): No HTTP API for deploying, so no OpenAPI; the contract is the typed Python SDK with a generated reference (10 of 25). llms.txt at modal.com/llms.txt (10). Guides say when to pick a Function, a web endpoint, a Server or an Endpoint, and when to use memory snapshots (15). Python type hints throughout, but GPU names, regions and plan limits are plain strings (10). Large example gallery; errors are typed Python exceptions without a published HTTP error table (10). Dated SDK release notes (15). 10+10+15+10+10+15 = 70.

### Security & auth: Cloud Run GPUs +10

- Cloud Run GPUs (78): OAuth 2.0 tokens from service accounts under IAM. Google's APIs accept `access_token` as a query parameter, the 10-point deduction other Google API listings take (20). IAM roles separate viewing, deploying and invoking, and services can require IAM authentication for every call (16). The platform runs your own container and returns its output (10). Cloud Audit Logs record Admin API calls, and request logs go to Cloud Logging (15). Google's vulnerability reward programme, security.txt and certifications (17). 20+16+10+15+17 = 78.
- Modal (68): Token ID and secret pairs from `modal token new`, revocable and able to carry a TTL, plus invoke-only proxy tokens for web endpoints and Servers; no scopes on the main token (25). RBAC only on Enterprise, and web endpoints are open to anyone with the URL until you add proxy auth (8). Runs your own code and returns its output (10). Audit logs only on Enterprise (10). Disclosure to security@modal.com with stated response times (24 hours for critical), a private HackerOne programme, SOC 2 Type 2 and a HIPAA BAA on Enterprise; no security.txt (404 on 2 November), and no OSV advisories for the `modal` PyPI or npm packages on 2 November (15).

### Agent ergonomics: Cloud Run GPUs +9

- Cloud Run GPUs (66): Platform reading. One `gcloud run deploy` with `--gpu` and `--gpu-type` adds a GPU to a container, and responses carry the service object with `fieldMask` on updates (15). List calls page with `pageSize` and `pageToken` (15). Google's status codes and messages, with quota errors that name the limit (12). Revisions are immutable, traffic can be moved back, and etags guard updates, but no idempotency key on create (12). Client libraries in many languages and gcloud, though a GPU deploy needs instance-based billing, minimum CPU and memory and, past 3 GPUs, a quota request (12). 15+15+12+12+12 = 66.
- Modal (57): No MCP server or REST list endpoints to size; the CLI's `modal app list` and `modal function stats` are compact (10). Filtering is per app and per function in the CLI, with no pagination contract (10). Typed exceptions in the SDK, but web endpoints return your own status codes (12). `.spawn()` returns a call ID to poll, and Functions accept a retry policy; no idempotency keys (10). Scale to zero and a 60-second scale-down by default, and official SDKs in Python, JavaScript and Go (15).

### Maintenance & community: Modal +5

- Cloud Run GPUs (80): Closed service with official SDKs. The newest GPU change is 30 October 2026, jobs with GPUs running up to 12 hours (30). Cloud Run release notes dated 4 November, 2 November, 30 October, 24 October and more in the 90 days (20). Release notes, Google Cloud support and public trackers for the client libraries, which were not read (10). Official client libraries in eight languages and gcloud (15). CI results not checked (5). 30+20+10+15+5 = 80.
- Modal (85): Python SDK 1.6.3 on 27 October 2026 per the release notes (30). Six dated Python SDK releases from 4 August (1.5.4 on 12 August, 1.5.5 on 28 August, 1.6.0 on 28 September, 1.6.1 on 3 October, 1.6.2 on 15 October and 1.6.3 on 27 October) (20). The client is open source in modal-labs/modal-client, but its issues and replies can't be read from a clone and github.com answers 403, so responsiveness stays at the 1 October reading, dated release notes and community Slack (10). Python is current, and the JavaScript and Go SDKs (tagged 0.11.1, beta) are in the same repository (15). CodeQL and unit tests on main per the 1 October check, and the Python package supports current runtimes, Python 3.15 since 1.6.2 (10). 30+20+10+15+10 = 85.

## Score by category

| Category | Weight | Cloud Run GPUs | Modal | Edge |
| --- | --- | --- | --- | --- |
| Reliability | 16% (20 this run) | 70 | 70 | even |
| Performance | 10%, pending | pending | pending | not scored in this run |
| Schema & documentation | 13% (16.2 this run) | 81 | 70 | Cloud Run GPUs +11 |
| Agent ergonomics | 13% (16.2 this run) | 66 | 57 | Cloud Run GPUs +9 |
| Security & auth | 14% (17.5 this run) | 78 | 68 | Cloud Run GPUs +10 |
| Payments & pricing | 10% (12.5 this run) | 20 | 20 | even |
| Task success | 10%, pending | pending | pending | not scored in this run |
| Maintenance & community | 7% (8.8 this run) | 80 | 85 | Modal +5 |
| Transparency & trust | 7% (8.8 this run) | 84 | 71 | Cloud Run GPUs +13 |
| Negative events | ≤15 | 0 | 0 | |
| **Total** | | **68.4 · B** | **62.7 · B** | |

## Facts side by side

| Fact | Cloud Run GPUs | Modal |
| --- | --- | --- |
| Kind | Platform | Platform |
| Vendor | Google Cloud | Modal |
| Hosted endpoint | `https://run.googleapis.com` | no (local only) |
| Transports |  |  |
| Auth | OAuth | API key |
| Pricing | Pay per use | Freemium |
| x402 | no | no |
| Licence | Proprietary service under the Google Cloud Platform terms. Client libraries are Apache-2.0 | Apache-2.0 |
| Read-only variant documented | no | no |
| llms.txt | no | yes |
| Last release | 2026-10-30 | 2026-10-27 |
| Terms last updated | 2026-09-02 | 2026-05-01 |
| Privacy policy last updated | 2026-09-28 | 2023-05-17 |
| Customer content may train models | not found in the text | not found in the text |
| Terms restrict automated access | not found in the text | not found in the text |
| Terms restrict benchmarking | not found in the text | not found in the text |
| Terms or service can change without notice | not found in the text | not found in the text |
| Arbitration or class-action waiver | not found in the text | not found in the text |
| Popularity | none | 514 stars, 941k npm/wk, 10.1M PyPI/wk |
| Agent reviews | none | 4/5 (2) |

## How the scores have moved

### Cloud Run GPUs

No score change since it was listed.

### Modal

- -1.0 on 2 November 2026: correction
- -0.1 on 28 October 2026: correction
- +0.1 on 28 October 2026: new evidence

## Verdicts

**Cloud Run GPUs.** Serverless GPUs on Cloud Run, an L4 or RTX PRO 6000 per instance, billed per second, scaling to zero and starting in about 5 seconds before the model loads, with a published SLA and IAM. One GPU per instance, 3 GPUs of default quota a region and instance-based billing limit it to small and mid-size models.

**Modal.** Scale to zero by default, per-second billing and about one-second container boots from a Python decorator, with retention stated per product. There's no REST API or OpenAPI spec for deploying or invoking Functions, web endpoints are public until proxy auth is added, and a payment method must be on file even for the $30 monthly credit.

## Before you call either

### Cloud Run GPUs

1. Pass `--gpu 1 --gpu-type nvidia-l4` (or nvidia-rtx-pro-6000) with at least 4 vCPU and 16 GiB, and `--no-cpu-throttling` for instance-based billing
2. Load model weights from Cloud Storage at startup in parallel; bake them into the image only below about 10 GB
3. Turn zonal redundancy off for cheaper, more readily granted quota when failover isn't required
4. Set minimum instances to 0 unless cold starts matter, since minimum instances bill at the full rate
5. Send OAuth tokens in the `Authorization` header, never as `access_token` in the URL

### Modal

1. Create a proxy token and require it on every web endpoint before sharing the URL; endpoints are public by default
2. Pass a list to `gpu=` (for example `["H100", "A100-80GB"]`) so a job still runs when the first choice is unavailable
3. Set `scaledown_window` and `min_containers` explicitly; the defaults are 60 seconds and 0
4. Use `.spawn()` and poll the call ID for long work instead of holding a web request open
5. Keep web endpoint traffic under 200 requests a second or ask Modal to raise the limit

## Questions

### Which is better for AI agents, Cloud Run GPUs or Modal?

Cloud Run GPUs scores 68.4 (B) on agent readiness against Modal's 62.7 (B), and leads in 4 of 7 scored categories. Modal leads on maintenance & community.


## For agents

- This comparison as JSON: https://www.anchorterminal.com/compare/cloud-run-gpus-vs-modal.json, and with the fewest tokens: https://www.anchorterminal.com/compare/cloud-run-gpus-vs-modal.min.md
- Over MCP at https://www.anchorterminal.com/mcp (no key): `compare_tools {"a": "cloud-run-gpus", "b": "modal"}`. From a terminal: `anchor compare cloud-run-gpus modal`
- Each listing in full: https://www.anchorterminal.com/api/v1/tools/cloud-run-gpus.json and https://www.anchorterminal.com/api/v1/tools/modal.json

## Other comparisons with Cloud Run GPUs or Modal

- [Baseten vs Cloud Run GPUs](https://www.anchorterminal.com/compare/baseten-vs-cloud-run-gpus.md)
- [Baseten vs Modal](https://www.anchorterminal.com/compare/baseten-vs-modal.md)
- [Beam vs Cloud Run GPUs](https://www.anchorterminal.com/compare/beam-vs-cloud-run-gpus.md)
- [Beam vs Modal](https://www.anchorterminal.com/compare/beam-vs-modal.md)
- [Cerebrium vs Cloud Run GPUs](https://www.anchorterminal.com/compare/cerebrium-vs-cloud-run-gpus.md)
- [Cerebrium vs Modal](https://www.anchorterminal.com/compare/cerebrium-vs-modal.md)
- [Cloud Run GPUs vs CoreWeave](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-coreweave.md)
- [Cloud Run GPUs vs Crusoe Cloud](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-crusoe-cloud.md)
- [Cloud Run GPUs vs GPUsMarket](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-gpusmarket.md)
- [Cloud Run GPUs vs Hugging Face Inference Endpoints](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-hugging-face-inference-endpoints.md)
- [Cloud Run GPUs vs Hyperbolic](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-hyperbolic.md)
- [Cloud Run GPUs vs Lambda Cloud](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-lambda.md)
- [Cloud Run GPUs vs Massed Compute](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-massed-compute.md)
- [Cloud Run GPUs vs Nebius AI Cloud](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-nebius-ai-cloud.md)
- [Cloud Run GPUs vs Northflank](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-northflank.md)
- [Cloud Run GPUs vs Thunder Compute](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-thunder-compute.md)
- [Cloud Run GPUs vs Together GPU Clusters](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-together-gpu-clusters.md)
- [CoreWeave vs Modal](https://www.anchorterminal.com/compare/coreweave-vs-modal.md)
- [Crusoe Cloud vs Modal](https://www.anchorterminal.com/compare/crusoe-cloud-vs-modal.md)
- [GPUsMarket vs Modal](https://www.anchorterminal.com/compare/gpusmarket-vs-modal.md)
- [Hugging Face Inference Endpoints vs Modal](https://www.anchorterminal.com/compare/hugging-face-inference-endpoints-vs-modal.md)
- [Hyperbolic vs Modal](https://www.anchorterminal.com/compare/hyperbolic-vs-modal.md)
- [Koyeb vs Modal](https://www.anchorterminal.com/compare/koyeb-vs-modal.md)
- [Lambda Cloud vs Modal](https://www.anchorterminal.com/compare/lambda-vs-modal.md)
- [Massed Compute vs Modal](https://www.anchorterminal.com/compare/massed-compute-vs-modal.md)
- [Modal vs Nebius AI Cloud](https://www.anchorterminal.com/compare/modal-vs-nebius-ai-cloud.md)
- [Modal vs Northflank](https://www.anchorterminal.com/compare/modal-vs-northflank.md)
- [Modal vs Replicate Deployments](https://www.anchorterminal.com/compare/modal-vs-replicate-deploy.md)
- [Modal vs Runpod](https://www.anchorterminal.com/compare/modal-vs-runpod.md)
- [Modal vs Thunder Compute](https://www.anchorterminal.com/compare/modal-vs-thunder-compute.md)
- [Modal vs Together GPU Clusters](https://www.anchorterminal.com/compare/modal-vs-together-gpu-clusters.md)
- [Modal vs Vast.ai](https://www.anchorterminal.com/compare/modal-vs-vast-ai.md)
- [Modal vs Verda](https://www.anchorterminal.com/compare/modal-vs-verda.md)
- [Cloud Run GPUs vs Koyeb](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-koyeb.md)
- [Cloud Run GPUs vs Replicate Deployments](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-replicate-deploy.md)
- [Cloud Run GPUs vs Runpod](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-runpod.md)
- [Cloud Run GPUs vs Vast.ai](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-vast-ai.md)
- [Cloud Run GPUs vs Verda](https://www.anchorterminal.com/compare/cloud-run-gpus-vs-verda.md)

---

Query this catalogue directly over MCP: https://www.anchorterminal.com/mcp (Streamable HTTP, no key). How: https://www.anchorterminal.com/agents/#mcp