Fine-tuning on Nodus: 67% lower charges

Oct 11, 2026 - 9 min read

Nodus produced the same fine-tuned model as Modal for about one-third of the recorded execution charge. Both platforms returned identical trained weights, reached the same accuracy and delivered a verified export in roughly five minutes.

Result	Nodus	Modal
Successful-run charge	$0.048696	$0.14746756
Final accuracy	91.74%	91.74%
Correct answers	800 / 872	800 / 872
Exported model weights	Identical	Identical

We ran this pilot with one small model, one seed and one accepted run per platform. The 67% reduction compares successful attempts before credits. We also had a failed Nodus attempt. The two Nodus attempts together cost 24.7% less than the corrected Modal reference.

This article covers supervised fine-tuning, one form of post-training. Our continued-pretraining experiment tested a different task. Each experiment started independently from the same base model.

How we compared the runs

We wanted to compare what each platform charged for a model that passed the same quality checks and could be exported for use. We fixed the starting checkpoint, prepared training data, training recipe and evaluation logic, then ran the experiment on production Nodus and on Modal.

Nodus’s successful attempt recorded 33.0% of the Modal reference’s charge. These charges cover work around training too, including startup, evaluation and artifact export, within the billing boundaries described below.

Fine-tuning / Cost 67% lower execution charges Identical model weights. Successful attempts compared before credits.

Share of Modal referenceLower is better

NodusSuccessful attempt: 33.0%$0.048696 USD
NodusSuccessful + failed attempt: 75.3%$0.111004 USD
ModalCorrected reference: 100.0%$0.14746756 USD

We compared the SHA-256 checksum of each complete exported model-weights file. The digests matched, as did the base revisions, input hashes, prepared training-token hashes and recorded library versions.

Two models can score equally on a test set while having different parameters. Here, the exported weights matched byte for byte. The lower recorded charge bought the same trained model.

Accuracy before and after fine-tuning

The task was sentiment classification: given a text, the model had to generate the correct sentiment label. Invalid labels counted as wrong.

Quality measure	Starting model	After fine-tuning, both platforms
Accuracy	87.96%	91.74%
Correct answers	767 / 872	800 / 872
Valid output labels	100%	100%

Both platforms gained 3.78 percentage points of accuracy, answering 33 more examples correctly out of 872. Nodus recorded the lower charge for that same improvement.

We set the task and acceptance criteria before the final evaluation and did not change the recipe in response to held-out scores. Both runs exceeded the predefined accuracy and output-validity gates, with exactly matching final scores.

This result supports a cost advantage for the tested job. It does not show that Nodus’s trainer learned a better model than Modal’s implementation. They learned the same model.

Where the jobs ran

We submitted the Nodus job to the production platform, which handled scheduling, GPU execution, billing and artifact export. Training and evaluation both ran on GPUs. Modal ran the comparison recipe in its own environment.

Nodus used its pinned trainer through standalone Jobs. The Modal reference used an independent implementation of the same recipe. Earlier diagnostics that ran Nodus trainer code on Modal appear separately in the evidence and are excluded from the native comparison, as are local CPU experiments.

Managed TrainingJob workflows are Beta and were not the interface we tested. Preference optimization, reinforcement learning and larger distributed training runs need separate measurements.

Training time and export time

Nodus recorded 112.8 seconds inside the trainer, compared with 174.5 seconds on Modal. That is a 35.4% shorter trainer runtime.

The wait for an export was much closer: 4.8 minutes from submission on Nodus and 4.9 minutes on Modal. Nodus’s lower charge came with similar observed delivery time for this job.

Fine-tuning / Timing Training time and time to export Two clocks for the same job. Lower is better for both.

Training loopSeconds

Nodus: 112.8 s
Modal: 174.5 s

Submission to exportMinutes

Nodus: 4.8 min
Modal: 4.9 min

Trainer runtime measures the training loop. Delivery time also includes waiting, setup, evaluation and retrieving the artifact. Both affect where it makes sense to run an experiment.

We used the same GPU class on each platform, but did not fully match effective CPU limits or startup conditions. The Nodus export clock also waited for final billing; we retrieved Modal usage separately. These timings describe the runs we observed. They do not isolate an algorithmic speedup or establish a latency advantage across repeated runs.

What the failed attempt cost

Our first native attempt failed before training because the benchmark wrapper assumed the wrong output path. We fixed the wrapper and reran it with the same model and training recipe.

Including that failure changes the comparison:

Fine-tuning execution	Recorded charge
Nodus successful attempt	$0.048696
Nodus failed wrapper attempt	$0.062308
Nodus, both attempts combined	$0.111004
Modal corrected reference	$0.14746756

Nodus still cost 24.7% less. This charges both native attempts against one accepted Modal reference. It describes the recorded cost of getting this export, not a typical retry rate.

We also corrected the Modal reference. An earlier trial used smaller artifact-transfer chunks, which added export overhead. We changed that setting to match the other trials and used the corrected run for the comparison. The original trial’s $0.24482145 charge remains in the campaign ledger and is excluded from the headline savings calculation.

Nodus’s final Job charges include boot, execution, evaluation, output upload and teardown. Collected Modal usage includes CPU, memory, GPU and reported export egress. Neither figure subtracts promotional credits.

We have not established whether any residual storage or control-plane charges posted later are final. The figures are recorded execution charges, not a closed invoice or an estimate of total cost of ownership. The measurement file contains exact measurements from the usage records and every paid attempt.

Testing this with your own models

A fine-tuning budget pays for preparing better examples, trying recipes and checking whether a model meets a product requirement. Failed attempts draw from it too. In this pilot, Nodus delivered the same model quality at a lower recorded cost, even after its first failure, with a similar wait for the export.

That gives companies a reason to test Nodus on their own fine-tuning jobs. The charges here are small because we kept the experiment small. Larger models, longer runs and different resource configurations could change the result, so these figures do not support an annual savings projection.

For your comparison, fix the starting model and training data, define an acceptance test, and compare the exported results with the charges attributable to each one. Record turnaround time, especially if the job has a deadline. That will tell you whether the cost advantage we measured carries over to your pipeline.

Methodology and evidence

We conducted this comparison in October 2026. The accepted native and corrected Modal fine-tuning runs were recorded on October 11. This is our own pilot, with one seed and one accepted result per platform, using a small model and the same GPU class. We did not estimate run-to-run variance or statistical significance.

The execution method lists exact hardware, model revisions, library versions, training settings and protocol deviations. The measurement file includes unrounded scores, timing definitions, export digests and all eight paid attempts across both experiments and diagnostics. Checksums cover the downloadable records and figures.

Read the fine-tuning evaluation protocol

We used SST-2, selecting 1,024 training examples per label deterministically. We removed normalized exact duplicates within training and against the held-out split. Normalization folded case and whitespace, but could not detect every semantically similar example.

We trained full model weights for 160 steps on 2,048 examples. All 872 examples in the public validation split were excluded from this experiment’s training. The starting model and both final models used the same scoring logic.

The evaluator requested greedy answers with sampling disabled and a four-token output limit. Invalid labels counted as wrong. The model could choose any output tokens; the evaluator did not force a choice between the two labels or truncate inputs to the training sequence length.

The acceptance gate required at least 80% accuracy, at least 99% valid labels, and Nodus accuracy within two percentage points of Modal. Both platforms reached 91.7431% accuracy and 100% valid labels, with matching complete weight-file digests.

We did not tune the recipe against held-out results. The corpus is public, and we do not know whether it appeared in the base model’s original training data. This test does not establish performance on unseen enterprise data or a general quality advantage over other training methods.

Read the execution controls and accounting boundaries

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

The campaign used standalone Jobs instead of the managed training submissions in the original plan. It also had an admission dry-run discrepancy and an overlapping native pretraining launch. The accepted jobs completed, but those deviations remain in the downloadable method; we do not count them as satisfied controls.

Savings use 100 × (1 − N / M), where N and M are the recorded Nodus and Modal charges. The chart sets this experiment’s corrected Modal reference to 100%. It makes no pricing assumption about another training job.

The combined fine-tuning and continued-pretraining campaign recorded $1.19670630 across eight paid attempts, within a $5 authorization. Those attempts include 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 cleanup, 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 the cleanup evidence.

We have published sanitized records and digests from our own measurements. They are not an independent audit, an unredacted invoice bundle or a collection of the trained weights.

To try your own fine-tuning experiment on Nodus, follow the Jobs guide, set a spending limit and use the usage and costs guide to inspect consumption. Compare the exported model against your acceptance test.

The companion article covers identical weights at 42.5% lower recorded charges in continued pretraining.