A post-trained open-weight model pays back only above a spending threshold on your LLM inference cost: about $5K a month of replaced frontier-API spend for a single workflow, and less as you add workflows.
The pull is obvious. Claude Fable 5.1 and GPT-6 Astra both list at $10 per million input tokens and $50 per million output tokens. A hosted Nemotron 3.5 Lightning, a 30B open-weight model with 3B active parameters, runs about $0.10 and $0.25. For a million tokens in and a million out, that is $60 against roughly $0.35.
The catch is that the cheap tokens come with fixed costs: a first build of about $60K in engineering, data and compute, then about $44K a year to keep the model current as new open-weight bases ship. Two levers decide whether that pays off: how many workflows you move, and how much token spend each one carries. This post walks through the process, the costs, and a grid that shows where each combination lands.
These figures assume a scrappy, AI-native team; conventional enterprises starting from scratch should expect higher costs, as explained in the cost section.
If you already have a candidate workflow, a post-training assessment can pressure-test whether the spend clears the bar.
What counts as a workflow
A workflow is one narrow task with its own eval and its own tuned model: KYB review, ticket triage, contract clause extraction. It is the unit this whole analysis counts.
Three boundaries matter:
- One task, one eval. If you cannot write a test that says what a correct answer looks like, you do not have a workflow yet.
- Separate models or adapters. Hosted services can run several LoRA adapters on one base model. That shares serving and refresh work, but each task still needs its own data and verifier.
- The asset is not the weights. Open-weight bases get replaced every few months. The dataset, gold eval set and verifiers carry forward to the next base. Reusing it is where the second workflow gets cheaper.
When post-training is the wrong answer
Skip it unless all of these hold:
- The task is narrow and stable, and requirements will not change monthly.
- You can write an eval with known correct answers, or a verifier a machine can run.
- You already have, or can get, examples of good output from your own data.
- The workflow carries more than about $4–5K a month of frontier-API spend.
- No cheaper closed model already passes your eval sufficient for your product.
Red flags: output quality is judged by taste rather than a test, the task changes every sprint, or the workflow is a one-off. In those cases a prompt and a frontier model is the cheaper answer.
LLM API cost comparison: the baseline you’re replacing
Compare against the cheapest closed model that passes your eval, not the flagship. Prices per million tokens, as of November 12, 2026:
Bar width is logarithmic so flagship and open-weight rates fit on one scale. Nemotron 3.5 Lightning is the lowest price.
Hosted Nemotron 3.5 Lightning is listed on CoreWeave’s W&B Inference at $0.10 input, $0.25 output and $0.05 cached on one page, and at $0.07, $0.20 and $0.04 on another. This post uses the higher figures, at 262K context. It serves at up to 250 tokens per second per stream.
Fable 5.2 and Mythos 5.2 also offer an optional fast mode that speeds token generation by up to 2.5 times, at $16 per million input tokens and $80 per million output tokens. A million tokens in and a million out is $96 on fast mode, against $60 on standard Fable or Astra list prices and about $0.35 on hosted Lightning. The same token volume costs about 1.6 times as much on fast mode as on the standard list rates this post uses for the ROI grid, so a workflow already on fast mode clears the roughly $5K break-even at lower volume.
One more push toward open weights: OpenAI is retiring its self-serve fine-tuning platform, with all remaining customers losing access on January 6, 2027, so closed-model tuning is a shrinking option.
How to estimate your LLM inference cost
Your position on the ROI grid depends on one number per workflow: what it would cost at Fable or Astra list prices. What drives that bill is token volume times the model’s price per token, with output tokens, cache hit rate, and batch eligibility moving it most. To get it:
- Pull 30 days of API logs and tag each call by workflow.
- Sum input, output and cached tokens per workflow.
- Price them at the baseline model’s rates, with your actual cache hit rate.
- Note which workflows are batch-eligible, since batch halves the baseline bill.
A useful reference: $10K a month at Fable or Astra list prices is about 500M input and 100M output tokens, roughly 600M tokens.
Caching moves the baseline. If half your input tokens are cache reads, the $10K example falls to about $7.6K on Fable and $7.75K on Astra.
To check your own numbers against the break-even line, use the post-training assessment.
The practice: steps, time and roles
A first model takes about 7–9 weeks and about 10 engineer-weeks for a team with some post-training experience, split between a product engineer and an ML engineer. The product engineer owns the data and eval plumbing in steps 1–4. The ML engineer owns training and verifier design in steps 5–10. Elapsed times below assume existing traces and a lightweight eval harness.
| Step | Owner | Elapsed |
|---|---|---|
| 1. Scope the task, metrics and cost target | Product eng | 0.5 week |
| 2. Build the eval set and measure the frontier baseline | Product eng, ML review | 1 week |
| 3. Collect, clean and label data (LLM pre-label, human review) | Product eng | 1–2 weeks, parallel with 2 and 4 |
| 4. Generate synthetic data from a teacher model | Product eng, ML review | 0.5 week |
| 5. Pick the base model, set up training and serving | ML eng | 0.5 week |
| 6. SFT or LoRA runs | ML eng | 0.5–1 week |
| 7. Design verifiers and rewards | ML eng | 1–2 weeks |
| 8. Reinforcement learning (light) | ML eng | 2–3 weeks |
| 9. Error analysis and data fixes | ML and product eng | 1–2 weeks, overlaps 7–8 |
| 10. Deploy, run alongside live traffic, cut over | ML and product eng | 1 week |
Two things shorten the schedule. First, an AI first pass on the engineering work, reviewed by a human, roughly halves ML engineering effort in steps 5–10 (from about 25 to about 13 engineer-weeks for a team new to post-training; the experienced team assumed here needs about 7). Second, the ML engineer can start steps 5–6 on a first data batch while the product engineer finishes the full dataset.
Two gates protect the budget. After SFT, check how far it gets you before committing to RL, which can cost 100 to 700 times more than SFT and does not reliably win. Before cutover, run the model alongside live traffic without replacing the baseline.
Verifier design in step 7 is the part that stays mostly human. An LLM cannot validate its own reward function without ground truth, and a loose verifier gets gamed during RL. Plan for this, and note that published open-model runs sweep each training stage several times, so budget for reruns.
The cost model
On Nemotron 3.5 Lightning, the first workflow costs about $60K to build, including compute, and about $44K a year to keep current. Each additional workflow costs about 24% less to build and about 29% less to run, because the pipeline, harness and deployment path carry over.
First workflow Each additional
Build split: labor and data ~$54K first / ~$41K next; compute ~$6.2K / ~$5.0K. One refresh totals ~$13.6K / ~$10.1K (two refreshes a year, plus ~$17K / ~$11K maintenance). The first build breaks down as roughly $26K ML engineering, $20K product engineering, $8K data and agent tokens (team review, synthetic generation from existing traces) and $6K compute. A refresh costs about 23% of the build because data, verifiers and scripts are reused.
Compute. Training compute is priced at the lowest rates we found for Nemotron 3.5 Lightning (a BF16 base) at 64K context, in dollars per million tokens: $0.184 prefill, $0.0368 cached prefill, $0.495 sampling and $0.44 training. These are limited-time 50% discount rates with no end date stated; the list rates are $0.368 prefill, $0.99 sampling and $0.88 training. At 256K context, training costs $0.80 ($1.60 at list) with the same prefill, cached prefill and sampling rates.
These volumes are illustrative, so scale them to your own runs. Each additional workflow uses about 80% of this compute, since the recipe is already known.
Serving is variable. At the hosted rates above, it comes to about 0.75% of what the same traffic would cost on Fable or Astra. Yes, 0.75% is not a typo: serving that traffic would cost $75 here, against $10,000 on the frontier API.
Assumptions behind these figures: ML engineer at about $4.7K a week and product engineer at about $4.25K a week, fully loaded; AI-assisted first passes with human review; the ML engineer’s time during training runs is freed for other work, so it is not charged here. Reuse on the second workflow cuts the build’s labor and data from about $54K to about $41K. These are estimates, so replace them with your own rates.
Who these costs describe. The model assumes a scrappy, AI-native team: one ML engineer and one product engineer with some post-training experience, existing traces and logging, a lightweight eval harness, review done by the team rather than outside experts, and serving already in place. AI-native enterprise teams should see similar costs. Conventional enterprises without a post-training pipeline, and workflows with specific corner cases, will cost more. Training compute on Nemotron 3.5 Lightning is only about a tenth of the build, so labor and data drive the cost.
Not included: hiring, compliance review, consultancy or platform fees, and any serving infrastructure beyond per-token hosting.
ROI: workflows × token spend
Spend per workflow drives the return; adding workflows mostly lowers the bar each one has to clear. Find your row (how many workflows) and column (monthly spend each would have at Fable or Astra list prices).
Assumptions: 99% savings against Fable or Astra (serving at about 0.75% of the baseline bill), the cost model above, a three-year horizon, with compute. “S” is monthly baseline spend per workflow, “N” the number of workflows, B the build cost and R the annual run cost.
3-year net = 36 × (0.9925 × S × N − Rₙ / 12) − Bₙ
Rows are workflow count. Columns are monthly baseline spend per workflow at Fable or Astra list prices. Cell second line is payback months on the build.
~0.3B tok
~0.6B
~1.5B
~3B
How to read it:
- Spend sets the size of the win. Going from $10K to $50K a month per workflow multiplies the three-year net about eight to ten times, for any number of workflows.
- More workflows lower the bar, not the payback. The marginal workflow breaks even at about $4K a month, against $5.4K for the first.
- Below about $4K a month per workflow, don’t build. Even five workflows only break even near $4.2K.
- The second and later workflows assume reuse. They are costed at about 76% of the first build and 71% of its run cost. That is a judgment, and it holds only when the tasks are related.
What moves the grid
The single-workflow three-year break-even is about $5.4K a month of baseline spend. These levers shift it:
Two other forces work outside the chart. Closed-model price cuts erode the savings, and the gap between flagship and small-tier prices is already wide: Astra lists at 2.5 times the rate of GPT-5.6 Sol. Open-weight price drops widen the gap. Rerun the grid each time either side reprices.
In-house or a consultancy
You can run the work in-house or bring in a consultancy. The training and serving tools are the same either way, so the choice mostly decides who carries the engineering cost and who owns what gets built.
- In-house. Your ML and product engineers run the process described above, which is the cost model in this post. It builds the skills and reusable assets that make the second and third workflow cheaper.
- Consultancy. An outside team runs the build. Outside consultants can cover the work from model and harness selection through data, environments, evals and a shipped endpoint. The fee replaces part or all of the engineering lines in the cost model, so get a quote and compare it with the first-build labor and data cost of about $54K. It can shorten the schedule and fill a gap in post-training experience.
The costs to weigh on the consultancy side: each refresh may be billed again unless your team takes it over, and the data, eval set and verifiers must be handed over and documented so they stay yours. A middle path is to have the consultancy build the first workflow alongside your engineers, then run refreshes and later workflows yourselves.
Tooling for either path. You can rent GPUs directly: the October 2026 median on-demand price is $4.20 an hour for an H100 and $8.19 for a B200, and rental prices have been rising in 2026. Or you can use a managed training service.
Whichever route you pick, check two things. First, how the host bills dedicated capacity versus per-token serving, because that sets the serving price your grid assumes. Second, who owns the data, eval set and verifiers when an engagement ends.
Benefits outside the ROI math
The grid counts only token savings. Five benefits sit outside it, and for some teams they decide the question before the cost does:
- Latency. A small tuned model served close to your systems can respond faster than a flagship API.
- Control. You pin the model version, so behavior does not change underneath you when a provider updates.
- Privacy. Sensitive data stays in an environment you choose.
- Vendor independence. The data and verifiers you build work with the next open-weight base, and with a different host.
- Prestige. Post-training a model of your own is a visible demonstration of AI-native capability, and it can be used in marketing, hiring and sales conversations. The value is real but hard to price, so count it as a tie-breaker, not as the reason to build.
Treat these as tie-breakers near the break-even line, not as a reason to build below it.
Checklist and sources
Score each candidate workflow before you commit engineering time:
- Monthly spend at Fable or Astra list prices is above about $4–5K
- The task is narrow, and its requirements are stable
- A gold eval set with known correct answers can be written
- A verifier a machine can run exists, or can be built
- Examples of good output exist in your own data
- No cheaper closed tier already passes the eval
- An owner is named for the eval harness and data pipeline after launch
All figures in this post are estimates: the cost lines, the 76% and 71% reuse factors and the reduction in effort from AI assistance are judgments, so replace them with your own rates.
Sources (prices as of November 12, 2026; Opus 5.5, Fable 5.2 and Mythos 5.2 fast mode, and Nemotron training and hosting prices as provided, not independently verified)
- Claude Fable 5.1 pricing
- GPT-6 Astra pricing
- OpenAI API price tiers
- Fine-tuning and RFT costs, OpenAI fine-tuning retirement
- GPU Price Index, October 2026
- Nemotron 3.5 Lightning 30B A3B model card
Hookshot™ Models is a serverless post-training platform that lets software engineers build models without a dedicated machine-learning team. Your team defines the training and test data, and Hookshot returns a model you can deploy on dedicated infrastructure, as a serverless endpoint, or on-premises.


