The Maestro ยท Part 18 ยท Phase 4 ยท ๐ผ Founder hat
The Scorecard
Eighteen months ago Gopala wrote down an idea, its hypotheses and the conditions that would kill it. Now he grades himself against them. This final part compares the plan with what happened, line by line, with a script; checks the runway and the path to break-even; asks which of Part 1's hypotheses held; lists what he would do differently; and sketches what comes next: Maestro-2, a larger team, and the localised and frontier-scale versions of this story the site will tell later.
๐ผ Founder๐ฌ Researcher๐ Analyst๐ป Coder
โ ๏ธ How to read this (as of 30 Oct 2026)
Plan figures come from the scripts in earlier parts.
scorecard.py and runway.py were run (real output below); every outcome they grade is the scenario, and revenue growth is our assumption. Gopala and his company are a teaching story; nothing here reports a real company's results. Disclosure: Claude, made by Anthropic, helps write this site.
Mission log: month 18
Plan vs outcome
Did the hypotheses hold?
The kill criteria, revisited
Cash, runway and break-even
Try the runway
Where the money went
What he would do differently
Ten lessons from wearing every hat
What comes next
The numbers he will report from now on
What the job looks like now
If you are building something like this
The risk register at month 18
The investor update, in five lines
Seven founder mistakes the scorecard caught
Delegation box
Budget and risk tracker
The series
Reading the numbers
1. Mission log: month 18
Week 78 ยท The review
- Writes
scorecard.pyandrunway.py; reviews the plan with investors and the two new hires.
Week 78 ยท Decisions
- Raises a seed extension or series A in month 22โ24 (section 5); approves Maestro-1.1 work; defers Maestro-2.
2. Plan vs outcome
scorecard.py ยท Python 3, no dependencies; scenario outcomes
"""scorecard.py โ plan vs outcome after 18 months (Part 3's plan vs the story).
Plan numbers are from earlier parts' scripts; outcomes are the SCENARIO.
A line is green within 10% of plan, amber within 25%, red beyond.
"""
ROWS = [ # name, plan, outcome, unit, higher_is_better
("Training compute spent", 8.1, 8.4, "$M", False),
("Main run duration", 31.4, 32.5, "days", False),
("Months to first partner use", 4, 4.5, "months", False),
("Months to Maestro-1 release", 13, 13.5, "months", False),
("Release-set improvement over Maestro-0", 4.0, 5.1, "points", True),
("Loop updates approved by the gate", 12, 7, "updates", True),
("Paying customers at month 18", 12, 9, "customers", True),
("Monthly burn", 318, 352, "$k", False),
]
def rag(plan, out, hib):
d = (out - plan) / plan if hib else (plan - out) / plan
return "G" if d >= -0.10 else ("A" if d >= -0.25 else "R")
def main():
counts = {"G": 0, "A": 0, "R": 0}
for name, plan, out, unit, hib in ROWS:
r = rag(plan, out, hib); counts[r] += 1
print(f"[{r}] {name:40s} plan {plan:7.1f} {unit:9s} outcome {out:7.1f}")
print(f"green {counts['G']}, amber {counts['A']}, red {counts['R']}")
if __name__ == "__main__":
main()$ python3 scorecard.py # outcomes are the story's, plans from Parts 3โ12
[G] Training compute spent plan 8.1 $M outcome 8.4
[G] Main run duration plan 31.4 days outcome 32.5
[A] Months to first partner use plan 4.0 months outcome 4.5
[G] Months to Maestro-1 release plan 13.0 months outcome 13.5
[G] Release-set improvement over Maestro-0 plan 4.0 points outcome 5.1
[R] Loop updates approved by the gate plan 12.0 updates outcome 7.0
[A] Paying customers at month 18 plan 12.0 customers outcome 9.0
[A] Monthly burn plan 318.0 $k outcome 352.0
green 4, amber 3, red 1
The 18-month scorecard (scenario)
Real output of scorecard.py on the story's outcomes.
- What went to plan.
- Training cost, the main run and the release date landed within about 4โ10% of plan, because Phases 1โ2 were planned from arithmetic and protected by gates.
- The release-set improvement over Maestro-0 (5.1 points in the story) beat the 4-point plan.
- What did not.
- Loop updates approved: 7 against a plan of 12. The gate rejected more than expected, mostly for test gaming and regressions (Part 11). That is the gate working, but it means the flywheel is slower than the pitch said.
- Customers: 9 against 12, and burn 11% above plan, mostly from the extra evaluation and red-team work.
3. Did the hypotheses hold?
| Hypothesis (Part 1) | Evidence | Verdict (scenario) |
|---|---|---|
| H1 ยท Skills transfer: retrieving verified skills raises success on new held-out tasks | Part 2 small-scale results; retrieval in production agents with a library well past 1,000 skills | Held, modestly |
| H2 ยท Folding skills into weights beats the same compute on generic code data | Release-set gain of Maestro-1 over Maestro-0 (Part 12) | Partly held; hard to separate from the new base model |
| H3 ยท The gate catches bad changes | Gamed and regressing updates rejected (Part 11); injected bad skills caught in red-team tests (Part 13) | Held, at a cost in speed |
| The moat: verified data competitors cannot download | Library of ~2,200 skills, partner agreements | Too early to tell |
- The honest summary.
- The idea worked well enough to build a business on, but not as a fast-compounding flywheel: the gate's rejections and skill overlap slowed it.
- The most valuable asset turned out to be the evaluation and gate machinery itself: clients trusted the product because it could show why each update shipped.
4. The kill criteria, revisited
- Part 1 named the result that would kill each hypothesis.
- H1: no gain on held-out tasks once the library held 1,000 skills. The library passed 1,000 with a held-out gain, so it did not fire.
- H2: no difference from generic data, or regressions the gate could not prevent. The gate prevented the regressions it saw, so it did not fire.
- H3: injected bad skills getting past the gate more than rarely in red-team tests. None of the story's injected skills passed.
- None fired, so the company continues.
- But the scorecard adds a new one for the next 12 months: if verified skills per cycle keep falling while usage grows, the loop has saturated and the strategy must change (Part 17's warning).
5. Cash, runway and break-even
runway.py ยท Python 3, no dependencies; scenario revenue
"""runway.py โ cash after 18 months and the path to the next raise.
Starts from the $20M seed (Part 3). Spend by phase from the story's
Mission Control; revenue from SCENARIO customers growing per month.
"""
RAISE = 20.0
SPENT_18M = 12.6 # $M, scenario total through month 18
BURN = 0.352 # $M per month after month 18 (scenario)
REV_M18 = 0.11 # $M monthly revenue at month 18 (scenario)
GROWTH = 0.12 # monthly revenue growth (assumption)
def main():
cash = RAISE - SPENT_18M
print(f"cash at month 18: ${cash:.1f}M of ${RAISE:.0f}M")
rev, m = REV_M18, 18
while cash > 0 and m < 60:
m += 1; rev *= 1 + GROWTH; cash -= max(0, BURN - rev)
if rev >= BURN:
print(f"break-even on monthly burn at month {m} with ${cash:.1f}M left"); break
else:
print(f"cash runs out at month {m}")
for g in (0.06, 0.09, 0.12, 0.15):
cash, rev, m = RAISE - SPENT_18M, REV_M18, 18
while cash > 0 and rev < BURN and m < 80:
m += 1; rev *= 1 + g; cash -= BURN - rev
print(f" growth {g:.0%}/month: {'break-even' if rev >= BURN else 'out of cash'} at month {m}")
if __name__ == "__main__":
main()$ python3 runway.py # scenario revenue and burn
cash at month 18: $7.4M of $20M
break-even on monthly burn at month 29 with $6.0M left
growth 6%/month: break-even at month 38
growth 9%/month: break-even at month 32
growth 12%/month: break-even at month 29
growth 15%/month: break-even at month 27
Months to break-even by monthly revenue growth (scenario)
Real output of runway.py; growth rates are assumptions.
- What it says.
- With $7.4M left at month 18 and $352k monthly burn, the company reaches break-even around month 29 if revenue grows 12% a month, keeping about $6M.
- At 6% growth it takes until month 38 but still does not run out of cash in this scenario, because revenue offsets more of the burn every month.
- The decision: raise in months 22โ24 anyway, from a position of strength, to fund Maestro-2 rather than survival.
6. Try the runway
Runway after month 18 (our model)
7. Where the money went
Spend through month 18 by phase (scenario, $M)
From Maestro Mission Control (scenario figures).
- Two surprises.
- Phase 4 cost almost as much as building the model: serving, people and integrations run every month, while training happened once.
- Phase 0 cost almost nothing, yet decided everything else: the cheapest phase had the highest leverage.
8. What he would do differently
- Build the evaluation harness even earlier.
- Part 12's discovery that 500 tasks were too few would have shaped Parts 9โ11 if it had come in month 3.
- Plan for the gate's rejection rate.
- The pitch assumed most loop updates would pass; a realistic plan would have assumed half.
- Start the go-to-market work in parallel with Phase 2.
- Customers lagged plan partly because product packaging started only in month 13.
- Price per solved task from day one.
- Seat pricing in the early pilots set expectations that had to be renegotiated (Part 16).
- Write things down earlier.
- Every record that existed (manifests, gate logs) made Phase 3 faster; every one that did not cost weeks.
9. Ten lessons from wearing every hat
- Arithmetic first: the plan that survived was the one built from 6ยทNยทD and quotes, not from ambition.
- Rent before you buy; buy useful hours, not GPU-hours (Part 4).
- Distrust hardware until it passes your own tests (Part 6).
- Data decides more than architecture (Part 8).
- Design for serving while you design for training (Parts 9 and 15).
- The verifier decides what the model learns (Part 11).
- A number without an interval is a guess (Part 12).
- Control actions, not words (Part 13).
- Records turn compliance from archaeology into assembly (Part 14).
- Give away operations before you give away the gate (Part 17).
10. What comes next
The next 18 months (plan)
๐Maestro-1.1More loop cycles, new task types to beat saturation
๐ฐRaiseMonths 22โ24, to fund Maestro-2
๐๏ธMaestro-2Larger MoE; near the EU 1e25 FLOP presumption (Part 14)
๐ฅTeam of ~15Separate safety, security and research leads
Plans, not results.
- Two more versions of this story are planned on the site.
- A localised version (starting with India: compute programmes, costs in rupees, local policy), as Part 3 promised.
- A frontier-scale version: what changes when the main run is 100,000 GPUs instead of 1,024.
- The site's other series go deeper on each layer this story touched.
- AI Compute Stack, Producing Intelligence, Who Runs the AI Factory, the ML, Data, Evaluation and Agent Layer series; all linked from the homepage.
11. The numbers he will report from now on
| Metric | Why | Source |
|---|---|---|
| Solved tasks per month | Value delivered | Product telemetry (Part 16) |
| Cost per solved task | Margin and pricing | Serving and sandbox costs (Part 15) |
| Accepted-change rate with interval | Quality as clients see it | Pilots and production (Part 12) |
| Verified skills per cycle | Health of the flywheel | Loop records (Part 17) |
| Gate approval rate | Speed of improvement | Gate log (Part 11) |
| Error-budget burn | Reliability | SLO dashboards (Part 17) |
| Runway in months | Survival | Finance (runway.py) |
- Every number links to its record.
- The same evidence library that serves regulators and customers (Part 14) serves investors.
12. What the job looks like now
- At month 1, Gopala wore every hat.
- Researcher, founder, infrastructure engineer, ML engineer, evaluator, safety lead, operator.
- At month 18, he wears three.
- Founder (money, partners, strategy).
- Owner of the gate and the data agreements.
- Research lead for the next model.
- The rest moved to people, agents and providers.
- Agents draft, summarise, run sweeps and triage; providers run buildings, GPUs and audits; two hires run operations and integrations.
- That shift, from doing everything to deciding what matters, is the real arc of the series.
13. If you are building something like this
- Start where Gopala started.
- Write the idea, the hypotheses and the kill criteria before writing code (Part 1).
- Prove it small on a laptop (Part 2), then price it from first principles (Part 3).
- Borrow the machinery.
- Every script in the series is in the site's repository under data/code, with real output on the page.
- The gate, the harness and the records matter more than the model size.
- Be honest in public.
- Label what was measured, what was simulated and what is a story. It builds more trust than a big number.
14. The risk register at month 18
| Risk | Status | Next step |
|---|---|---|
| Flywheel saturation | Watch: gains per cycle small | New task types; track skills per cycle |
| Competition from large labs | High | Depth in client repositories, trust evidence |
| Customer concentration | Medium: three partners are a large share of revenue | Broaden pilots |
| Regulatory change | Low today; rises with Maestro-2 scale | Re-run ai_act_check.py before training |
| Key person | Reduced | Second gate reviewer, documented processes |
| Compute prices | Medium | Renewal options and a second provider (Part 4) |
15. The investor update, in five lines
- What he sends at month 18.
- Maestro-1 trained from scratch for $8.4M (plan $8.1M) and shipped at month 13.5.
- It beats the post-trained open model on clients' private tasks, with an interval that excludes zero (Part 12).
- Nine paying customers (plan twelve); hybrid pricing with healthy margins (Part 16).
- $7.4M cash; break-even around month 29 at 12% monthly growth (our model).
- The flywheel works but slower than pitched; plan to fix it with new task types before Maestro-2.
- Every line links to its record.
- Investors see the same evidence as regulators and customers.
16. Seven founder mistakes the scorecard caught
- Pitching the flywheel faster than the gate would allow.
- Treating serving as an afterthought in the budget.
- Starting product packaging too late.
- Measuring success on public benchmarks in early investor updates.
- Underestimating evaluation and red-team costs.
- Doing everything himself for too long.
- Not writing down the kill criteria in the first week (he did; most founders do not).
17. Delegation box
๐ Gopala himself
- The scorecard and the decisions it drives
- Fundraising
- The research agenda for Maestro-2
๐ค AI agents
- Assembling the scorecard data from every system
- Drafting the investor update
- Scenario analysis on growth and burn
๐ค Bought, rented or borrowed
- Investors and advisers for the review
- The first two hires running operations
- Counsel for the next financing
18. Budget and risk tracker
| Item | Status after Part 18 | Note |
|---|---|---|
| Spend to date | ~$12.6M of $20M (scenario) | Through month 18 |
| Scorecard | 4 green, 3 amber, 1 red | Loop updates behind plan |
| Runway | $7.4M; break-even ~month 29 at 12% growth | Our model |
| Strategy risk | Watch | Flywheel slower than pitched |
| Cash risk | Low | Raise planned from strength |
| Competition risk | High | Larger labs ship agents too |
19. The series
The Maestro: 18 parts in five phases
Verdict
- Eighteen months, eighteen parts, every hat: an idea tested small, a machine rented and verified, a model trained from scratch, proved and approved, and products shipped to paying clients.
- The scorecard is honest: the plan held where it was built from arithmetic and slipped where it relied on hope.
- That is the Maestro series.
- Thank you for reading; see it all on Maestro Mission Control.
20. Reading the numbers
- Primary / standard
- Plan figures from earlier parts' scripts (budget.py, failure_budget.py, evaluation and gate scripts).
- Secondary โ ๏ธ
- None in this part.
- Our assumptions
- All outcomes, revenue, growth, burn, spend by phase, hires and plans.