Home โ€บ Blog โ€บ The Maestro ยท Part 3
The Maestro ยท Part 3 ยท Phase 0 ยท ๐Ÿ’ผ Founder hat

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.

FL
FrontierAGI Team
๐Ÿ’ผ Founder๐Ÿ“Š Planner๐Ÿ’ป Coder
โš ๏ธ How to read this (as of 30 Oct 2026) The compute formulas (6ยทNยทD for training, 2ยทNยทD for generation) are the standard approximations used across the field. The H100 peak figure is NVIDIA's specification; the $2.35 per GPU-hour reserved price is a secondary report of a SemiAnalysis figure (โš ๏ธ) and moves monthly; utilisation, overheads, salaries and the raise are our assumptions, written into the script so you can change them. The budget script's output below is real. Gopala is a teaching scenario. Disclosure: Claude, made by Anthropic, helps write this site.

1. Mission log: weeks 6โ€“10

Week 6 ยท Pricing
  • 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.
Week 7 ยท Deciding
  • 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).
Weeks 8โ€“10 ยท Funding and partners (in parallel with Part 2's experiments)
  • 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

A ยท post-train open 32B$0.80M
B ยท 8B dense from scratch$5.34M
D ยท MoE 12B active from scratch$7.25M
C ยท 32B dense from scratch$9.29M

Real output of budget.py (our assumptions: 30% MFU, $2.35/GPU-hr โš ๏ธ).

ScenarioWhat it meansUpsideDownside
A ยท Post-train an open 32BTake an open-weight model; fine-tune and run reinforcement learning on verified skillsCheap, fast, strong from day oneSomeone else's architecture, data and licence; competitors can start from the same base
B ยท From scratch, 8B densePre-train a small dense model on ~15T tokens (Llama-3-8B-like data scale)Full ownership; cheap to serveSmall; general ability below good open models
C ยท From scratch, 32B denseA mid-size dense model on ~6T tokensStronger, still simple to trainMost expensive to train and to serve
D ยท From scratch, MoE with 12B activeA mixture-of-experts model (larger total, 12B active per token) on ~10T tokensBig-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

๐Ÿ”ขFLOPs6 ร— parameters ร— tokens
โšกGPU speed989 TFLOP/s peak ร— 30% MFU
โฑ๏ธGPU-hoursFLOPs รท speed, +10% failures
๐Ÿ’ตCostGPU-hours ร— $/hour

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:

Training โ‰ˆ 6 ยท N ยท DFLOPs to train a dense transformer with N parameters on D tokens: about 2 for the forward pass and 4 for the backward pass, per parameter per token. For mixture-of-experts, N is the active parameters.
Generation โ‰ˆ 2 ยท N ยท DProducing D tokens (for example reinforcement-learning rollouts) costs a forward pass only. It runs at lower utilisation than training.
GPU-time = FLOPs รท (peak ยท MFU)An H100 peaks at 989 TFLOP/s in dense BF16 (NVIDIA spec). Real training achieves 30โ€“45% of that ("model FLOPs utilisation"); the rest is lost to communication, memory and waiting.

4. The budget script

budget.py ยท Python 3, no dependencies
"""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")
$ python3 budget.py scenario train FLOPs GPU-hours days@1024 final run with R&D A post-train open 32B 1.92e+22 113,695 4.6 $ 0.27M $ 0.80M B from scratch 8B dense 7.20e+23 568,475 23.1 $ 1.34M $ 5.34M C from scratch 32B dense 1.15e+24 988,653 40.2 $ 2.32M $ 9.29M D from scratch MoE 12B active 7.20e+23 771,149 31.4 $ 1.81M $ 7.25M hybrid plan (A then D): training compute $8.1M of a $20M raise monthly burn besides training: $318k (people $150k, serving $108k, other $60k) โ†’ ~38 months of runway

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

๐Ÿš€Maestro-0Post-train an open model, ship to partners (months 3โ€“6)
๐Ÿ—ƒ๏ธVerified dataReal client tasks feed the skill library
๐Ÿ—๏ธMaestro-1Pre-train own 12B-active MoE (months 9โ€“10.5)
๐Ÿ”FlywheelPost-training and the RSI loop (months 10.5+)

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:

Now: Maestro-0 (scenario A)Post-train a strong open model on the skill loop and ship it to design partners within the first months. Purpose: real clients, real verified data, revenue, and proof that the loop works on production tasks.
Next: Maestro-1 (scenario D)Pre-train a mixture-of-experts model from scratch, with an architecture and tokenizer designed for code and tools, trained on public data plus the verified-skill data that only Gopala has. Purpose: full ownership of weights and licence, cheaper serving, and a base model whose data rights are clean.

7. Sizing the from-scratch model

ChoiceMaestro-1 planReason
ArchitectureMixture-of-experts, 12B active parametersQuality per serving dollar
Tokens~10T: filtered web, code, maths, documentation, plus verified skillsOpen corpora alone reach this scale; FineWeb alone is ~15T tokens of English web text
ContextLong context added in a late training stageCheaper than training long from the start (Llama 3's approach)
PrecisionBF16 with FP8 matmuls where stableSpeed; FP8 needs care (ML Layer Part 4)
Compute~7.2 ร— 1023 FLOPs; ~31 days on 1,024 H100-class GPUs at 30% MFUFrom budget.py

8. Rent or buy?

Rent the training clusterReserve 1,024 GPUs for ~2 months around the main run; use smaller on-demand slices for experiments (neoclouds or hyperscalers).
Rent the serving cluster64 GPUs reserved for design partners, scaled with demand.
Revisit ownership at scaleOnly when utilisation is high and predictable for years: the future "full frontier" section of this site.

9. Cash and runway

Where the $20M goes

$8.1Mtraining compute (A then D)
$318kmonthly burn besides training
~38 monthsrunway
$150kpeople per month

Real output of budget.py; salaries, serving and the raise are our assumptions.

The plan ties spending to evidence:

GateUnlocksEvidence required
G1 ยท Month 3Serving cluster; Maestro-0 post-training (~$0.8M)Part 2 results hold; two design partners live
G2 ยท Month 6Experiments for Maestro-1 (~$2โ€“3M)Skill loop beats the base model on partners' held-out tasks; paying customers
G3 ยท Month 9Main pre-training run (~$2M final run)Small-scale ablations predict a better model; data and safety plans signed off
G4 ยท Month 13Maestro-1 releaseEvaluation and safety gates passed (Phase 3)

10. The 18-month master plan

Phases overlap; Gopala switches hats weekly

Our plan. Tap a bar.

Tap a bar.

11. The investor memo

Maestro ยท Seed memo ยท one page

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

๐Ÿ™‹ Gopala himself
  • The scenarios and the decision
  • The cash model and gates
  • Pitching and partner negotiations
๐Ÿค– AI agents
  • Collecting and normalising price quotes
  • Drafting contracts for lawyer review
  • Sensitivity analysis on the budget script
๐Ÿค Bought, rented or borrowed
  • A start-up lawyer (financing, data-sharing agreements)
  • A fractional finance lead
  • Advisers who have run large training jobs

13. Budget and risk tracker

ItemStatus after Part 3Note
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
Time10 of ~78 weeksPhase 1 starts next
Technical riskSmall-scale evidence positiveMust hold at scale (Phase 2)
Market riskTwo design partners signedNeed paying customers by G2
Compute supply riskQuotes collectedReserved capacity tight in 2026; book early (Part 4)
Competition riskHighSpeed to partners' workflows is the defence
Execution risk: one maestroHighContractors, agents and advisers named in each delegation box

14. The series

The Maestro: 18 parts in five phases

Verdict
  • 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.

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.