Nov 12, 2026 - 10 min read

Fireworks AI is the better choice for a LoRA fine-tune of a model it already hosts that you plan to serve on Fireworks, because you pay per training token and never provision anything. Nodus is the better choice for everything that needs GPU time, since it lists the NVIDIA H100 at $2.60 per hour against $8.00 on Fireworks AI’s dedicated training rate card, and resumes a lost run from its latest checkpoint. Your own trainer, a model outside the Fireworks serverless list and full fine-tuning all fall on that side.

We make Nodus, so we price the same jobs on both platforms below, show the arithmetic once, link every Fireworks AI fact to its own pricing or docs page, and say plainly where Fireworks AI wins.

How do Nodus and Fireworks AI compare at a glance?

They sell different things. Fireworks AI is an inference platform that also runs training: you send data or a Python loop, it runs the GPU work on its side and serves the result. Nodus is an AI compute platform: you bring a training script or pick a managed recipe, and it runs that on the cheapest capacity that will finish it, with checkpoints and recovery.

	Fireworks AI	Nodus
Fine-tuning options	Serverless Training (shared pool, LoRA only) and Dedicated Training (provisioned trainers, LoRA or full)	Managed TrainingJob runtimes (Beta: SFT, DPO, ORPO, KTO, GRPO, distillation), or any script as a Job
How training is billed	Serverless: per 1M tokens you train, prefill and sample. Dedicated: per GPU-hour	Per GPU-hour from prepaid credits, with a dollar cap per run
Example price	$4.103 per 1M train tokens on Qwen 3.8 27B; H100 $8.00/hr dedicated	H100 SXM $2.60/hr, L40S $0.793/hr
Models	The serverless list, or models with a dedicated training shape	Hugging Face models by URI, pinned to a commit, or weights in a Volume
Checkpoints and recovery	Serverless: in-run snapshots, limited cross-run resume. Dedicated: explicit checkpoint and resume	Full checkpoints with optimizer state; a replacement attempt starts from the latest one
Serving the result	Serverless adapters (Preview, one base model) or a dedicated deployment billed per GPU-second	Download the weights with nodus cp; hosted inference (Beta) covers catalog models
Agent support	Training Agent Skills for Claude Code, Cursor, Codex and OpenCode	Hosted MCP server for Claude Code, Codex and Cursor
Free tier	A time-limited free SFT offer on one model	None; prepaid credits

Checked November 12, 2026 on Fireworks AI pricing, the Fireworks Training API overview, Serverless Training, Specialized Model Inference and Agent Skills docs, the Nodus pricing page, the Nodus training guide, inference guide and agent setup.

One change matters if you read older comparisons. The Fireworks pricing page still shows Managed Training from $0.50 per 1M tokens, but its migration guide says managed SFT and DPO no longer accept new jobs. New work goes through the Training API, which is what we price here.

How does Fireworks AI charge for fine-tuning?

Fireworks AI has two meters, and which one you pay depends on your model. Serverless Training bills per 1M tokens: train tokens for every token passed through the backward pass, plus prefill and sample tokens when your loop generates text. It is LoRA only and limited to the serverless model list, which on the pricing page today runs from Qwen 3.6 35B A3B at $2.14 per 1M train tokens to Kimi K3 at $32.55.

Dedicated Training is for full fine-tuning, larger runs and models outside that list. It bills per GPU-hour at the same rates as Fireworks On Demand serving: $8.00 for an H100 or H200, $13.00 for a B200 and $15.00 for a B300. The Dedicated Training docs ask you to request access first, and say the trainer and any sampling deployment are separate resources with separate bills. You pick a “training shape”, which fixes the GPU layout for a model and method.

Small models land on the GPU-hour meter. No 8B model appears in the serverless training rates on the pricing page, so an 8B LoRA today runs on a dedicated shape such as the qwen3-8b-128k example in the training shapes docs.

Is Nodus cheaper than Fireworks AI per GPU-hour?

Yes, at every GPU both list. Fireworks AI publishes one rate card for dedicated training and serving, and Nodus publishes its own on the pricing page.

GPU	Fireworks AI, per hour	Nodus, per hour	Nodus difference
H100	$8.00	$2.60	67.5% less
H200	$8.00	$3.593	55.1% less
B200	$13.00	$5.50	57.7% less
B300	$15.00	$6.943	53.7% less

Prices checked November 12, 2026 on Fireworks AI pricing (GPU rates) and the Nodus pricing page, where GPU rates are listed as the hourly supply price.

The gap is widest on the H100, the GPU most fine-tuning runs use.

Take a full fine-tune that needs 8 x H100 for 10 hours, or 80 GPU-hours. On Fireworks AI Dedicated that is 80 × $8.00 = $640.00. On Nodus it is 80 × $2.60 = $208.00, or $432 less. Both bills count the time GPUs are allocated, including checkpoint writes; the Fireworks cost estimator notes that queue wait before allocation is not billed.

Same hardware, same hours: $432 stays in your budget on Nodus.

Smaller jobs do not need an H100 at all. The Nodus sft runtime preset runs a QLoRA fine-tune of Qwen3-8B on one L40S, RTX A6000 or A100 80GB. Ten hours on an L40S is 10 × $0.793 = $7.93. It will run slower than an H100, so measure before you compare it with a faster card.

What does the same LoRA job cost per token and per GPU-hour?

Per-token pricing is easy to predict, and hourly pricing is cheaper when the job runs fast. The only way to choose is to convert one into the other.

Our worked example: LoRA SFT on a 20M-token dataset for 3 epochs, which is 60M training tokens. The dataset size is our assumption; swap in your own. We count only the train meter, so evaluation sampling would add prefill and sample charges on Fireworks AI.

• Qwen 3.8 27B on Fireworks AI Serverless: 60 × $4.103 = $246.18.
• Qwen 3.6 35B A3B on Fireworks AI Serverless: 60 × $2.14 = $128.40.

Divide each bill by the $2.60 Nodus H100 rate to get the GPU-hours it buys: $246.18 ÷ $2.60 = 94.7 H100-hours, and $128.40 ÷ $2.60 = 49.4 H100-hours.

If your run finishes inside these hours on Nodus, hourly is the cheaper meter.

Now turn hours into a speed you can test. To finish 60M tokens in 94.7 H100-hours, the 27B job has to average 60,000,000 ÷ (94.7 × 3,600), about 176 tokens per second per H100. The 35B A3B job has to average about 338 tokens per second per H100 to finish in 49.4 hours.

We have not benchmarked these models, so we are not claiming either speed. Measure it.

How do you decide which meter your job belongs on?

Run a short trial, read the speed, and do one division. On Nodus, nodus describe tj/<name> shows the step, loss and tokens per second while a TrainingJob runs, per the training guide. A model without a runtime preset gets the default single-GPU resources, so set spec.resources when you need an H100.

The rule we use:

1. If your model is on the Fireworks serverless list, LoRA is enough, and you will serve on Fireworks, start there.
2. Otherwise compute break-even speed: total training tokens ÷ (Fireworks bill ÷ $2.60 × 3,600). If your trial on one Nodus H100 beats it, train on Nodus.
3. If you need full fine-tuning or a model outside the list, you are on GPU-hours either way. Compare the rate cards directly; the same H100 hour is $8.00 on Fireworks AI and $2.60 on Nodus.

For more GPU options and break-even speeds, see our guide to the cheapest way to fine-tune Llama on an H100.

What happens when a fine-tuning run fails halfway?

On an hourly bill, a failure costs the work since the last checkpoint, so how checkpoints work matters more than the rate. Fireworks AI’s Training API overview says it handles preemption recovery and job resume for Dedicated Training. For Serverless, the same page lists in-run snapshots with limited cross-run resume, and the serverless docs say training checkpoints stay loadable for about 30 days.

On Nodus, the managed runtimes write full checkpoints with optimizer, scheduler and RNG state, per the training guide. If a machine stops sending heartbeats for 60 seconds on shared capacity, the attempt is declared lost and a replacement starts from the latest checkpoint, per attempts and recovery. Each TrainingJob has a maxCostUSD cap. Reaching it suspends the run rather than failing it, and raising the cap resumes from the checkpoint:

$ nodus patch tj/support-sft --type merge -p '{"spec":{"maxCostUSD":"40"}}'

Your own script gets the same recovery if it saves its model, optimizer and progress under the state directory Nodus provides.

Where is Fireworks AI the better choice?

Fireworks AI wins whenever serving is the main job and training is a step on the way. These are real advantages.

• You want the fine-tuned model served without running anything. Fireworks AI deploys a trained LoRA by live merge or multi-LoRA, per its deployment docs, and its pricing page says serving a trained model costs only the deployment’s GPU-seconds. Nodus hosted inference is Beta and its docs cover catalog open-weight models, not your own adapters.
• Your model is on the serverless list. There is no trainer to size, no idle charge, and the bill is tokens times a published rate.
• You want serverless adapters. Specialized Model Inference (Preview) loads up to three LoRA adapters per account on GLM 5.3 Flash and bills per token at the base model’s price.
• You need specific certifications on file. The Fireworks pricing page lists zero data retention by default, SOC 2 Type II, ISO 27001 and HIPAA with a BAA. Check any platform, ours included, against your own list.

You can also split the work. The Fireworks docs describe importing an adapter trained elsewhere as a Hugging Face PEFT folder, rank 4 to 64, or uploading a custom model for a dedicated deployment. Training on Nodus and serving on Fireworks AI is a valid setup.

How do you move a Fireworks AI fine-tuning job to Nodus?

The data is the main change. Fireworks AI SFT files use OpenAI chat format, one messages array per line, per its SFT cookbook. The Nodus sft runtime takes prompt and completion rows. We wrote and tested this converter on a three-row sample; it keeps single-turn rows and reports the rest:

import json, sys

kept = skipped = 0
with open(sys.argv[1]) as src, open(sys.argv[2], "w") as dst:
    for line in src:
        msgs = json.loads(line)["messages"]
        system = [m["content"] for m in msgs if m["role"] == "system"]
        turns = [m for m in msgs if m["role"] != "system"]
        if [m["role"] for m in turns] != ["user", "assistant"]:
            skipped += 1
            continue
        prompt = "\n\n".join(system + [turns[0]["content"]])
        dst.write(json.dumps({"prompt": prompt, "completion": turns[1]["content"]}) + "\n")
        kept += 1
print(f"kept {kept}, skipped {skipped} multi-turn or tool rows")

Then install the CLI, upload the file and launch. Commands come from the training guide and Volumes guide:

$ pip install nodus-compute
$ nodus login
$ nodus create volume support-chats --size 100Gi
$ nodus volume put support-chats ./chats.jsonl /chats.jsonl
$ nodus apply -f sft.yaml --dry-run -o yaml
$ nodus apply -f sft.yaml

sft.yaml is the training guide’s LoRA example with columns: {prompt: prompt, completion: completion}. The dry run prints the estimated cost before anything is charged. When it finishes, nodus cp tj/support-sft:outputs/adapter/adapter_model.safetensors ./adapter_model.safetensors downloads the adapter.

FAQ

Who are Fireworks AI’s main competitors for fine-tuning?

Together AI is the closest, since it also bills per training token and serves the result. Nodus, Modal and RunPod bill for GPU time and run your own trainer. Our Together AI alternatives post prices one job across all of them.

Is Fireworks AI or Modal better for fine-tuning?

They solve different problems. Modal runs your Python on GPUs billed per second, and Fireworks AI runs the training loop for you on its own hardware. For an hourly option, the Nodus pricing page lists the H100 at $2.60 against $3.949 for Modal.

Can Nodus serve a model I fine-tuned?

Not as a hosted endpoint today. Nodus inference (Beta) serves catalog models, so you download the adapter or merged weights and serve them with your own code, or import them into a platform that hosts adapters.

Do I need an H100 to fine-tune an 8B model?

No. The Nodus sft presets run QLoRA on Qwen3-8B on a single 48GB or 80GB card, and our platform comparison covers which card suits which model size.

Tags:

• training
• fine-tuning
• comparisons
• fireworks-ai
• pricing

A100, H100, H200, B200, B300: which GPU should you pick?

What are the best open-source sandboxes for AI agents?