The Plan and the Money
Part 2 built a training stack Gopala trusts and, in the scenario, tests showing the self-improving idea survives contact with real models. Now Gopala has to decide what that idea is worth spending money on, and how much. Should he pre-train his own model from scratch or post-train an open one? How big, on how many GPUs, for how long? Rent or buy? How much must he raise, and how long will it last? This part answers those questions from first principles, with a script anyone can rerun with their own numbers, and ends with an 18-month master plan and the one-page memo he takes to investors.
1. Mission log: weeks 6โ10
- Writes
budget.py(section 4) and prices four ways to get a model. - Collects real GPU quotes from three neoclouds and one hyperscaler; finds on-demand prices spread over a factor of three, reserved prices much tighter.
- Chooses the hybrid plan (section 6): ship a first product on a post-trained open model within months; pre-train his own mixture-of-experts model once real verified data exists.
- Decides to rent, not buy (section 8).
- Builds the cash model and 18-month plan (sections 9โ10). Writes the memo (section 11).
- Signs two design partners who will share real, verifiable engineering tasks under contract; a third is negotiating.
- Pitches; the scenario assumes a $20M seed round closes at the end of week 10.
2. The big decision
Four ways to get a model: cost including experiments
Real output of budget.py (our assumptions: 30% MFU, $2.35/GPU-hr โ ๏ธ).
- There are only four sensible ways for a start-up to get the model at the centre of its product.
- Gopala writes them down as scenarios with explicit sizes, so the comparison is about numbers, not taste.
| Scenario | What it means | Upside | Downside |
|---|---|---|---|
| A ยท Post-train an open 32B | Take an open-weight model; fine-tune and run reinforcement learning on verified skills | Cheap, fast, strong from day one | Someone else's architecture, data and licence; competitors can start from the same base |
| B ยท From scratch, 8B dense | Pre-train a small dense model on ~15T tokens (Llama-3-8B-like data scale) | Full ownership; cheap to serve | Small; general ability below good open models |
| C ยท From scratch, 32B dense | A mid-size dense model on ~6T tokens | Stronger, still simple to train | Most expensive to train and to serve |
| D ยท From scratch, MoE with 12B active | A mixture-of-experts model (larger total, 12B active per token) on ~10T tokens | Big-model quality at small-model serving cost (the DeepSeek-V3 lesson) | Harder to train well; lower utilisation; more engineering |
3. Compute from first principles
Compute from first principles
The same four steps price every option in the table below.
Every number in this part comes from three rules of thumb, explained in the site's frontier-lab start-up playbook and planning the Llama 3 run:
- On top of the final run, two multipliers dominate the real bill:
- experiments (small runs, ablations, data mixes, failed attempts
- labs commonly spend several times the final run) and failures (Llama 3's 405B run saw 466 interruptions in 54 days
- see running the run).
4. The budget script
"""budget.py โ the Maestro's compute and cash plan, from first principles.
Training compute โ 6 ยท N_active ยท D (dense or MoE active params, tokens)
Generation (RL) โ 2 ยท N_active ยท D_gen (rollouts are inference)
GPU-seconds = FLOPs / (peak FLOP/s ยท MFU)
All prices and efficiencies are ASSUMPTIONS you should replace with real quotes.
python3 budget.py
"""
H100_BF16 = 989e12 # NVIDIA H100 SXM dense BF16 peak, FLOP/s (spec sheet)
PRICE = 2.35 # $/GPU-hour, 1-year reserved H100 (secondary report, Mar 2026) โ assumption
GPUS = 1024 # cluster size for the main run
SCENARIOS = [
# name, active params, train tokens, MFU, RL rollout tokens, experiment multiplier
("A post-train open 32B", 32e9, 0.1e12, 0.40, 1.0e12, 2.0),
("B from scratch 8B dense", 8e9, 15e12, 0.40, 0.5e12, 3.0),
("C from scratch 32B dense", 32e9, 6e12, 0.40, 1.0e12, 3.0),
("D from scratch MoE 12B active", 12e9, 10e12, 0.30, 0.8e12, 3.0),
]
FAILURE_OVERHEAD = 0.10 # restarts, lost steps, bad nodes (Llama 3 saw 466 interruptions in 54 days)
RL_MFU = 0.20 # generation runs at lower utilisation than training
def plan(name, n, d, mfu, d_gen, exp_mult):
train_flops = 6 * n * d
gen_flops = 2 * n * d_gen
gpu_h = (train_flops / (H100_BF16 * mfu) + gen_flops / (H100_BF16 * RL_MFU)) / 3600
gpu_h *= 1 + FAILURE_OVERHEAD
days = gpu_h / GPUS / 24
final = gpu_h * PRICE
total = final * (1 + exp_mult) # experiments, ablations, evals cost a multiple of the final run
return train_flops, gpu_h, days, final, total
print(f"{'scenario':34s} {'train FLOPs':>11s} {'GPU-hours':>10s} {'days@'+str(GPUS):>9s} {'final run':>10s} {'with R&D':>10s}")
for s in SCENARIOS:
f, h, dys, fin, tot = plan(*s)
print(f"{s[0]:34s} {f:11.2e} {h:10,.0f} {dys:9.1f} ${fin/1e6:8.2f}M ${tot/1e6:8.2f}M")
# Runway: compute is the biggest line, but not the only one
monthly_people = 150_000 # Gopala, contractors (DC technicians, security, legal), agent API bills (assumption)
monthly_serving = 64 * PRICE * 24 * 30 # a 64-GPU serving cluster for design partners
monthly_other = 60_000 # storage, egress, data licences, tools, insurance (assumption)
raise_usd = 20e6
compute_total = plan(*SCENARIOS[0])[4] + plan(*SCENARIOS[3])[4] # the hybrid plan: A now, D later
burn = monthly_people + monthly_serving + monthly_other
months = (raise_usd - compute_total) / burn
print(f"\nhybrid plan (A then D): training compute ${compute_total/1e6:.1f}M of a ${raise_usd/1e6:.0f}M raise")
print(f"monthly burn besides training: ${burn/1e3:,.0f}k (people ${monthly_people/1e3:,.0f}k, "
f"serving ${monthly_serving/1e3:,.0f}k, other ${monthly_other/1e3:,.0f}k) โ ~{months:.0f} months of runway")- Three things stand out.
- Post-training an open model costs about a tenth of any from-scratch option.
- A from-scratch run at start-up scale is a month on 1,024 GPUs and a few million dollars for the final run, but five to nine million once experiments and failures are counted.
- And the MoE option buys a model with far more total capacity than the 8B dense one for about 35% more compute, because the cost follows active parameters while the quality follows total parameters more closely.
5. Try your own numbers
The same formulas, live
Defaults are scenario D. Our model; replace the price with a real quote.
6. The choice: a hybrid plan
The hybrid plan
Ship first to earn the data; then train the model that only that data makes possible.
Part 1 concluded that the moat is verified data and the gate, not the technique. That settles the order of play:
- Why not just stay on an open model?
- Three reasons, all about the moat:
- the licence and future direction of someone else's model are outside his control
- the data mix of a model he did not train is unknown, which complicates the contamination checks his evaluations depend on (Evaluation Layer Part 2)
- a model trained from the start on verified skills should absorb them better than one fine-tuned at the end (H2, to be tested in Phase 2).
- Why not pre-train first?
- Because it would burn the most money before a single client proves the idea.
- Three reasons, all about the moat:
- The honest caveat: a 12B-active model trained by one start-up will not beat the frontier labs' best general models.
- It does not need to.
- It needs to be the best model for its clients' verified work, at a serving cost they can afford.
7. Sizing the from-scratch model
- The Chinchilla study found that, for a fixed training budget, about 20 tokens per parameter minimises loss.
- Modern models deliberately train far beyond that (Llama 3 8B saw about 15 trillion tokens), because a smaller model trained longer is cheaper to serve for its whole life.
- Gopala follows the modern practice: the serving bill, not the training bill, dominates a product company's costs over time (the Great Flip).
| Choice | Maestro-1 plan | Reason |
|---|---|---|
| Architecture | Mixture-of-experts, 12B active parameters | Quality per serving dollar |
| Tokens | ~10T: filtered web, code, maths, documentation, plus verified skills | Open corpora alone reach this scale; FineWeb alone is ~15T tokens of English web text |
| Context | Long context added in a late training stage | Cheaper than training long from the start (Llama 3's approach) |
| Precision | BF16 with FP8 matmuls where stable | Speed; FP8 needs care (ML Layer Part 4) |
| Compute | ~7.2 ร 1023 FLOPs; ~31 days on 1,024 H100-class GPUs at 30% MFU | From budget.py |
8. Rent or buy?
- Buying 1,024 GPUs means paying for the chips (H100 prices have been widely reported in the tens of thousands of dollars each โ ๏ธ), plus servers, networking, storage, a data hall with liquid-cooling-capable power and staff to run it, all before training starts.
- The final run itself needs those GPUs for about a month.
- The AI Factory as a Service economics calculator shows the break-even for owning usually needs high utilisation over years.
- For a start-up with one big run, a stream of experiments and an uncertain future, renting wins on every count: speed, cash and flexibility.
- Renting does not remove Phase 1's work, it changes it: Gopala still has to choose and contract the provider, verify the cluster on day zero, install his own software stack and run operations.
- Parts 4โ7 cover exactly that.
9. Cash and runway
Where the $20M goes
Real output of budget.py; salaries, serving and the raise are our assumptions.
- The budget script's last lines give the cash picture: training compute for the hybrid plan is about $8.1M of a $20M raise, and everything else (people and contractors, a serving cluster for design partners, storage, data licences, tools) burns about $318k a month, leaving roughly three years of runway if nothing else changes.
The plan ties spending to evidence:
| Gate | Unlocks | Evidence required |
|---|---|---|
| G1 ยท Month 3 | Serving cluster; Maestro-0 post-training (~$0.8M) | Part 2 results hold; two design partners live |
| G2 ยท Month 6 | Experiments for Maestro-1 (~$2โ3M) | Skill loop beats the base model on partners' held-out tasks; paying customers |
| G3 ยท Month 9 | Main pre-training run (~$2M final run) | Small-scale ablations predict a better model; data and safety plans signed off |
| G4 ยท Month 13 | Maestro-1 release | Evaluation and safety gates passed (Phase 3) |
10. The 18-month master plan
Phases overlap; Gopala switches hats weekly
Our plan. Tap a bar.
11. The investor memo
Problem
Companies want AI that does real engineering work reliably. General models are impressive but do not learn from a company's own work, and their improvements are not auditable.Insight
In domains where success can be checked by machine, a model can keep and reuse its verified solutions, and fold the best into its weights, under a fixed, auditable gate (an L4 self-improving system).Evidence so far
A controlled toy experiment (Part 1, real) and pre-registered real-model tests (Part 2; in our scenario they come out positive) show retrieved, gated skills raise success at equal compute; naive memory makes things worse, which is why the gate matters.Moat
Proprietary verified-skill data that compounds with every client task, and a gate clients and regulators can audit. Not the technique itself.Plan
Maestro-0 on a post-trained open model for design partners now; Maestro-1, our own mixture-of-experts model, pre-trained from month 9.Use of funds ($20M)
~$8M training compute, ~$4M serving, ~$5M people and contractors, ~$3M data, safety, legal and reserve.Biggest risks
Big labs focusing on this niche; clients unwilling to share tasks; the loop drifting or gaming its checks (mitigated by the gate, external evaluations and human sign-off).12. Delegation box
- The scenarios and the decision
- The cash model and gates
- Pitching and partner negotiations
- Collecting and normalising price quotes
- Drafting contracts for lawyer review
- Sensitivity analysis on the budget script
- A start-up lawyer (financing, data-sharing agreements)
- A fractional finance lead
- Advisers who have run large training jobs
13. Budget and risk tracker
| Item | Status after Part 3 | Note |
|---|---|---|
| Spend to date | ~$9k (our estimate) | Part 2's rented GPUs and APIs, legal fees |
| Cash | $20M raised (scenario) | ~$8M ring-fenced for training compute |
| Time | 10 of ~78 weeks | Phase 1 starts next |
| Technical risk | Small-scale evidence positive | Must hold at scale (Phase 2) |
| Market risk | Two design partners signed | Need paying customers by G2 |
| Compute supply risk | Quotes collected | Reserved capacity tight in 2026; book early (Part 4) |
| Competition risk | High | Speed to partners' workflows is the defence |
| Execution risk: one maestro | High | Contractors, agents and advisers named in each delegation box |
14. The series
The Maestro: 18 parts in five phases
- Phase 0 ends with a decision grounded in arithmetic: ship first on a post-trained open model to earn real verified data, then pre-train a 12B-active mixture-of-experts model of his own, all on rented GPUs, with spending released only when evidence arrives.
- About $8M of a $20M raise goes to training compute; the rest buys three years of runway.
- Phase 1 turns money into a working machine: Part 4, securing compute.
- Follow it all on Maestro Mission Control.
15. Reading the numbers
- Primary / standard
- H100 SXM dense BF16 peak 989 TFLOP/s (NVIDIA). 6ยทNยทD and 2ยทNยทD approximations (Kaplan et al. 2020; Hoffmann et al. 2022). Chinchilla ~20 tokens per parameter. Llama 3: 8B trained on ~15T tokens; 466 interruptions in 54 days for 405B (Meta). FineWeb ~15T tokens (Hugging Face).
- Secondary โ ๏ธ
- $2.35 per H100-hour on one-year contracts (SemiAnalysis figure reported by secondary sources, March 2026); H100 purchase prices.
- Our assumptions
- Scenario sizes, MFU, failure overhead, experiment multipliers, salaries, serving cluster, the $20M raise, gates and plan.