Oct 12, 2026 - 9 min read

Pick Modal if your training jobs are short, sit next to web endpoints, or need one large RDMA cluster. Pick Nodus if your runs last hours or days and the bill matters most. The Python API is nearly the same, listed GPU rates are lower on most cards, and when a machine is reclaimed Nodus restores your checkpoint on a new one rather than starting over.

We build Nodus, so we have tried to keep this fair. Every Modal fact links to Modal’s own docs or pricing page, the costs are worked out in the open, and there is a section on where Modal wins.

How do Nodus and Modal compare at a glance?

	Modal	Nodus
How you pay	Per second, plus a monthly plan: Starter $0, Team $250	Prepaid credits. A funded hold is placed before work starts and renewed every 5 minutes
GPUs	T4 to B300, up to 8 per container	RTX 3070 to B300, up to 8 per machine
Preemption	GPU Functions are preemptible by default, with no opt-out; the call restarts on the same input	You choose whether a run may use interruptible capacity; your state directory is checkpointed and restored on the replacement machine
Longest single run	24 hours per Function call; longer runs resume through retries	Functions: 24 hours. Jobs: an optional wall-clock timeout you can raise or remove while the job runs
Multi-node	Clusters of up to 32 nodes and 256 GPUs over RDMA	Beta: up to 8 nodes, after your first credit purchase
Cold starts	Containers boot in about a second, before your imports and model loading	The estimate shows the expected start time before you run
Spend limits	Monthly Workspace budget and spend limit; Environment budgets on Team and Enterprise	A hard dollar cap on each run plus Budgets that block new work
Coding agents	Agent skills installed with modal skills install	An MCP server for Claude Code, Codex and Cursor; writes show a dry run first
Free credit	$30 of compute every month on Starter	$30 once for a new org, valid for 30 days

Sources: Modal pricing, preemption, timeouts, GPUs, Clusters, cold starts, budgets and modal skills; the Nodus pricing page and the Nodus guide for Modal users. Checked October 12, 2026.

Is Nodus cheaper than Modal for training?

On listed rates, yes for most GPUs. The gap is widest on older and mid-range cards like the A100, L40S and L4, and it nearly closes on the newest Blackwell parts.

Here are three ordinary training jobs priced at each platform’s listed GPU rate:

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

Prices checked October 12, 2026: Modal’s per-second GPU rates converted to hourly (H100 $3.9492, A100 80 GB $2.4984, L4 $0.7992) and the hourly supply prices on the Nodus pricing page (H100 $2.60, A100 80 GB $1.09, L4 $0.43). Modal bills CPU cores and memory on top of its GPU rates, and on Nodus nodus run --dry-run prints the expected cost of your exact run before anything starts.

A useful way to read the gap: one 8 x H100 machine kept busy for a week (168 hours) comes to $1,813 more at Modal’s listed rate. If you train a few short jobs a month, the gap is small next to the time a move takes. If your GPUs are busy most days, it adds up fast.

Listed rates are only a starting point, so we also measured. In two small pilots on October 11, 2026, we ran the same recipe on both platforms with Qwen2.5-0.5B on one NVIDIA L4, one seed and one accepted run each. Nodus produced byte-identical weights for 67% lower recorded charges in supervised fine-tuning and 42.5% lower in continued pretraining.

Those are pilots, not a promise for your job. Counting a failed Nodus attempt, the fine-tuning saving drops to 24.7%, and the pretraining export took 11.0 minutes on Nodus against 7.7 on Modal.

What happens when a GPU is preempted mid-run?

On both platforms your training code has to save its own state. The difference is who handles everything around that save.

Modal says every Function can be preempted, that preemptions are rare, and that the chance grows with run length. When one happens, Modal sends an interrupt signal and restarts the Function on the same input. GPU Functions can’t opt out, because the nonpreemptible flag is not supported for them (Modal preemption docs). So you write checkpoints to a Modal Volume, look for the latest one when the Function starts and add retries, which is the pattern in Modal’s own long-training example.

On Nodus your script writes its state to /nodus/state and loads it on start, and the platform does the rest. It sets the checkpoint cadence from how often the capacity is interrupted: at least four checkpoints over the expected run time, with saving kept to about a tenth of it. When a reclaim notice arrives, it asks for an urgent checkpoint and prepares a replacement machine at the same time. The replacement starts only once the old machine is provably gone, with the state directory restored, so you lose at most the work since the last committed checkpoint (checkpoints guide).

Whichever you pick, checkpoint often. On one 8 x H100 machine at Modal’s listed rate, a restart that throws away 3 hours of work costs 3 x 8 x $3.9492 = $94.78. With a checkpoint every 30 minutes, the same restart costs at most $15.80.

Can one training run last longer than 24 hours?

Not as a single call on Modal. A Modal Function call runs for at most 24 hours (Modal timeouts). 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 a Volume. The example says that gives a job about 10 days before you restart it by hand.

Nodus Functions have the same 24-hour ceiling, but long training usually runs as a Job. A Job’s wall-clock timeout is optional, and you can raise, lower or remove it while the job runs. Time spent suspended does not count. Recovery from lost machines is limited by attempts rather than a clock: 8 by default, 3 for multi-node jobs.

The 36-hour run from the table is one command on Nodus. Check the estimate first, then launch it with a cap a little above the estimate:

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

Which is better for multi-node training?

Modal, if you need more than 8 nodes or a guaranteed RDMA fabric. Modal Clusters run up to 32 nodes and 256 GPUs per cluster, with larger clusters on request. They come with a 3,200 Gbps RDMA network (6,400 Gbps on B300), and every node is gang-scheduled and physically colocated. Each node has to use all of its GPUs (Modal Clusters).

Multi-node training on Nodus is in Beta. It is on for every organization with no access request, but gangs top out at 8 nodes and need a first credit purchase. By default every node sits on one provider’s private network in one region. You can allow nodes across providers, but in the Beta their traffic over public addresses is not encrypted.

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

The rule we use: for fine-tuning or post-training on 2 to 8 nodes, either platform works. For a 16-node pretraining run, use Modal Clusters.

Can a coding agent run training jobs on each?

Yes, 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 comes back as a dry run with a cost estimate and only runs once confirmed, and the agent works within your account’s projects and spending limits.

Modal ships agent skills instead. modal skills install puts Modal’s skills and documentation into your project’s .agents/ or .claude/ folder, and your agent then drives the Modal CLI and SDK. For spending, Modal’s budgets are monthly caps per workspace or environment, while Nodus can cap each run in dollars before it starts.

When is Modal the better choice?

Modal is the better pick in these cases, so check them before you move anything:

• You serve models next to your training code. Modal web endpoints (@modal.web_endpoint, @modal.asgi_app) have no equivalent in the Nodus SDK, which serves models through nodus.InferenceEndpoint instead.
• Your code depends on modal.Dict, modal.Queue or parametrized classes. Nodus supports none of them today.
• You need more than 8 nodes in one job, or a guaranteed RDMA network between them.
• Your workload is bursty and latency-sensitive. Modal containers boot in about a second, and its cold start guide explains how to keep warm pools.
• You want a ready-made training library. 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 listed gap is much smaller, so for Blackwell work the choice comes down to features rather than price.

How do you move a Modal training function to Nodus?

Change the import, then trade the Volume-and-retries recovery for a checkpoint path, a cost cap and, if you want it, interruptible capacity. Here is the same function on both platforms:

# Modal: checkpoints in a Volume, retries to resume
@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 cap in USD
    checkpoint="/nodus/state",  # saved, then restored if the machine is reclaimed
    interruptible=True,         # allow cheaper interruptible capacity
)
def train(): ...

Inside train, load the model, optimizer and step from /nodus/state if they exist, and save there as you go. App, .remote(), .map(), .spawn(), Image, Volume and Secret keep their Modal names. Install with pip install nodus-compute, sign in with nodus login, then nodus run app.py. The Modal users guide lists every mapping and gap.

FAQ

Does Modal code need changes beyond the import?

Usually small ones. Durations accept strings like “6h”, but days are not a unit, and the image’s Python minor version must match yours, as on Modal. Parametrized classes raise nodus.errors.Unsupported, so set them up in an @nodus.enter() hook instead.

Can I use Modal and Nodus together?

Yes. One sensible split is serving on Modal web endpoints and running 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 I keep training data in Europe on both?

Yes. Modal lets you pin a region, and pinned Functions cost 1.15x base prices for a broad region like eu and 1.75x for a narrow one (Modal region selection). On Nodus you pass region classes such as eu or uk, and the run is placed only on offerings in those classes, each at its own listed rate.

How do the free credits differ?

Modal’s Starter plan includes $30 of compute every month. Nodus gives your first org $30 once, after your email and card are verified, and it expires 30 days after it is issued. Orgs on starter credit alone also have tighter limits until the first top-up.

Tags:

• training
• modal
• comparisons
• pricing

Continued pretraining on Nodus: 42.5% lower charges