Modal and Lanes Compute approach GPU compute from different ends. Modal is code-first: you write Python functions and Modal runs them on GPUs on demand, abstracting the infrastructure away. Lanes Compute is infrastructure-first: you get the GPUs or a multi-node cluster and run your own stack on them. Lanes Compute is in early access.
Concretely, Lanes Compute rents you A100, H100, and H200 SXM cards, plus L40S and other options for lighter workloads, from a single GPU to a multi-node cluster, billed per second, with your own containers on top. This page is about which end of that spectrum fits your work, and when both do.
At a glance
| Dimension | Lanes Compute | Modal |
|---|---|---|
| Model | GPUs and clusters you run your stack on | Serverless: your Python runs on managed GPUs |
| Control | Full control of the machine and stack | Managed infrastructure, code-first |
| Multi-node | Yes, InfiniBand and NVLink | Managed scaling |
| Bring your own stack | Yes, your own containers | Python-first with your dependencies |
| GPUs | A100, H100, H200 SXM, plus L40S | Managed GPU pool |
| Storage | Fast persistent network volumes | Managed by the platform |
| Billing | Per second | Per second |
| Status | Early access | Generally available |
| Docs | Lanes Compute | modal.com |
Where Lanes Compute fits
Lanes Compute is for when you want direct control of the hardware: a specific GPU, a real multi-node cluster, your own container and framework. You run your stack, not a platform's abstraction of it.
That control earns its keep when the workload does not fit the shape of a function: a long training or fine-tuning run, a serving stack such as vLLM that you tune yourself, or a distributed job that needs InfiniBand between nodes and NVLink within them. You pick the card, attach persistent network volumes so datasets and checkpoints survive between runs, choose the region near your data, and pay per second while the environment is live. Once it is torn down, billing stops.
Where Modal fits
Modal is for when you want infrastructure to disappear behind your code. If a serverless, Python-first developer experience with autoscaling suits your work, Modal is excellent at it.
Serverless is a good trade when jobs are short, bursty, and shaped like functions: the platform handles machines and scaling, and you think in code. The price of that convenience is distance from the hardware, which starts to matter once you want to shape the machine, the interconnect, or the runtime yourself.
How Lanes does it
- You pick the hardware. A100, H100, or H200 SXM today, with L40S and other options for lighter workloads, from a single card to a multi-node cluster, taken on demand or reserved for longer runs.
- Your containers, unchanged. Bring your own images and frameworks: PyTorch, JAX, vLLM, Axolotl, DeepSpeed, or anything else that runs in a container. A CLI and API drop into your existing agents and tooling. See bring your own stack.
- Billing follows the run. Per-second billing while the environment is live, nothing after teardown, and persistent volumes that hold datasets and checkpoints between runs. For serving, pick a card sized to your traffic, as in inference and model serving.
- Early access, quick onboarding. Request access with the form on the compute page, describe the workload, and onboarding usually takes a day or two.
Choose Lanes Compute if
- You want direct control of GPUs and clusters, running your own stack.
- Your work is long training or fine-tuning runs, or a serving stack you operate yourself.
- You need multi-node jobs with real interconnect between nodes.
- You want persistent volumes and per-second billing around your own containers.
Choose Modal if
- You want a code-first, serverless experience that manages the infra for you.
- Your jobs are short, bursty, and function-shaped.
- You would rather not think about machines at all.
The two models are not exclusive. Some teams keep function-shaped jobs on a serverless platform and run training and serving on infrastructure they control.
Further reading
- Bring your own stack: run PyTorch, JAX, vLLM, and your own containers on Lanes Compute.
- Inference and model serving: serve models on GPUs sized to your traffic, with your own serving stack.