Securing Compute
Phase 0 ended with $20M in the bank and a plan that needs about 1,024 H100-class GPUs for a month of pre-training, 64 more for serving, and a smaller pool for experiments from month 3. Now Gopala has to turn money into reserved machines. Which kind of provider? On what contract? What must the contract say about failures, networking, storage and security? And how does he compare offers whose list prices differ by 75% but whose useful hours may not? This part is the buyer's guide he wished he had: the market as of late 2026, a scoring script that prices every offer per useful GPU-hour, the clauses that matter and the acceptance test he writes into the contract before signing.
1. Mission log: weeks 11โ14
- Writes down the hard requirements from Part 3: 128 nodes ร 8 H100-class GPUs in one non-blocking network fabric, ~1.5 MW of IT power, shared storage that can absorb a multi-terabyte checkpoint in minutes, and a 12-month term from month 3.
- Starts from public ratings and peer references, not ads: 14 providers on the long list, 6 that can offer 1,024 GPUs in a single fabric by month 3.
- Negotiates the contract clauses in section 12, with an outside lawyer, and signs with the provider that wins on cost per useful hour (scenario).
- Books a separate on-demand pool for experiments and keeps one hyperscaler account for storage and serving burst.
2. What exactly is he buying?
What "1,024 GPUs" really means
Two clusters with the same GPU count can differ two-fold in speed because of the layers around the GPUs.
- "1,024 GPUs" is not a specification.
- Two clusters with the same GPU count can differ by a factor of two in training speed because of everything around the GPUs.
Gopala's requirements sheet, the first thing every provider receives:
| Requirement | Why it matters for Maestro-1 | What to ask for |
|---|---|---|
| GPU | The budget (Part 3) assumes H100-class: 80 GB HBM, ~989 dense BF16 TFLOP/s peak. | H100 or H200 SXM, 8 per node on NVSwitch. Not PCIe cards: their GPU-to-GPU bandwidth is far lower. |
| One fabric | Tensor and expert parallelism (Part 9) need every GPU to talk to every other at full speed. | All 1,024 GPUs on one non-blocking InfiniBand NDR or RoCE fabric, 8 ร 400 Gb/s NICs per node ("rail-optimised"). A written topology diagram. |
| Storage | Checkpoints of a large MoE model plus optimiser state run to terabytes; a slow save stalls 1,024 GPUs. | Parallel file system (e.g. Lustre, WEKA, VAST, DDN) with a stated write bandwidth, plus object storage for data. |
| Access | He needs to install his own stack (Part 7). | Bare metal or near-bare-metal, root on nodes, out-of-band (BMC) access or a provider API to power-cycle. |
| Orchestration | Saves weeks if the provider runs it well; costs weeks if they do not. | Managed Slurm or Kubernetes offered, but not forced. |
| Location | Data-residency clauses from design partners; latency to his data. | Named data centre, no silent migration. |
| Time | Every month of delay is ~$318k of burn with no model. | Delivery date with penalties; partial early delivery for experiments. |
- The total requirement, from Part 3: about 1,024 GPUs for the main run and its experiments (months 6โ10.5), 64 GPUs for serving from month 4, and a smaller pool (64โ128 GPUs) for Maestro-0 post-training and ablations from month 3.
- He decides to reserve the large block for 12 months anyway: in 2026, reserved capacity in one fabric is the scarce thing, and a block released between runs may not come back.
3. The market in late 2026
- There are four kinds of seller.
- Each fits a different part of the plan.
| Seller | Examples | Strength | Weakness for a start-up |
|---|---|---|---|
| Hyperscalers | AWS, Microsoft Azure, Google Cloud, Oracle | Reliability, security reviews done, every other service next door, credits for start-ups | Highest list price for GPUs; large reservations often need long commitments |
| Neoclouds | CoreWeave, Nebius, Lambda, Crusoe, Together AI and others | GPU-first, faster delivery, training-grade fabrics, often better price | Quality varies widely; some resell other operators' capacity |
| Brokers and marketplaces | Aggregators across many small sites | Cheapest per hour, flexible terms | Mixed hardware, often no single fabric, thin support |
| Colocation + owned hardware | Equinix, Digital Realty and regional operators | Lowest cost over 3โ5 years | Capital, lead time and staff Gopala does not have (Part 3 chose to rent) |
- A useful public starting point is SemiAnalysis's ClusterMAX rating, which reviews GPU clouds on security, networking, storage, orchestration, reliability and support, and puts them in tiers from Platinum to Underperform.
- CoreWeave was the only Platinum provider in the published ratings (โ ๏ธ ratings are refreshed every few months, and a newer edition was reported in September 2026).
- Gopala uses it to build the long list, not to decide: a rating reviews a provider in general, and he needs to know about his block, in one building, on his dates.
- Hyperscaler start-up programmes give credits worth tens or hundreds of thousands of dollars.
- They pay for Maestro-0 experiments and storage nicely, but they do not reserve a 1,024-GPU block in one fabric.
- Gopala uses credits for the edges of the plan, not its centre.
4. What GPUs actually cost in 2026
- Prices for H100-class GPU-hours moved a lot in two years, and the quoted figure depends on term, volume, GPU variant and what is bundled.
The public evidence, all secondary (โ ๏ธ):
| Price point | Figure | Source type |
|---|---|---|
| One-year H100 contract, Oct 2025 low | ~$1.70 per GPU-hour | SemiAnalysis figure reported by a price tracker โ ๏ธ |
| One-year H100 contract, Mar 2026 | ~$2.35 per GPU-hour (almost +40%) | Same โ ๏ธ (the figure Part 3's budget uses) |
| Neocloud on-demand listings, Oct 2026 | from ~$1.70, most between ~$2 and ~$4 | Price aggregators โ ๏ธ |
| Hyperscaler on-demand | often several times neocloud prices per GPU-hour | Aggregators and list prices โ ๏ธ |
| Reserved vs on-demand | discounts of roughly 20โ40% for 1โ12 month terms | Aggregators โ ๏ธ |
- Three things follow for a buyer.
- First, prices are not monotonic: they fell through 2025 as supply caught up and then firmed in 2026 as demand for inference grew, so a 12-month lock-in is a bet in either direction.
- Second, cheap single-GPU listings tell you little about a 1,024-GPU block in one fabric, which is a different product.
- Third, the spread between providers is wide enough that the useful-hour arithmetic in the next sections matters more than haggling over cents.
5. A quote template that makes offers comparable
- Providers quote in different shapes:
- per GPU-hour or per node-month, with or without storage, with networking "included"
- but unspecified, with discounts that depend on paying a year up front.
Gopala sends one template and refuses quotes that do not fill it in:
- Price per GPU-hour, for 1, 6 and 12 months, and the upfront payment required for each.
- GPU model, memory, node design, NICs per node and link speed; the fabric topology and oversubscription ratio.
- Storage: type, usable capacity, guaranteed read/write bandwidth per node and in aggregate, price.
- Availability commitment per node, how it is measured, and the credit when it is missed.
- Time to replace a failed node or GPU, and whether spares are held on site.
- Support: named engineers, response times by severity, and a shared chat channel.
- Security: certifications (SOC 2 Type II, ISO 27001), tenant isolation, who has physical and remote access, how disks are wiped.
- Delivery date, the penalty for slipping, and whether part of the block can come early.
- Egress charges for moving data and checkpoints out.
6. Reading a real SLA
- Before writing his own clauses, Gopala reads what the market offers.
- CoreWeave's public terms of service, for example, state a monthly uptime objective of at least 99.9% for cloud platform instances, and its master services agreement template defines a "hardware failure"
- as breakage of a GPU node that causes that node to fail.
- Its object-storage SLA says service credits do not entitle the customer to a refund or other payment.
- CoreWeave's public terms of service, for example, state a monthly uptime objective of at least 99.9% for cloud platform instances, and its master services agreement template defines a "hardware failure"
These are normal industry terms, and three lessons hold for any provider:
- Platform uptime is not node availability. A control plane at 99.9% says nothing about whether node 57 of his 128 is healthy. He needs per-node terms.
- Credits are not cash. They lower next month's bill; they do not pay for a lost week of a training run.
- Definitions decide everything. Is a node with one failed GPU "down"? Is a node whose fabric link runs at half speed "down"? If the contract does not say, the answer will be no.
7. Scoring offers: cost per useful GPU-hour
List price vs price per useful GPU-hour
Real output of provider_score.py on illustrative offers (our assumptions, not real quotes).
- The core idea of the script: you pay for every reserved hour, but you only get the hours when a node is up (availability) and, of those, only the hours that do useful training (goodput: lost to restarts after failures, slow nodes dragging the whole job, hand-offs that take days).
- Dividing the list price by both gives the price per useful hour.
- The rest of the score (network, support, security) is judged from the trial and references.
"""provider_score.py โ compare GPU cloud offers on cost per USEFUL GPU-hour.
The list price is not the price. What matters is how many hours of real
training you get per dollar, after the cluster's own failures, slow
hand-offs and the support you will need at 3 a.m.
Providers P1-P4 are illustrative offers, not real quotes.
"""
GPUS = 1024 # Maestro-1 main run (Part 3)
MONTHS = 12 # reservation length
# name, $/GPU-hr, availability (fraction of hours the reserved nodes are up),
# goodput (fraction of up-hours doing useful training: restarts, slow nodes),
# hours to replace a failed node, network rating 1-5, support rating 1-5,
# security rating 1-5, upfront payment fraction
OFFERS = [
("P1 neocloud, top-rated", 2.65, 0.990, 0.93, 4, 5, 5, 4, 0.25),
("P2 neocloud, cheap", 2.10, 0.960, 0.85, 48, 3, 2, 3, 0.50),
("P3 hyperscaler", 3.40, 0.995, 0.92, 2, 4, 4, 5, 0.00),
("P4 broker, mixed sites", 1.95, 0.940, 0.80, 72, 2, 2, 2, 1.00),
]
WEIGHTS = {"cost": 0.40, "network": 0.20, "support": 0.20, "security": 0.20}
def useful_cost(price, avail, goodput):
# you pay for every reserved hour; you only get avail*goodput of it
return price / (avail * goodput)
def main():
hours = MONTHS * 730
rows = []
for n, p, a, g, rep, net, sup, sec, up in OFFERS:
u = useful_cost(p, a, g)
rows.append((n, p, u, rep, net, sup, sec, up, p * GPUS * hours))
best = min(r[2] for r in rows)
print(f"{'offer':26s} {'list':>6s} {'useful':>7s} {'repl h':>6s} {'contract':>9s} {'upfront':>8s} {'score':>6s}")
scored = []
for n, p, u, rep, net, sup, sec, up, total in rows:
s = (WEIGHTS["cost"] * 5 * best / u + WEIGHTS["network"] * net
+ WEIGHTS["support"] * sup + WEIGHTS["security"] * sec)
scored.append((s, n))
print(f"{n:26s} ${p:5.2f} ${u:6.2f} {rep:6d} ${total/1e6:7.1f}M ${total*up/1e6:6.1f}M {s:6.2f}")
scored.sort(reverse=True)
print("ranking:", " > ".join(n.split()[0] for _, n in scored))
# what a 10-point goodput gap costs on the 31-day main run
run_h = 31 * 24 * GPUS
print(f"main run = {run_h:,} GPU-hours of useful work; at P2 that needs "
f"{run_h/(0.96*0.85):,.0f} paid hours vs {run_h/(0.99*0.93):,.0f} at P1")
if __name__ == "__main__":
main()Three lessons, all from the made-up offers but true of real ones:
- The cheapest list price (P4, $1.95) is not the cheapest useful hour once 94% availability and 80% goodput are counted: it ends at $2.59, essentially the same as P2 and close to P1's $2.88, while carrying far more risk.
- A goodput gap is expensive: to get the same 761,856 useful GPU-hours for the main run, the cheap P2 offer needs about 106,000 more paid hours than P1, roughly $220k at P2's price, before counting the weeks of delay.
- The upfront column matters for a start-up as much as the price: P4 wants the whole contract in advance, which would take most of the $20M raise on day one.
- Availability and goodput are the numbers a provider will not give honestly in a quote.
8. Try your own offer
Useful price calculator (our model)
9. When does the cheap offer really win?
- The score in the previous section ranks P1 first.
- But Gopala is a founder as well as an engineer, so he checks the two questions a CFO would ask: how much must the cheap offer's goodput improve to match, and what does the whole contract cost once upfront cash, storage, egress and late delivery are added?
"""offer_sweep.py โ when does the cheap offer really win?
Two questions the list price hides:
1. How good must the cheap offer's goodput be to match the premium one?
2. What does the whole contract cost once upfront cash, storage, egress
and the cost of delay are counted?
All inputs are our assumptions; change them to your quotes.
"""
GPUS, MONTHS, H = 1024, 12, 730
P1 = dict(price=2.65, avail=0.990, good=0.93, upfront=0.25, storage=45_000, egress=0)
P2 = dict(price=2.10, avail=0.960, good=0.85, upfront=0.50, storage=60_000, egress=90_000)
CASH_RATE = 0.12 # yearly cost of cash tied up upfront (what else it could fund)
DELAY_WEEKS = {"P1": 0, "P2": 3} # later delivery in the scenario
BURN_WEEK = 318_000 * 12 / 52 # Part 3 burn
def useful(o):
return o["price"] / (o["avail"] * o["good"])
def contract(name, o):
compute = o["price"] * GPUS * H * MONTHS
cash = compute * o["upfront"] * CASH_RATE * (MONTHS / 12) / 2
other = o["storage"] * MONTHS + o["egress"]
delay = DELAY_WEEKS[name] * BURN_WEEK
useful_h = GPUS * H * MONTHS * o["avail"] * o["good"]
total = compute + cash + other + delay
print(f"{name}: compute ${compute/1e6:5.2f}M + cash ${cash/1e6:4.2f}M + storage/egress "
f"${other/1e6:4.2f}M + delay ${delay/1e6:4.2f}M = ${total/1e6:5.2f}M "
f"-> ${total/useful_h:4.2f} per useful GPU-hour")
return total / useful_h
def main():
print(f"useful price: P1 ${useful(P1):.2f} P2 ${useful(P2):.2f}")
# break-even goodput for P2 against P1
be = P2["price"] / (P2["avail"] * useful(P1))
print(f"P2 matches P1 on useful price at goodput {be:.1%} (P1 needs {P1['good']:.0%})")
print("goodput of P2 -> useful price")
for g in (0.70, 0.75, 0.80, 0.85, 0.90, 0.95):
u = P2["price"] / (P2["avail"] * g)
bar = "#" * int((u - 2.0) * 20)
print(f" {g:.0%} ${u:4.2f} {bar}{' <- cheaper than P1' if u < useful(P1) else ''}")
a, b = contract("P1", P1), contract("P2", P2)
print(f"whole-contract winner: {'P1' if a < b else 'P2'} by ${abs(a-b):.2f} per useful GPU-hour")
if __name__ == "__main__":
main()- The honest result is uncomfortable: on money alone, the cheap offer P2 wins, by about $0.20 per useful GPU-hour (about $4M over the year), even after paying for its later delivery and higher upfront payment.
- Its goodput would have to fall to about 76% before P1 matched it on useful price.
- So why does the scenario pick a P1-like provider anyway?
- Because the numbers above assume P2's 85% goodput is real, and that is the least reliable number in the table.
- Its 48-hour node replacement, weaker support and security score mean its variance is larger: a bad month on P2 is far worse than a bad month on P1, and the main run is a single 31-day bet that the company cannot repeat.
Gopala writes the decision down this way:
- Take the cheapest offer per useful hour unless its goodput is unproven and the work cannot be repeated.
- Experiments and evaluation, which can be rerun, go to the cheap pool; the main run goes to the provider whose goodput the trial confirmed.
- In the scenario he does exactly that: the main block with a P1-like provider, and a smaller on-demand P2-like pool for ablations.
10. The two-node trial
How an offer is tested before signing
Each step can drop a provider.
- Before signing, Gopala asks every finalist for two nodes for 48 hours, and runs the same checks he will run on day zero (Part 6): GPU diagnostics, NVLink bandwidth inside a node, InfiniBand bandwidth between the two nodes, a 2-node NCCL all-reduce, a storage write test, and his own small training job from Part 2.
- Then he deliberately reports a fake fault at 2 a.m. local time and times the response.
| Trial check | What it reveals |
|---|---|
| All-reduce bus bandwidth between nodes | Whether the fabric delivers what the quote says (Part 6 shows how to read the numbers) |
| Storage write of a 200 GB file from 16 GPUs at once | Whether checkpoint saves will stall the run |
| Firmware and driver versions | Whether nodes are maintained, and whether they all match |
| A support ticket at night | Whether "24/7" means a person or a queue |
| Asking for root and BMC access | Whether he can run his own stack (Part 7) |
- In the story, one finalist's inter-node bandwidth comes in at about half of its peers' on the trial (the pattern Part 6's parser flags), and support takes nine hours to answer the night ticket.
- It is dropped.
- The winner is a neocloud similar to P1 in the script.
- This is the scenario, not a review of any real provider.
11. Security due diligence
- His model weights and his partners' code will live on someone else's machines.
The security questions he asks every finalist, and the answers he wants:
| Question | Why | Good answer |
|---|---|---|
| Are my nodes single-tenant? | Shared hosts widen the attack surface | Dedicated bare-metal nodes, no other tenant's VMs |
| Is my fabric isolated? | InfiniBand partitions or separate VLANs stop cross-tenant traffic | A dedicated partition key (PKey) or physically separate fabric |
| Who has root or BMC access? | Provider staff can read memory and disks | Named, logged, break-glass only, with notification |
| Which audits? | Evidence of process, needed for partner contracts | Current SOC 2 Type II report and ISO 27001 certificate, shared under NDA |
| How are drives handled at the end or on failure? | Weights and data on failed disks leave the building | Wipe or destroy on site, with certificates |
| Can I encrypt storage with my own keys? | Limits exposure if storage is copied | Customer-managed keys for object and file storage |
- His design partners will ask the same questions about him (Part 14), so the answers go straight into his own security documentation.
12. The clauses that matter
- A GPU contract is mostly about what happens when things break.
Gopala's lawyer drafts, but these are the clauses he insists on as the infrastructure owner:
| Clause | Weak version | What he asks for |
|---|---|---|
| Availability | "99.9% platform uptime", measured on the provider's control plane | Per-node availability, measured by his own health checks, with credits per node-hour lost |
| Replacement | "Best effort" | Failed node replaced within a stated number of hours from on-site spares; credit for every hour beyond it |
| Acceptance | Billing starts on hand-over | Billing starts when the acceptance test (section 14) passes on the whole block |
| Delivery | "Target date" | A date, with credits for each week late and the right to cancel after a long slip |
| Fabric | "High-speed networking" | Named topology and minimum all-reduce bandwidth, tested at acceptance |
| Data | Silence | His data and weights stay his; disks wiped on exit with a certificate; no use for training anyone's models |
| Exit | Silence | Egress fees capped or waived for moving checkpoints out at the end |
| Security incidents | Notice "without undue delay" | Notice within a stated number of hours and access to the investigation |
- Credits are rarely large enough to repay the cost of a stalled run.
- Their real value is that they make the provider measure the same thing Gopala measures, so failures get fixed rather than argued about.
13. What the research says about failures
- Goodput is where providers differ most and disclose least, so Gopala reads what large operators have published.
- Meta's FAIR team studied 11 months of its research clusters (about 4 million jobs and over 150 million A100 GPU-hours) in "Revisiting Reliability in Large-Scale Machine Learning Research Clusters".
- Its headline: the mean time to failure of a 1,024-GPU job was about 7.9 hours, against about 47.7 days for an 8-GPU job.
- Large jobs are hit far more often simply because they touch more hardware for longer.
- That is much worse than the rate Part 7 derives from Meta's Llama 3 production run (one interruption roughly every two days at Gopala's size).
- The two are different settings (shared research clusters full of short jobs and new code, versus one carefully run production job), but together they bracket what he might see, and Part 7 simulates both.
- For buying, the lesson is that the provider's operational quality (spares on site, fast swaps, health checks that catch bad nodes before jobs do) moves goodput by tens of points, which the score above treats as a 3-point difference in list price.
14. The acceptance test
The acceptance test
Pass โ billed. Fail โ fixed or replaced by the provider first.
- The most important clause is that billing starts only when the delivered block passes a test written into the contract.
Gopala's version, built from the burn-in in Part 6:
- Every node passes the long GPU diagnostic (NVIDIA DCGM level 3) and a 24-hour burn-in with no GPU errors.
- Every node reports 8 GPUs and 8 active 400 Gb/s fabric links, with matching firmware and driver versions.
- NCCL all-reduce bus bandwidth on every node pair, and on the full 1,024 GPUs, is within 10% of the provider's stated figure.
- Storage sustains the stated write bandwidth from all nodes at once for 10 minutes.
- A 72-hour run of his own training job on the whole block completes without a hardware stop.
- If 98% of nodes pass, the passing ones are accepted and billed, and the rest must be fixed or replaced before they are billed.
- This pushes the cost of bad hardware back to the provider, where it belongs.
15. Seven buying mistakes
- Comparing list prices instead of useful prices.
- Accepting "up to 3.2 Tb/s per node" without a topology and an all-reduce number.
- Letting billing start at hand-over rather than acceptance.
- Forgetting storage: a cluster that cannot save a checkpoint quickly wastes GPU time on every save.
- Ignoring egress: moving tens of terabytes of checkpoints out at the end can cost more than a week of compute.
- Splitting the main block across two buildings to save money; a training job cannot span them efficiently.
- Signing without a trial, on the strength of a rating or a famous customer.
16. Negotiating the money terms
A start-up's leverage is small, but some terms move more easily than price:
- Upfront payment. Providers finance their GPUs with debt and like prepayment. Offering a longer term in exchange for a smaller prepayment protects runway; in the scenario he gets 25% upfront instead of 50% by agreeing to 12 months instead of 9.
- Ramp. Paying for a quarter of the block in month 3 and the rest from month 5 matches Part 3's plan and saves several hundred thousand dollars.
- Resale of idle time. The right to hand idle nodes back to the provider's on-demand pool for a share of the revenue.
- Upgrade path. A price for moving part of the block to newer GPUs at renewal, so he is not stuck with H100s if Blackwell-class capacity becomes cheap.
- References. Two current customers of the same size he can call, not the provider's biggest logo.
17. Planning capacity month by month
The reservation is a fixed block, but demand is not. He maps GPU demand by month from Part 3's plan to see how full the block will be:
| Months | Main use | GPUs busy (planned) | Idle risk |
|---|---|---|---|
| 3โ5 | Maestro-0 post-training, bring-up of the rest of the block | 256โ512 | Low: block arrives in stages |
| 5โ6 | Maestro-0 iterations, data-refinery jobs (Part 8) | ~512 | Medium: half the block may idle |
| 6โ9 | Maestro-1 ablations and small MoE runs | 512โ1,024 | Low |
| 9โ10.5 | Main run | 1,024 (all) | None; experiments move to the burst pool |
| 10.5โ15 | Post-training, RSI loop, evaluation | 256โ768 | Medium: resell idle nodes |
- The months with idle risk are where the resale clause and the ramp pay for themselves.
- A block that is 70% busy over the year costs, per useful hour, about 1/0.7 โ 1.4 times its list price before any failure is counted, which is why Part 3's budget counts only training compute and this part adds the rest.
18. The final compute portfolio
| Pool | Size | From | Use | How bought |
|---|---|---|---|---|
| Main block | 1,024 GPUs (128 nodes), one fabric | Month 3 (part early, all by month 5) | Maestro-0 post-training, Maestro-1 experiments and main run | 12-month reservation (scenario) |
| Serving | 64 GPUs | Month 4 | Maestro-0 for design partners, then Maestro-1 | Reserved, separate fabric, separate provider for resilience |
| Burst | 0โ128 GPUs | As needed | Evaluation sweeps, extra ablations | On demand, paid from cloud credits first |
| Storage and data | Object storage | Now | Raw data, checkpoints archive | Hyperscaler with start-up credits |
- The 12-month block costs more than Part 3's plan assumed for training alone, because the block is reserved even when it is between jobs.
- Gopala keeps it busy: Maestro-0 post-training in months 3โ6, experiments in months 6โ9, the main run in months 9โ10.5, and post-training, evaluation and a second smaller run after that.
- Idle weeks would be resold back to the provider under a clause he negotiated (scenario).
19. Delegation box
- The requirements sheet and the scoring weights
- The trial checks and the night ticket
- The final decision and signature
- Normalising quotes into the template
- Running the trial scripts and summarising logs
- A first draft of the contract markup for the lawyer
- A start-up lawyer for the contract
- Two advisers who have run large clusters (references on providers)
- Public ratings such as ClusterMAX for the long list
20. Budget and risk tracker
| Item | Status after Part 4 | Note |
|---|---|---|
| Spend to date | ~$40k (scenario) | Trials, legal fees, deposits |
| Committed | Main block for 12 months (scenario) | Largest commitment in the plan; billing starts at acceptance |
| Time | 14 of ~78 weeks | Delivery from month 3 |
| Compute supply risk | Reduced | Delivery date and penalties signed; two providers |
| Provider quality risk | Unknown until acceptance | Acceptance test written into the contract |
| Cash risk | Acceptable | Upfront payment negotiated to a quarter (scenario) |
21. The series
The Maestro: 18 parts in five phases
- Gopala buys useful hours, not GPU-hours: he prices every offer per useful hour, tests finalists with his own scripts, and makes billing start only when his acceptance test passes.
- The machine now exists on paper.
- Next, Part 5: the power and cooling that physical machine needs, even when someone else runs the building.
22. Reading the numbers
- Primary / standard
- H100 SXM: 80 GB HBM3, ~989 dense BF16 TFLOP/s, 700 W (NVIDIA). ClusterMAX tiers and criteria (SemiAnalysis). Meta's Llama 3 interruption record; 1,024-GPU job MTTF ~7.9 h vs ~47.7 days for 8-GPU jobs in Meta research clusters (Kokolis et al., arXiv:2410.21680). CoreWeave ToS: โฅ99.9% monthly uptime objective for platform instances.
- Secondary โ ๏ธ
- One-year H100 contract prices .70 (Oct 2025) and .35 (Mar 2026), SemiAnalysis figures via a price tracker; Oct 2026 listing ranges and reserved discounts from aggregators. ClusterMAX ratings move every few months; CoreWeave as the only Platinum provider is from the published ratings and the providers' own announcements; a newer edition was reported in Sep 2026 (โ ๏ธ). Price ranges for H100 rental.
- Our assumptions
- Offers P1โP4, all availability and goodput figures, scoring weights, contract outcome, upfront terms and the portfolio.
- Sources
- SemiAnalysis ClusterMAX ยท ClusterMAX: how to rent GPUs
- NVIDIA H100 ยท NVIDIA nccl-tests
- Meta: The Llama 3 Herd of Models ยท Meta FAIR: Revisiting Reliability in Large-Scale ML Research Clusters
- CoreWeave terms of service (SLO) ยท H100 rental prices (secondary) ยท H100 cloud price listings, Oct 2026 (secondary)