Nodus vs Modal: Which GPU Training Platform Comes Out on Top?

Introduction: Key Considerations for Choosing a GPU Training Platform

With AI model training costs rising ever higher, choosing the right GPU cloud platform directly affects both the economics and efficiency of your project. Nodus and Modal, two closely watched platforms, each have distinct design philosophies. The Nodus team recently published a detailed comparative analysis. While they openly acknowledge that they built Nodus, all data about Modal links to official documentation and pricing pages, the cost calculations are fully public, and they specifically list the scenarios where Modal wins. This transparency is commendable and makes the comparison more valuable as a reference.

The core conclusion is actually quite clear: if your training jobs are short, need to work closely with web endpoints, or require large-scale RDMA clusters, Modal is the better choice; but if your training runs for hours or even days and cost is the primary consideration, Nodus has the edge. The Python APIs of the two are nearly identical, Nodus's list prices are lower on most GPUs, and when a machine is reclaimed, Nodus automatically resumes from a checkpoint on a new machine instead of starting over.

Price Comparison: Is Nodus Really Cheaper?

Looking at list prices, Nodus is indeed cheaper on most GPUs. The gap is most pronounced on older or mid-tier cards like the A100, L40S, and L4, while it narrows considerably on the latest Blackwell series. The Nodus team ran a price comparison using three typical training jobs:

Example job	GPU-hours	Modal price	Nodus price
1×A100 80GB LoRA fine-tune for 6 hours	6	$14.99	$6.54
Eval sweep: 40 runs of 1×L4 for 2.5 hours each	100	$79.92	$43.00
8×H100 full fine-tune for 36 hours	288	$1,137.37	$748.80

These prices are based on data checked on October 12, 2026. Modal bills by the second, with GPU rates converted to hourly (H100 $3.9492, A100 80GB $2.4984, L4 $0.7992), while Nodus's pricing page shows hourly supply prices (H100 $2.60, A100 80GB $1.09, L4 $0.43). Note that Modal also charges for CPU cores and memory on top of GPU rates, whereas Nodus's nodus run --dry-run command can print the exact expected cost before launch.

One intuitive way to read this: an 8×H100 machine running continuously for a week (168 hours) costs $1,813 more at Modal's list price. If you only train a few short jobs per month, that gap is negligible relative to migration time; but if your GPUs run nearly every day, the cost compounds quickly.

List price is only the starting point—the Nodus team also ran real measurements. In two small pilot runs on October 11, 2026, they ran identical recipes with a Qwen2.5-0.5B model on a single NVIDIA L4 on both platforms. Nodus produced byte-identical weights in supervised fine-tuning but logged 67% lower cost; in continued pretraining, costs were 42.5% lower. However, these are only pilots, not a promise for your job. If you count one failed Nodus attempt, the fine-tuning savings drop to 24.7%, and the pretraining export took 11.0 minutes on Nodus versus 7.7 minutes on Modal.

Preemption Handling: Which Is Less of a Headache?

Both platforms require your training code to save state itself. The difference lies in who handles everything beyond saving.

Modal explicitly states that every Function can be preempted, that preemption is rare but becomes more likely with longer runtimes. When preemption occurs, Modal sends an interrupt signal and restarts the Function with the same inputs. GPU Functions cannot opt out, because the nonpreemptible flag is not supported for them (according to Modal's preemption docs). So you need to write checkpoints to a Modal Volume, look for the latest checkpoint on Function start, and add retries—exactly the pattern in Modal's official long-training example.

On Nodus, your script writes state to /nodus/state and loads it on start, and the platform handles the rest. It sets checkpoint cadence based on how often capacity is interrupted: saving at least four times within the expected runtime, with save time kept to about a tenth of the runtime. When a reclaim notice arrives, it requests an urgent checkpoint and simultaneously prepares a replacement machine. The replacement machine only starts once the old one is confirmed gone, and the state directory is restored, so you lose at most the work after the last committed checkpoint (according to Nodus's checkpoint guide).

Whichever platform you choose, checkpoint frequently. On an 8×H100 machine at Modal's list price, a restart that discards 3 hours of work costs 3×8×$3.9492 = $94.78. If you checkpoint every 30 minutes, the same restart costs at most $15.80.

Interrupt signals and checkpoints: On GPU cloud platforms, "preemption" refers to the platform forcibly reclaiming a running instance due to resource scheduling needs. Because the process is terminated directly upon preemption, any in-memory state that hasn't been persisted is lost. Training code must therefore periodically write model weights, optimizer state, learning rate scheduler state, and the current step to persistent storage (such as a Modal Volume or Nodus's /nodus/state directory). Checkpoint frequency requires a trade-off: too frequent slows training throughput, too sparse makes the time cost of a single interruption too high. A common industry rule of thumb is to keep checkpoint time within 5% of total training time.

Interruptible capacity and cost: Many cloud platforms offer "interruptible" (spot) instances at significantly lower prices than on-demand instances, at the cost of being reclaimable at any time. For long training jobs, using interruptible capacity can greatly reduce costs, but only if the training framework supports automatic checkpointing and recovery.

Long-Running Jobs: How Do You Break Through the 24-Hour Ceiling?

On Modal, a single Function invocation runs for at most 24 hours (according to Modal's timeout docs). Modal's long-training example covers longer runs by pairing a 24-hour timeout with up to 10 retries, each resuming from the last checkpoint in the Volume. That example says this gives a job roughly 10 days before a manual restart is needed.

Nodus Functions have the same 24-hour limit, but long training typically runs as a Job. A Job's wall-clock timeout is optional, and you can raise, lower, or remove it while the job runs. Paused time doesn't count. Recovery from a lost machine is limited by attempt count rather than the clock: 8 by default, and 3 for multi-node jobs.

The 36-hour run in the table takes just one command on Nodus. Check the estimate first, then launch with a cap slightly above it:

nodus run --dry-run --gpu H100:8 --expected-duration 36h -- torchrun train.py
nodus run --gpu H100:8 --checkpoint /nodus/state --max-cost 800 -d -- torchrun train.py

Multi-Node Training: Scale and Networking Compared

If you need more than 8 nodes or a guaranteed RDMA network, Modal is the better choice. Modal clusters support up to 32 nodes and 256 GPUs, with larger scales available by request. They feature 3,200 Gbps RDMA networking (6,400 Gbps on B300), and each node is gang-scheduled and physically co-located. Every node must use all of its GPUs (according to Modal's cluster docs).

Nodus's multi-node training is in Beta. It's available to all organizations without an application, but gangs are capped at 8 nodes and require a first credit purchase. By default, each node sits on a single provider's private network within the same region. You can allow cross-provider nodes, but in Beta their traffic over public addresses is unencrypted.

When a node is lost, Nodus keeps the surviving machines, replaces only the lost node, and restarts each rank from the latest checkpoint. It sets up the environment for torchrun, Ray, and verl, so your launcher finds peers without extra flags.

The rule they use: for fine-tuning or post-training with 2 to 8 nodes, either platform works; for 16-node pretraining runs, use Modal clusters.

RDMA and collective communication: The core bottleneck in multi-node training is inter-node communication. Traditional TCP/IP networks have high CPU overhead and latency when transferring large amounts of data such as gradients and activations. RDMA (Remote Direct Memory Access) lets the NIC read and write remote memory directly, bypassing the kernel protocol stack to achieve microsecond latency and extremely high bandwidth. Collective communication libraries like NCCL can run near line rate on RDMA networks. Modal's 3,200 Gbps RDMA network means AllReduce operations across 8 nodes are barely a bottleneck, whereas Nodus's cross-provider nodes in Beta communicating over public addresses may see significantly degraded latency and bandwidth.

Gang scheduling: Gang scheduling means all nodes of a multi-node job must be available at the same time before the job starts, otherwise the job queues. This avoids the resource waste of some nodes starting early and idling while waiting for the rest, and is a necessary mechanism for large-scale distributed training.

Coding Agents: Different Integration Approaches

Both platforms support coding agents running training jobs, but with different approaches. Nodus runs an MCP server that Claude Code, Codex, and Cursor can call directly. nodus mcp install sets it up on your machine, or you can add the hosted server. Every write returns a cost estimate as a dry run and only runs after confirmation, and the agent works within your account's projects and spending limits.

Modal, by contrast, offers agent skills. modal skills install places Modal's skills and docs into your project's .agents/ or .claude/ folder, and then your agent drives the Modal CLI and SDK. On spending, Modal's budgets set a monthly cap per workspace or environment, while Nodus can limit each run in dollars before it runs.

MCP protocol: MCP (Model Context Protocol) is an open protocol proposed by Anthropic to let AI coding assistants (such as Claude Code and Cursor) call external tools and services in a standardized way. Nodus's MCP server exposes capabilities like launching training jobs and querying costs, which agents can call directly in conversation. Every write operation returns a cost estimate as a dry run and requires confirmation before actually executing, which provides a safety boundary for agent automation.

Agent skills: Modal's "skills" mechanism works differently. It injects Modal's documentation and CLI usage into a project's .agents/ or .claude/ directory, and the agent reads the docs itself before driving the CLI and SDK. This approach is more flexible but lacks a mandatory pre-run confirmation step, and cost control relies on workspace-level monthly budget caps. The two approaches reflect the difference between the "tool invocation" and "knowledge injection" paradigms of agent integration.

When Is Modal the Better Fit?

In some scenarios, Modal is the better choice. Check these cases before migrating anything:

• You serve the model right next to your training code. Modal's web endpoints (@modal.web_endpoint, @modal.asgi_app) have no counterpart in the Nodus SDK, which serves models via nodus.InferenceEndpoint.
• Your code relies on modal.Dict, modal.Queue, or parameterized classes. Nodus doesn't currently support these.
• You need more than 8 nodes for a single job, or a guaranteed RDMA network between nodes.
• Your workload is bursty and latency-sensitive. Modal containers start in about a second, and its cold-start guide explains how to keep a warm pool.
• You want ready-made training libraries. Modal's training quickstart points to Modal Dojo, an open-source library for supervised fine-tuning and RL, while managed training on Nodus is still in Beta.

On B200 and B300, the list-price gap is much smaller, so for Blackwell work the choice comes down to features rather than price.

Migrating from Modal to Nodus: The Practical Steps

Migration usually just means changing imports, then replacing the Volume-heavy recovery pattern with a checkpoint path, a cost cap, and (if you want) interruptible capacity. Here's the same function on both platforms:

# Modal: checkpoints to a Volume, recovery via retries
@app.function(
    gpu="H100:8",
    volumes={"/ckpt": volume},
    timeout=24 * 60 * 60,
    retries=modal.Retries(initial_delay=0.0, max_retries=10),
)
def train(): ...

# Nodus: the same function after `import nodus`
@app.function(
    gpu="H100:8",
    timeout="24h",
    max_cost=600,               # hard dollar cap
    checkpoint="/nodus/state",  # save, and resume if the machine is reclaimed
    interruptible=True,         # allow cheaper interruptible capacity
)
def train(): ...

Inside train, load the model, optimizer, and step (if present in /nodus/state), and save at any time. App, .remote(), .map(), .spawn(), Image, Volume, and Secret keep their Modal names. Install with pip install nodus-compute, log in with nodus login, then nodus run app.py. The Modal user guide lists all the mappings and gaps.

FAQ

Does Modal code need changes beyond imports?

Usually small changes. Durations accept strings like "6h", but days are not a unit, and the image's Python minor version must match yours (same as Modal). Parameterized classes throw nodus.errors.Unsupported, so set them up in a @nodus.enter() hook.

Can I use Modal and Nodus at the same time?

Yes. A reasonable split is to serve on Modal web endpoints and run long training on Nodus, passing weights through Hugging Face or your own S3 bucket. Nodus Volumes can import directly from Hugging Face, git, URLs, and S3.

Can both platforms keep training data in Europe?

Yes. Modal lets you pin regions; pinning a Function to a broad region (like eu) costs 1.15× the base price, and a narrow region costs 1.75× (according to Modal's region selection docs). On Nodus, you pass a region class like eu or uk, and the run is placed only on offerings in those classes, each with its own list price.

How do the free tiers differ?

Modal's Starter plan includes $30 in compute credits per month. Nodus gives your first organization a one-time $30, issued after email and card verification, expiring 30 days from issuance. Organizations on starter credits alone also have tighter limits before their first top-up.

One-line Summary

Nodus vs Modal GPU cloud platform comparison: a full analysis of pricing, preemption handling, long-running training, and multi-node capabilities.

Paragraph Summary

This article compares two GPU cloud training platforms, Nodus and Modal. On price, Nodus has lower list prices on most GPUs, with the widest gaps on mid-tier cards like the A100, L40S, and L4 and narrower gaps on the Blackwell series; real measurements show Nodus costs 42.5% to 67% less, though it may take longer. On preemption, Modal is forcibly preemptible and requires manually implementing checkpoints and retries, while Nodus automatically manages checkpoint cadence and machine recovery. For long-running training, both cap a single invocation at 24 hours, but Nodus's Job mode can adjust timeouts dynamically and supports multi-node recovery. For multi-node training, Modal supports 32 nodes with guaranteed RDMA, while Nodus is capped at 8 nodes in Beta. Migration mainly involves import changes and recovery-pattern adjustments, and the two APIs are highly similar.