Continued pretraining on Nodus: 42.5% lower charges

Oct 11, 2026 - 9 min read

Nodus produced the same continued-pretraining model as Modal at 42.5% lower recorded execution charges. Both runs improved held-out perplexity by 21.8%, and the exported weight files matched byte for byte.

Result	Nodus	Modal
Successful-run charge	$0.121164	$0.21090282
Final perplexity, lower is better	16.425884	16.425884
Improvement over starting perplexity	21.8%	21.8%
Exported model weights	Identical	Identical

We ran this pilot with one small model, one seed and one accepted run per platform. Charges are recorded usage before credits. Nodus spent less time in the trainer but took longer to deliver the export: 11.0 minutes versus 7.7 minutes.

The task was continued pretraining of an existing model on raw text. We did not train from scratch. Our fine-tuning experiment was a separate study, and each experiment started independently from the same base checkpoint.

How we compared the runs

Continued pretraining updates a language model using additional text. We wanted to measure how much its predictions improved on held-out text and what each platform charged for that improvement.

We fixed the base checkpoint, prepared training data, recipe and evaluation logic, then ran the experiment on production Nodus and on Modal. Nodus recorded 57.5% of the Modal reference’s charge. Both runs reached the same score and produced identical weights.

Continued pretraining / Cost 42.5% lower execution charges Identical model weights. Successful attempts compared before credits.

Share of Modal referenceLower is better

NodusSuccessful attempt: 57.5%$0.121164 USD
ModalSuccessful attempt: 100.0%$0.21090282 USD

Because the saved parameters matched, a company comparing these runs does not have to decide whether a lower bill compensates for a different model. Nodus delivered the same learned result for less recorded usage cost.

We kept the pilot small, so the absolute charges are small too. Their ratio describes this job and does not guarantee pricing for a larger model or a longer run.

Perplexity before and after training

We evaluated language modeling with negative log-likelihood and perplexity. Lower perplexity means the model assigned higher probability to the held-out text under this evaluation method.

Quality measure	Starting model	After training, both platforms
Perplexity	21.000911	16.425884
Mean negative log-likelihood	3.044566	2.798858
Evaluated target tokens	286,056	286,056

Both platforms reduced perplexity by 21.8%. We evaluated 1,833 qualifying test paragraphs and counted every target token after each paragraph’s first token once. Long paragraphs passed through successive scoring windows, so evaluation did not stop at one training-length sequence.

We summed negative log-likelihood across target tokens, divided by the total token count and calculated perplexity from that average. This weights every token equally. Averaging paragraph perplexities would instead give short and long paragraphs equal weight.

After export, we compared the SHA-256 digests of the complete model-weights files. They matched. The final parameters were byte-identical, and the base revisions, input hashes, prepared training-token hashes and recorded library versions matched too.

Both platforms produced the quality improvement. Nodus’s advantage in this experiment was the lower recorded charge for the same result.

Where the jobs ran

The native job ran on production Nodus, which handled scheduling, GPU execution, billing and artifact export. Both training and evaluation used GPUs. Modal ran the reference recipe in its own environment.

Nodus used a pinned Nodus trainer through standalone Jobs. The Modal reference independently implemented the same recipe. Earlier diagnostics that ran Nodus trainer code on Modal appear separately in the campaign record and are excluded from the native result, as are local CPU runs.

We tested standalone Jobs. Managed TrainingJob workflows are Beta and were not evaluated.

Training time and export time

Nodus recorded 119.0 seconds inside the training loop, compared with 140.5 seconds on Modal. Its trainer runtime was 15.3% shorter.

The export took longer to arrive. From submission to local export, Nodus took 11.0 minutes and Modal took 7.7 minutes. The native job spent 215 seconds in its recorded boot phase and another 85 seconds in teardown.

Continued pretraining / Timing Training time and time to export Two clocks for the same job. Lower is better for both.

Training loopSeconds

Nodus: 119.0 s
Modal: 140.5 s

Submission to exportMinutes

Nodus: 11.0 min
Modal: 7.7 min

Nodus cost less in this run; Modal returned the export sooner. If your job has a strict deadline, weigh both results.

We used the same GPU class but did not fully match CPU limits, cache warmth or startup conditions. The Nodus clock waited for final billing before downloading the export, while we collected Modal usage separately. The runs also took place on different dates within the campaign. We did not run a randomized, simultaneous comparison.

These timings do not isolate an algorithmic speedup or establish a latency distribution. They show why we measure the wait for a usable artifact as well as the trainer’s runtime.

What the recorded charge includes

Nodus’s final compute charge includes the work around training:

Native charge segment	Recorded charge
Boot	$0.041332
Execution, evaluation and output upload	$0.063349
Teardown	$0.016483
Total	$0.121164

The Modal reference recorded $0.21090282, including collected CPU, memory, GPU and reported export-egress usage. Neither figure subtracts promotional credits.

Nodus’s 42.5% lower charge includes its longer boot and teardown in the final Job bill. We compared recorded usage rather than estimating cost by multiplying trainer time by an advertised hourly rate.

Both pretraining runs completed successfully. The full ledger also includes software diagnostics, a native fine-tuning failure and the corrected Modal fine-tuning export trial. These attempt sets cover different work, so we do not pool them into a platform savings claim.

We have not established whether any residual storage or control-plane charges posted later are final. The result compares recorded execution charges, not a closed all-in invoice or an estimate of long-term ownership cost. The measurement file preserves the exact charges and accounting boundaries.

Testing this with your own models

Continued pretraining takes experimentation with data and evaluation. When a run produces the same model for less money, the lower charge leaves more of the budget for that work. In this pilot, Nodus preserved the improvement in held-out text prediction and the trained weights while recording lower charges than Modal.

The extra wait for Nodus’s export is part of the decision. These results give companies a reason to test Nodus when the cost difference matters more than that observed delay.

For your comparison, fix the source model and data, score both exports with the same evaluator and inspect the costs attributable to each accepted result. Record startup and export time as well. That makes the comparison relevant to the workflow your product needs.

This experiment does not establish savings for foundation-model training, multi-GPU scale or every model architecture. The result we can report is 42.5% lower recorded charges for the same continued-pretraining model in this pilot.

Methodology and evidence

We ran this pilot on October 10 and 11, 2026, with one small model, one seed and one accepted result per platform. It is our own comparison. Both platforms used the same GPU class, but surrounding CPU and startup conditions were not fully matched. We did not repeat runs or calculate confidence intervals or statistical significance.

The execution method lists exact model revisions, hardware names, library versions, training settings and protocol deviations. The results include unrounded measurements, weight-file digests and the full campaign ledger. File checksums cover the downloadable evidence and charts.

Read the continued-pretraining evaluation protocol

We used the raw WikiText-2 configuration of WikiText. We kept paragraphs longer than 100 characters and selected the first 1,024 distinct training paragraphs in dataset order, excluding normalized exact matches against qualifying test text. Normalization folded case and whitespace; it did not remove every semantic overlap.

Both runs started independently from the same base checkpoint and trained full model weights for 128 steps. Neither started from random initialization or used the fine-tuned model from the companion experiment.

We evaluated all 1,833 qualifying test paragraphs and 286,056 target tokens. Scoring used full precision on GPUs, with a 256-token window and a stride of 128. Every token after a paragraph’s first token was scored once across successive windows.

We accumulated token-level negative log-likelihood and divided it by the total target count. Perplexity was the exponential of that mean. Both trained models improved over the untouched base and passed the predefined gate requiring native NLL to be no more than 1% relatively above Modal’s NLL. Their final NLL and weight-file digest matched exactly.

We did not adjust the recipe in response to held-out scores. The corpora are public, and we do not know whether they appeared in the base model’s original training data. The experiment does not establish a result on private enterprise text or an unseen domain.

Read the controls, deviations and campaign accounting

The base revision, input files, prepared training tokens, seed, recipe and recorded library versions matched. We did not capture the native effective CPU limit in a way equivalent to Modal’s limit. Host-visible CPUs did not establish a dedicated allocation. We did not control cache warmth, startup or host conditions, or randomize run order.

The native pretraining job launched while the fine-tuning job was still training, earlier than the frozen plan specified. They were separate jobs, but we did not measure possible shared contention. The native experiment also used standalone Jobs instead of the planned managed training submissions and completed despite an admission dry-run discrepancy. We have kept these protocol deviations in the record.

Savings use 100 × (1 − N / M), where N and M are the recorded Nodus and Modal charges. The chart uses this experiment’s Modal charge as its 100% reference; it does not project a bill for another training job.

The campaign recorded $1.19670630 across eight paid attempts within a $5 authorization, including fine-tuning, pretraining, corrections and software diagnostics. Each platform’s subtotal covers different work, so the subtotals cannot be used to calculate platform savings. Charges posted later remain outside the finalized execution records.

After we collected artifacts, checks showed zero native live allocations and pending holds, no remaining native nodes, and all five Modal apps stopped. An allocation-detail endpoint error prevented us from checking each allocation’s deletion timestamp. Independent counts, node states and final charges supplied cleanup evidence.

We have published sanitized measurements and source digests from our own runs. They are not an independent audit, unredacted invoices or a public distribution of the model files. A broader study would repeat runs, randomize starts, capture equivalent resource limits and close a consistent billing window.

To try continued pretraining on Nodus, follow the Jobs guide, set a spending limit and use the usage and costs guide to inspect the run.

The companion article covers fine-tuning with identical weights at 67% lower successful-run charges.