# Run a bounded GPU job and tear it down

> Run a bounded GPU job and tear it down: 4 companies fully do it, 14 with a limit, 26 carry the tag. Every listing in GPU & serverless compute with the reason and a source.

- Canonical: https://www.anchorterminal.com/niches/gpu-compute.batch-job/
- Markdown: https://www.anchorterminal.com/niches/gpu-compute.batch-job/index.md (~2,100 tokens)
- Slim: https://www.anchorterminal.com/niches/gpu-compute.batch-job/index.min.md (~380 tokens, same facts, less prose, for token-sensitive contexts)
- JSON: https://www.anchorterminal.com/niches/gpu-compute.batch-job/index.json (this page as data, same URL with Accept: application/json)
- 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-15

Four or more companies' docs show a full fit.

| Companies, full fit | With a limit | Carry the tag | Share of the category's work | First-hand accounts |
| --- | --- | --- | --- | --- |
| 4 | 14 | 26 | 12 | 4 |

## What counts as done

The job starts after submission, writes its outputs to the given storage, and all compute is released within one scale-down window with a cost that matches seconds or minutes of GPU time, not hours.

Measured, for our own tests: the job starts within 5 minutes of submission.

How agents ask for it: embed these 2 million chunks as fast as possible; transcribe this folder of audio overnight; evaluate this model on the benchmark on an H100 and give me the numbers

## Does the job

The docs show it meets the test above, and nothing we read says otherwise.

- **Beam (Smartshare, Inc.)**: Task queues and functions run up to 3600 s by default (or unlimited), return a task_id to poll at api.beam.cloud/v2/task/{id}, post a signed callback_url, and containers stop 10 s after the queue drains; Output.save gives expiring public URLs.
- **Modal (Modal Labs, Inc.)**: .spawn() and .map() run a Function up to 24 hours per attempt, containers scale down 60 s after the last input, and billing is per second with nothing at zero containers. Outputs go to Volumes or the caller polls the call ID.
- **Nebius AI Cloud (Nebius B.V.)**: Serverless AI jobs run a container to completion with --timeout, mounted buckets or filesystems for output and an optional preemptible VM, billed per second only while running; the container disk is removed when the job finishes.
- **Northflank (Northflank Ltd)**: POST run-job starts a manual job with GPU resources and runtime overrides, runs return details and logs through the API, and compute is billed per second only while the run lasts.

## Does the job, with a limit

It does the job, but something in the docs or a user's account will get in an agent's way. The limit is named in each row.

- **Baseten (Baseten Labs, Inc.)**: /async_predict queues work for up to 72 hours and sends through a webhook, and a deployment scales to zero after scale_down_delay. Outputs are not stored, so a failed webhook loses them, and the 900 s default delay bills after the last job.
- **Cerebrium (Cerebrium Inc.)**: ?async=true returns a run_id with 202 and webhookEndpoint forwards the result; runs last up to 12 hours and containers stop after the 60 s cooldown. No result is stored for the caller, so a failed webhook loses it unless the function writes to /persistent-storage.
- **Cloud Run GPUs (Google LLC)**: Cloud Run jobs attach a GPU per task with --parallelism, write to Cloud Storage and release everything at the end; a user ran a livestream translation pipeline this way (acc-37). GPU tasks are capped at 12 hours (preview) and parallelism at the GPU quota, 3 by default.
- **CoreWeave (CoreWeave, Inc.)**: A Kubernetes job runs on a node pool and targetNodes 0 or deletion ends billing, but the unit is a whole node by the hour and the agent manages the scale-down itself; no managed job submission or result path.
- **Crusoe Cloud (Crusoe Technologies LLC)**: A VM billed per second and deleted afterwards fits a bounded job, and Serverless Fine-Tuning queues a training job with no GPU choice, but there is no general job API, webhook or managed output; the OS disk bills while stopped.
- **Hyperbolic (Hyperbolic Labs, Inc.)**: A job means renting a VM, running the script over SSH and terminating; hourly billing from ready means a 10 minute job costs an hour, and there is no job submission, webhook or managed output path.
- **Lambda Cloud (Lambda, Inc.)**: A job is a VM launched, run over SSH and terminated, billed in one-minute increments from health check to terminate with free ingress and egress; no job queue, webhook or managed output, and filesystems keep billing after the instance is gone.
- **Massed Compute (Massed Compute, Inc.)**: A job is a VM the agent launches, runs over SSH and terminates; billing is debited every minute at the hourly rate, and there is no job queue, webhook or managed output. Stopping instead of terminating keeps the full charge.
- **Replicate Deployments (Replicate, LLC)**: Predictions run asynchronously with webhooks and a deployment scales back down afterwards, but outputs and logs are deleted an hour after an API prediction, so the agent must copy results promptly, and idle instance time is billed.
- **Runpod (Runpod, Inc.)**: /run queues a job, /status polls it and webhooks deliver results, with workers idle-timing out afterwards; an agent skill picks hardware and starts temporary inference this way (acc-04). Results expire after 30 minutes, and payload errors once left workers restarting until balances drained (acc-10).
- **Thunder Compute (Thunder GPU, Inc.)**: Sandboxes run commands as durable jobs billed per second with an expiry (for example 900 s) and the SDK reattaches after disconnects; results must be downloaded before the sandbox is terminated, and sandbox access must be enabled by the vendor per organisation.
- **Together GPU Clusters (Together Computer, Inc.)**: The automation guide shows a CI job creating an on-demand cluster, polling for Ready, running a Kubernetes job and deleting the cluster. Billing is per hour of an 8-GPU-minimum cluster, so short jobs pay for an hour, and volumes keep billing after deletion.
- **Vast.ai (Vast.ai Inc.)**: An instance or serverless endpoint runs a bounded job at marketplace prices, as the gpt-oss-20b evaluation did (acc-21), but a stopped instance keeps billing storage, bandwidth is charged per byte by the host, and at zero balance instances stop and data is scheduled for deletion.
- **Verda (DataCrunch Oy)**: Serverless Containers accept async and polling requests and replicas scale to zero afterwards, and a VM job is refunded for the unused part of its 10-minute increment on delete. No result retention window or webhook is documented, and the replica bills while it idles until the scale-down delay.

- not this job: GPUsMarket (Tyga.Cloud Ltd): No job submission, queue or object-storage output path; the only async call is per-video generation polling. Work runs on a rental the agent must stop itself.
- not this job: Hugging Face Inference Endpoints (Hugging Face, Inc.): No job submission or run-to-completion mode; an endpoint must be created, called and paused or deleted, and bills per minute while a replica runs.
- not this job: Koyeb (Koyeb SAS): No run-to-completion job type; a worker service bills until scaled down or deleted and has no submission or result path.

## What stops agents finishing

- results deleted after a short window (30 minutes on one platform, one hour on another) before the agent fetches them
- a crashing worker restarts and bills until a human deletes it
- job queue takes 500 ms per job to hand out work, so small jobs cannot saturate the worker
- per-TB ingress and egress on some marketplace hosts dwarfs the compute cost

## Around it

Before: gpu-compute.find-and-provision, web-scrapers.bulk-page-collection, speech-to-text.long-recording-batch. After: agent-memory.ingest-records, open-weights.bulk-extraction, inference.batch-offline.

## Where this comes from

Weight 12 of 100 in GPU & serverless compute: 4 of 48 accounts are bounded jobs (embeddings, an evaluation run, speech-to-text bursts, a test TTS run) and the vendors' own use-case pages put batch next to inference; weight raised above the count because every training and endpoint account implies the tear-down step.

As data: https://www.anchorterminal.com/api/v1/use-cases/gpu-compute.batch-job.json, or the MCP tool get_use_case with id gpu-compute.batch-job. Draft, read 2026-11-12 from public docs and first-hand accounts, not yet reviewed by a person.

---

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