Home โ€บ Blog โ€บ The Maestro, Season 2 ยท Part 10
The Maestro, Season 2 ยท Part 10 ยท Phase 7 ยท ๐Ÿ“ Research director hat

Sizing Maestro-2

Phase 7 opens. Month 34: the research engine has said no to the exciting bet and yes to environments. Now the company has to decide whether to train a second model from scratch, and if so how big. This part follows Gopala and his research director through the first decision of any frontier run: what exactly are we buying with twenty million dollars of compute?

FL
FrontierAGI Team
๐Ÿ’ผ CEO๐Ÿ”ฌ Research director๐Ÿงฎ Scaling
โš ๏ธ How to read this (as of 4 Nov 2026) Gopala's company, its people and their decisions are a teaching scenario: the story is fiction, the methods are real. size_m2.py and triage.py were run (real output below). The scaling-law constants are the published Chinchilla fit; failure counts, prices, MFU and penalty weights are scenario assumptions. Disclosure: Claude, made by Anthropic, helps write this site.

1. Month 34: the question nobody wanted to ask

๐Ÿ“– The story

The board meeting ended at six. By seven, the whiteboard in the small meeting room still said what Ines, the lead investor, had written on it in green: Maestro-2: yes or no?

Gopala had expected the question. He had not expected how quickly the room divided. The sales lead wanted a bigger model because a rival had just announced one. The finance lead wanted to know why a company with a working product would spend a third of its Series A on a single training run. Mira Kovaฤ, the research director he had hired in month 24, said nothing until everyone else had finished. Then she said: Before we size a model, let us find out what the model is for.

She left with a laptop and four hundred failed customer tasks.

2. The map: from failures to a model size

๐Ÿ•ธ๏ธ Why train, and how big

or click any node

Tap any node. Data in teal, ideas in purple, risks in red, the chosen option in green. The guided tour follows the story.

3. Train only for what nothing else can fix

๐Ÿ“– The story

Mira came back on Thursday with a spreadsheet and a short sentence. Half of these are not the model's fault.

One hundred and forty-eight failures were context: the agent had not been told how a customer's repository was laid out, or had pulled a stale skill from the library. One hundred and twelve were the harness: retry loops that never gave up, plans so long they forgot their own first step. Only the remaining hundred and forty were genuinely beyond Maestro-1, and even a better model would fix only some of those.

๐Ÿ”ฌ In plain words: triage by layer An AI product has three layers: the model (the trained network), the harness (the code that calls it, retries, plans and uses tools) and the context (what it is shown: files, skills, rules). Fixing a layer higher up is far cheaper than retraining the model, so you always fix context first, harness second and the model last.
triage.py ยท Python 3, no dependencies; scenario counts
"""triage.py โ€” model, harness or context? Triage before you train.

400 failed customer tasks from the last quarter were labelled by the layer that
would fix them (the model + harness + context frame). Fixes to context and
harness are cheap and fast; only "model" failures justify a new pre-training
run. Counts, fix rates and costs are SCENARIO numbers from the story.
"""
FAILS = [  # (cause, layer, count, share a fix would recover)
    ("missing repo conventions in context", "context", 92, 0.80),
    ("stale or wrong skill retrieved", "context", 56, 0.70),
    ("tool-call loop / bad retry policy", "harness", 71, 0.75),
    ("plan too long, no checkpoints", "harness", 41, 0.60),
    ("multi-file reasoning over 4h tasks", "model", 63, 0.55),
    ("unfamiliar languages (Rust, Kotlin)", "model", 47, 0.65),
    ("long-context recall past 128k", "model", 30, 0.60)]
COST = {"context": ("2 weeks", 0.05), "harness": ("6 weeks", 0.3), "model": ("9 months", 22.0)}  # time, $M

def main():
    tot = sum(f[2] for f in FAILS)
    for layer in ("context", "harness", "model"):
        rows = [f for f in FAILS if f[1] == layer]; n = sum(r[2] for r in rows); rec = sum(r[2] * r[3] for r in rows)
        print(f"{layer:8} {n:4} failures ({n / tot:4.0%})  fix recovers {rec:5.1f} tasks  in {COST[layer][0]:9} for ${COST[layer][1]:5.2f}M")
    cheap = sum(f[2] * f[3] for f in FAILS if f[1] != "model"); model = sum(f[2] * f[3] for f in FAILS if f[1] == "model")
    print(f"\nfix context + harness first: {cheap:.0f} of {tot} failures ({cheap / tot:.0%})")
    print(f"only a new model fixes:      {model:.0f} of {tot} ({model / tot:.0%}) -> train Maestro-2 only for these")

if __name__ == "__main__":
    main()
$ python3 triage.py # 400 failures, three layers context 148 failures ( 37%) fix recovers 112.8 tasks in 2 weeks for $ 0.05M harness 112 failures ( 28%) fix recovers 77.8 tasks in 6 weeks for $ 0.30M model 140 failures ( 35%) fix recovers 83.2 tasks in 9 months for $22.00M fix context + harness first: 191 of 400 failures (48%) only a new model fixes: 83 of 400 (21%) -> train Maestro-2 only for these

Where 400 failures come from

Context (repo conventions, stale skills)148 ยท 37%
Harness (retries, long plans)112 ยท 28%
Model (reasoning, languages, long context)140 ยท 35%

Real output of triage.py. The context and harness fixes went into the product the same month.

4. The two formulas behind every model size

๐Ÿ“– The story

Tomรกs Reyes, who had run Maestro-1's pre-training, drew two lines on the whiteboard under Ines's question. One tells us what it costs. The other tells us what we get. Everything else is taste.

๐Ÿ”ฌ In plain words: 6 ร— N ร— D Training a model means pushing every token through it forward and then backward. Each active parameter does about two operations per token on the way forward and four on the way back, so the bill is roughly six ร— parameters ร— tokens. For a mixture-of-experts model, only the experts a token actually visits count as active parameters.
๐Ÿ”ฌ In plain words: scaling law Researchers trained hundreds of models at different sizes and found that the final loss follows a smooth curve. The Chinchilla fit is loss = 1.69 + 406.4 / N^0.34 + 410.7 / D^0.28: a floor you can never beat, plus a penalty for too few parameters and a penalty for too few tokens. Loss is how surprised the model is by real text: lower is better.
๐Ÿ”Ž Go deeper: why use a dense-model law for a mixture-of-experts model?
  • Because there is no better public one at this scale, and the team only needs it to rank options.
    • Using active parameters for N ignores that a mixture-of-experts model stores more knowledge in its inactive experts, so the law probably undersells all four options equally.
  • Before the real run, the team re-fits the law on its own small runs (Part 13).
    • Season 1, Part 2 showed what happens when you trust a borrowed fit: predicted 1.410, got 1.499.

5. Four shapes, one budget

size_m2.py ยท Python 3, no dependencies; published fit, scenario prices and penalties
"""size_m2.py โ€” sizing Maestro-2 under a compute budget.

Training compute uses the standard estimate FLOPs ~= 6 x N x D (N = parameters
active per token, D = training tokens). Loss is predicted with the Chinchilla
fit of Hoffmann et al. (2022): L = E + A/N^a + B/D^b. Applying a dense-model
fit to a mixture-of-experts model by using ACTIVE parameters is a rough
approximation, used here only to rank options. Prices, MFU and the candidate
shapes and the two penalty weights are SCENARIO assumptions. Maestro-1's row
counts the final run only.
"""
E, A, B, a, b = 1.69, 406.4, 410.7, 0.34, 0.28   # Hoffmann et al. 2022, fit 3
PEAK, MFU, PRICE = 989e12, 0.40, 2.40            # H100 dense BF16 FLOP/s; our MFU; $/GPU-hour

def loss(n, d): return E + A / n ** a + B / d ** b

def main():
    cands = [("Maestro-1 (today)", 11.7e9, 10e12), ("B1: 24B active, 60T", 24e9, 60e12),
             ("B2: 32B active, 50T", 32e9, 50e12), ("B3: 40B active, 48T", 40e9, 48e12),
             ("B4: 70B active, 25T", 70e9, 25e12)]
    print(f"{'option':22} {'FLOPs':>9} {'tok/param':>9} {'GPU-hours':>10} {'cost $M':>8} {'pred. loss':>10}")
    for name, n, d in cands:
        f = 6 * n * d; gh = f / (PEAK * MFU) / 3600
        print(f"{name:22} {f:9.2e} {d / n:9.0f} {gh / 1e6:9.2f}M {gh * PRICE / 1e6:8.1f} {loss(n, d):10.3f}")
    # score = predicted loss + training-cost penalty + serving-cost penalty (active params drive serving cost)
    print(f"\n{'option':22} {'loss':>6} {'+train':>7} {'+serve':>7} {'score':>7}")
    sc = []
    for name, n, d in cands[1:]:
        tr, sv = 0.002 * 6 * n * d / 1e24, 0.0006 * n / 1e9
        sc.append((loss(n, d) + tr + sv, name)); print(f"{name:22} {loss(n, d):6.3f} {tr:7.4f} {sv:7.4f} {sc[-1][0]:7.4f}")
    print(f"\nchosen (lowest score): {min(sc)[1]}")

if __name__ == "__main__":
    main()
$ python3 size_m2.py # four candidate shapes for Maestro-2 option FLOPs tok/param GPU-hours cost $M pred. loss Maestro-1 (today) 7.02e+23 855 0.49M 1.2 1.937 B1: 24B active, 60T 8.64e+24 2500 6.07M 14.6 1.867 B2: 32B active, 50T 9.60e+24 1562 6.74M 16.2 1.859 B3: 40B active, 48T 1.15e+25 1200 8.09M 19.4 1.852 B4: 70B active, 25T 1.05e+25 357 7.37M 17.7 1.846 option loss +train +serve score B1: 24B active, 60T 1.867 0.0173 0.0144 1.8988 B2: 32B active, 50T 1.859 0.0192 0.0192 1.8973 B3: 40B active, 48T 1.852 0.0230 0.0240 1.8987 B4: 70B active, 25T 1.846 0.0210 0.0420 1.9093 chosen (lowest score): B2: 32B active, 50T

Predicted loss: lower is better

B4 ยท 70B active ร— 25T1.846
B3 ยท 40B ร— 48T1.852
B2 ยท 32B ร— 50T1.859
B1 ยท 24B ร— 60T1.867
Maestro-1 ยท 11.7B ร— 10T1.937

Real output. Bars are drawn on an absolute scale, so the differences look small; at this level, 0.01 in loss is a noticeable change in capability.

Final score = loss + training cost + serving cost

1.8973B2 ยท chosen
1.8987B3 ยท +0.0014
1.8988B1 ยท +0.0015
1.9093B4 ยท +0.0120

Real output. B1, B2 and B3 are almost tied: the decision is close, which is normal.

๐Ÿ“– The story

Ines read the table twice. So the biggest model is the smartest, and you are not building it.

The biggest model is the smartest on day one, Gopala said. We pay for its size on every token a customer sends, for as long as it runs. B4 would make us a research lab with a serving bill. B2 keeps us a company.

6. Sandbox: size your own Maestro-2

๐ŸŽฎ Sandbox: size your own Maestro-2

Same formulas and constants as size_m2.py: Chinchilla loss fit, 6ND compute, 40% MFU, $2.40 per GPU-hour, our two penalty weights.

7. Five mistakes

8. Delegation box

๐Ÿ™‹ Gopala himself
  • The train-or-not decision and the final shape
  • Explaining the choice to the board
๐Ÿค– AI agents
  • Labelling failure traces
  • Sweeping shapes with the scaling law
๐Ÿค Bought, rented or borrowed
  • Board and investors as a challenge panel

9. Budget and risk tracker

ItemStatus after Part 10Note
DecisionTrain Maestro-2 (B2)32B active, 50T tokens
Compute9.60e24 FLOPs96% of the EU line
Cheap fixesShipped191 of 400 failures recovered
Regulatory marginThin4% under the line

10. The series

The Maestro, Season 2: 23 parts in five phases (Season 1: 18 parts)

VerdictMaestro-2 is justified by the 21% of failures that only a stronger model can fix, and sized by the total bill of training it and serving it rather than by its loss alone: 32B active parameters, 50T tokens. Next: finding 4,096 GPUs to train it on.

11. Reading the numbers

Primary / standard
Chinchilla scaling-law fit (Hoffmann et al., 2022); the 6ND compute estimate (Kaplan et al., 2020).
Secondary โš ๏ธ
None in this part.
Our assumptions
Failure counts, prices, MFU, penalty weights and all story events are the scenario.