THE INSTRUMENTS · Nº 953 · EDITION 1 · LAUNCHING SOON

LUND CARDS · THE INSTRUMENTSNº 953 PROPOSED

THE CARD AS TEXT · FOR EYES AND FOR MACHINES

THE COMPUTE CARD · the compute ledger · FLOPs, memory, watts, cost

WAKES WHEN a model to train: FLOPs, GPU-hours, days and the bill · a compute budget to split into parameters and tokens · a model to serve: tokens per second, and which bound applies · a model to fit: weights, KV cache and how many GPUs · a cluster to power: kW, MW, kWh and CO2 from your grid factor · a price per GPU-hour to turn into cost per million tokens

THE LOOP

NAME
JOB
SPEC
WORK
BOUND
SHOW
HAND OFF
LEDGER

NEVER

Password-cracking or brute-force estimates
Investment, GPU-stock or crypto-mining advice
A spec figure with no source behind it
A price or grid factor the user did not give
A ceiling called a benchmark

IT MAKES train — training FLOPs about 6·N·D (Kaplan et al. 2020), GPU-hours, wall-clock days, the bill from your price; with --gpu-hours, the MFU a reported run implies; chinchilla — compute-optimal tokens, about 20 per parameter (Hoffmann et al. 2022): a rule of thumb; infer — s per token about 2·N; decode bound by memory bandwidth, prefill by compute; says which bound applies; memory — weights + KV cache (2 × layers × kv-heads × head-dim × context × batch × bytes), and the GPUs it needs; energy — and facility power (kW, MW), energy (kWh) and, with your grid factor, CO2; cost — cost per million tokens, or a bill, in your currency; gpus — the built-in accelerator table: memory, bandwidth, dense BF16 and FP8, power; each with its source and date.

THE STANDARD every number shows its formula; spec-sheet figures (memory; peaks are dense, without sparsity; architecture figures (layers, KV heads, head size); the user's inputs stay the user's; no currency is assumed and no price is supplied; never password-cracking or brute-force estimates.

IN THE BOX SKILL.md · CARD.md · the machine · compute.py · 33/33 · references · THE-METHOD by hand · START-HERE · TIN · MY-LEDGER · THE-CLAUSES · LICENSE-NOTE · the doors · HOSTS · system prompts · ten tests · faces · audit · witness.

PROOF SELFTEST 33/33 · witnessed 2026-10-09 · Edition 1.

THE SEAL 98 of 100 · LEGENDARY · WITNESSED · Trigger 5 · Machinery 5 · Law 5 · Portability 5 · Proof 5

IT CAN BE WRONG an AI reading a text file: it can be wrong and can invent a number, a rule, a name or a date; check what matters against your own records and the source; the risk is yours. THE-CLAUSES.md rides in the packet and is part of the licence.

THE PUNCH · SHA-256 OF SKILL.MD · C8AD3C90DB45444A8D147BCE

THE FACE, FULL SIZE → · THE MACHINE FACE → · card.json →

THE COMPUTE CARD

the compute ledger · FLOPs, memory, watts, cost

TRAIN · CHINCHILLA · INFER · MEMORY · ENERGY · COST · GPUS

LEGENDARYWITNESSEDIN CLAUDE IN LUNDR IN CHATGPT

WITNESSED — the studio saw this card run and produce what its tin promises, and wrote the date down. What the marks mean →

THE SPEC SHEET · READ BEFORE YOU BUY · THE STANDARD EVERY CARD MEETS →

SEAL: 98 of 100 · LEGENDARY · WITNESSED
EDITION: E1 · witnessed 2026-10-09
MACHINE: scripts/compute.py · 7 commands · selftest 33/33
RUNS: On your own computer. Standard library only, offline; no account, no key, no telemetry.
HOSTS: Claude · Claude Code · ChatGPT · Gemini · any AI that reads a file (HOSTS.md names each door)
LICENCE: One person, any number of their own AIs and computers · editions replace files · nothing renews · freeze, not loss
PUNCH: C8AD3C90DB45444A8D147BCE · sha-256 of SKILL.md · check any file against it →

CITE THIS CARDTHE COMPUTE CARD, Edition 1. Lund Studio LLC, Westminster, Colorado. https://lundr.tech/?view=compute-card. Punch C8AD3C90DB45444A8D147BCE. Retrieved 2026-10-10.

What it is.

A seat that works the arithmetic of AI compute (training, serving, memory, energy and cost) with every formula, source and assumption shown, for founders, engineers and buyers sizing a model, a cluster or a bill.

Works training FLOPs (6·N·D), GPU-hours, wall-clock days and the bill from your price, or the MFU a reported run implies; splits a compute budget into compute-optimal parameters and tokens (about 20 tokens per parameter, a rule of thumb); gives decode and prefill ceilings in tokens per second and says whether memory bandwidth or compute bounds them; sizes weights, KV cache and training model states against GPU memory and counts the GPUs; works IT and facility power, energy and, with your grid factor, CO2; turns a GPU-hour price and a throughput into cost per million tokens; carries a dated table of accelerator specs, each with its source.

It carries a machine that shows its working: train — training FLOPs about 6·N·D (Kaplan et al. 2020), GPU-hours, wall-clock days, the bill from your price; with --gpu-hours, the MFU a reported run implies; chinchilla — compute-optimal tokens, about 20 per parameter (Hoffmann et al. 2022): a rule of thumb; infer — s per token about 2·N; decode bound by memory bandwidth, prefill by compute; says which bound applies; memory — weights + KV cache (2 × layers × kv-heads × head-dim × context × batch × bytes), and the GPUs it needs; energy — and facility power (kW, MW), energy (kWh) and, with your grid factor, CO2; cost — cost per million tokens, or a bill, in your currency; gpus — the built-in accelerator table: memory, bandwidth, dense BF16 and FP8, power; each with its source and date — 33 checks in its selftest, 7 of its 7 commands on the record. It will never password-cracking or brute-force estimates; never investment, GPU-stock or crypto-mining advice; never a spec figure with no source behind it; never a price or grid factor the user did not give; never a ceiling called a benchmark.

Seven laws, written into the card.

They are in the card itself, so the AI follows them.

EVERY NUMBER SHOWS ITS FORMULAEvery number shows its formula, its source and its limit. A rule of thumb is called one.

SPEC-SHEET FIGURES (MEMORYSpec-sheet figures (memory, bandwidth, dense FLOPS, power) are published figures that change: each is printed with its source and date and can be overridden. A chip with no sourced figure is left out, never guessed.

PEAKS ARE DENSE, WITHOUT SPARSITYPeaks are dense, without sparsity. Serving speeds are roofline ceilings, not benchmarks: say which bound applies, and ask for measured MFU or bandwidth use when the answer matters.

ARCHITECTURE FIGURES (LAYERS, KV HEADS, HEAD SIZE)Architecture figures (layers, KV heads, head size) come from the model's own config file or model card. If they are missing, ask, or count the weights alone and say the KV cache was left out.

THE USER'S INPUTS STAY THE USER'SThe user's inputs stay the user's: price, grid factor, PUE and utilisation are never filled in silently; every default is printed as an assumption.

NO CURRENCY IS ASSUMED AND NO PRICE IS SUPPLIEDNo currency is assumed and no price is supplied.

NEVER PASSWORD-CRACKING OR BRUTE-FORCE ESTIMATESNever password-cracking or brute-force estimates; never investment, GPU-stock or crypto-mining advice.

What rides in the card.

In the card’s own voice, with a machine that shows its working.

THE GUIDESreferences/THE-FORMULAS.md · THE-METHOD.md · THE-SOURCES.md · THE-SPECS.md

THE MACHINEcompute.py · seven commandstrain — training FLOPs about 6·N·D (Kaplan et al. 2020), GPU-hours, wall-clock days, the bill from your price; with --gpu-hours, the MFU a reported run implies; chinchilla — compute-optimal tokens, about 20 per parameter (Hoffmann et al. 2022): a rule of thumb; infer — s per token about 2·N; decode bound by memory bandwidth, prefill by compute; says which bound applies; memory — weights + KV cache (2 × layers × kv-heads × head-dim × context × batch × bytes), and the GPUs it needs; energy — and facility power (kW, MW), energy (kWh) and, with your grid factor, CO2; cost — cost per million tokens, or a bill, in your currency; gpus — the built-in accelerator table: memory, bandwidth, dense BF16 and FP8, power; each with its source and date. Every command prints its working and refuses a bad input; 33 checks in its selftest, 7 of 7 commands on the record.

What it does once your AI has it.

train Training FLOPs about 6·N·D (Kaplan et al. 2020), GPU-hours, wall-clock days, the bill from your price; with --gpu-hours, the MFU a reported run implies
chinchilla Compute-optimal tokens, about 20 per parameter (Hoffmann et al. 2022): a rule of thumb
infer S per token about 2·N; decode bound by memory bandwidth, prefill by compute; says which bound applies
memory Weights + KV cache (2 × layers × kv-heads × head-dim × context × batch × bytes), and the GPUs it needs
energy And facility power (kW, MW), energy (kWh) and, with your grid factor, CO2
cost Cost per million tokens, or a bill, in your currency
gpus The built-in accelerator table: memory, bandwidth, dense BF16 and FP8, power; each with its source and date
On the record The machine, run on real work on 2026-10-09: a FAKE founder's plan (a compute budget, a 7B training run, a 70B model fitted, served and costed, and a 1,000-GPU cluster powered) and three published runs checked: Llama 2 7B, BLOOM and DeepSeek-V3. Run from this packet's own scripts/compute.py before AUDIT.md, WITNESS.md and MANIFEST.md were added (none of them touches SKILL.md, so the punch is the punch of the packet you hold). Output pasted as it printed.

What it will never do.

It will never password-cracking or brute-force estimates; never investment, GPU-stock or crypto-mining advice; never a spec figure with no source behind it; never a price or grid factor the user did not give; never a ceiling called a benchmark.

Training time comes from 6·N·D and an MFU you set; serving speeds are roofline ceilings, not benchmarks; memory counts weights and the KV cache with a reserve for the rest; energy counts the GPU board times PUE. Spec-sheet figures are dated assumptions you can override, and a chip with no sourced figure is left out. It never estimates password cracking or brute force, gives no investment, GPU-stock or crypto-mining advice, and supplies no prices or grid factors. It is an AI reading a text file: it can be wrong, so check what matters against your own records and the source.

Not for an electric car's charging cost or range (THE OBSERVATORY CARD), spreadsheets, password cracking or brute-force estimates, GPU-stock or investment advice, crypto-mining returns, or electricity contracts and data-centre permits (the utility or a qualified engineer).

What’s in the buy.

CARD.md — the whole card: who it is, its laws, when it says no, what it carries · SKILL.md — the door your AI reads first · START-HERE.md — the first five minutes, for you
THE-FORMULAS.md + THE-METHOD.md + THE-SOURCES.md + THE-SPECS.md — the guides in references/, in the card's own voice
scripts/compute.py — the machine: train · chinchilla · infer · memory · energy · cost · gpus, standard library only, selftest 33/33
WITNESS.md — the self-test and the runs on the record, as they printed · MANIFEST.md, every file hashed · AUDIT.md, the twelve checks · tests/, ten tests with their evals
MY-LEDGER.md — the card's memory, on your own machine · TIN.md · LICENSE-NOTE.md · THE-CLAUSES.md
card.svg + card-machine.svg + card.json · card.html, the card as one offline file · HOSTS.md, the door for each host (Claude, Claude Code, ChatGPT, Gemini, Any other AI) · system/, the prompts for any other AI
Also sold as a bot: the same card as instructions and knowledge files for a ChatGPT Project or GPT, a Gemini Gem or a Claude Project (THE BOTS, beside the packet)

PROOF · SELFTEST 33/33 · 7 OF 7 COMMANDS ON THE RECORD · WITNESSED 2026-10-09 · EDITION 1 · PUNCH C8AD3C90DB45444A8D147BCE

ON EVERY DOOR · A CARD FOR YOUR AI, A FILE FOR YOUR COMPUTER

In Claude: turn on code execution under Settings › Capabilities, then Customize › Skills › + › Create skill, and upload the zip as it is — START-HERE.md in the box walks you through it, and tells you how to keep the ledger. In ChatGPT, Gemini and the rest: a Project, a GPT or a Gem with the card’s files attached and the short door in the box pasted as its instructions. The words run anywhere an AI reads Markdown; the machines run wherever the host runs Python. Witnessed in Claude only. The host marks →

Take it.

Nº 953 PROPOSED — LAUNCHING SOON

Sold as is under the term printed. A card instructs an AI you operate; results depend on your model, your files and your judgement. Not medical, legal, tax or financial advice, never the person’s boss, and not a licence to practise. The terms →

ONE PAYMENT · NOTHING RENEWS ITSELF

OFFLINE · ONE LICENCE · PUNCH-CHECKABLE · THE STANDARD

One payment. The file is yours to keep and keeps working at its edition; new editions issued in the year after you buy reach you by email as replacement files. Tax is added at checkout where it applies. Nothing auto-renews.

A TERM, NOT A SUBSCRIPTION: NOTHING RENEWS ITSELF AND NOBODY IS CHARGED AGAIN. WHEN A TERM ENDS THE FILES STAY ON YOUR COMPUTER AND STAY READABLE — FREEZE, NOT LOSS.

THE MACHINE · IN THE OPEN · FROM THE WITNESSED RUN OF 2026-10-09

compute.py, every command showing its working.

A small Python program, standard library only. Your AI runs it; you can too. Every block below is pasted from the card’s own WITNESS.md, as printed.

`train`	training FLOPs about 6·N·D (Kaplan et al. 2020), GPU-hours, wall-clock days, the bill from your price; with --gpu-hours, the MFU a reported run implies
`chinchilla`	compute-optimal tokens, about 20 per parameter (Hoffmann et al. 2022): a rule of thumb
`infer`	s per token about 2·N; decode bound by memory bandwidth, prefill by compute; says which bound applies
`memory`	weights + KV cache (2 × layers × kv-heads × head-dim × context × batch × bytes), and the GPUs it needs
`energy`	and facility power (kW, MW), energy (kWh) and, with your grid factor, CO2
`cost`	cost per million tokens, or a bill, in your currency
`gpus`	the built-in accelerator table: memory, bandwidth, dense BF16 and FP8, power; each with its source and date
`selftest`	33 checks that prove the machine; it must print 33/33

gpus · THE BUILT-IN ACCELERATOR TABLE: MEMORY, BANDWIDTH, DENSE BF16 AND FP8, POWER; EACH WITH

$ compute.py gpus
THE ACCELERATOR TABLE · published spec-sheet figures, checked 2026-10-09; they change, so each is an assumption you can override
key             name                                 mem GB     TB/s    BF16 TF     FP8 TF   watts
a100-sxm-80gb   NVIDIA A100 80GB SXM                   80.0    2.039      312.0          -     400
h100-sxm        NVIDIA H100 SXM                        80.0     3.35      989.5    1,979.0     700
h100-pcie       NVIDIA H100 PCIe                       80.0        2      756.5    1,513.0     350
h200-sxm        NVIDIA H200 SXM                       141.0      4.8      990.0    1,979.0     700
b200            NVIDIA B200 (HGX B200)                180.0      7.7    2,250.0    4,500.0    1000
mi300x          AMD Instinct MI300X                   192.0      5.3    1,307.4    2,614.9     750
mi325x          AMD Instinct MI325X                   256.0        6    1,307.4    2,614.9    1000
tpu-v5p         Google Cloud TPU v5p                  102.0    2.765      459.0      459.0       -
tpu-v6e         Google Cloud TPU v6e (Trillium)        32.0    1.638      918.0          -       -
tpu7x           Google Cloud TPU7x (Ironwood)         206.2     7.38    2,307.0    4,614.0       -
sources:
  a100-sxm-80gb: NVIDIA A100 Tensor Core GPU datasheet (80GB, Nov 2020): 80 GB, 2,039 GB/s, BF16 312 TFLOPS dense (624 with sparsity), max TDP 400 W; no FP8
  h100-sxm: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 3.35 TB/s, BF16 1,979 and FP8 3,958 TFLOPS shown with sparsity, "1/2 lower without sparsity"; up to 700 W (configurable)
  h100-pcie: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 2 TB/s, BF16 1,513 and FP8 3,026 TFLOPS with sparsity (half without); 300-350 W (configurable)
  h200-sxm: Lenovo Press LP1944, NVIDIA HGX H200 product guide (updated 7 Nov 2025), Table 2: 141 GB HBM3e, 4.8 TB/s, BF16 990 and FP8 1,979 TFLOPS without sparsity, 700 W
  b200: Lenovo Press LP2226, NVIDIA HGX B200 product guide (updated 13 Jan 2026), Table 2: 180 GB HBM3e, 7.7 TB/s, BF16 2.25 and FP8 4.5 PFLOPS without sparsity, 1000 W TGP
  mi300x: AMD Instinct MI300X data sheet (2025): 192 GB HBM3, 5.3 TB/s peak, BF16 1,307.4 and FP8 2,614.9 TFLOPS dense, 750 W TBP
  mi325x: AMD Instinct MI325X data sheet (2025): 256 GB HBM3E, 6 TB/s peak, BF16 1,307.4 and FP8 2,614.9 TFLOPS dense, 1000 W max TBP
  tpu-v5p: Google Cloud TPU docs, v5p (last updated 2026-08-11): 95 GiB HBM, 2,765 GBps, BF16 459 and FP8 459 TFLOPS per chip; no power figure there
  tpu-v6e: Google Cloud TPU docs, v6e (last updated 2026-10-07): 32 GB HBM, 1,638 GBps, BF16 918 TFLOPS, INT8 1,836 TOPS per chip; no FP8 or power figure there
  tpu7x: Google Cloud TPU docs, TPU7x (last updated 2026-10-07): 192 GiB HBM, 7,380 GBps, BF16 2,307 and FP8 4,614 TFLOPS per chip; no power figure there
formula: none: a table of published figures; TFLOPS are dense (without sparsity), memory in GB of 10^9 bytes (GiB converted × 1.0737)
source: each row names its sheet; checked 2026-10-09
limit: only accelerators whose figures could be read from a named source are listed; anything else is left out rather than guessed. Pass any other chip's figures with --tflops, --tbps, --mem-gb and --watts.
assumption: a dash means the named source gives no figure

chinchilla · COMPUTE-OPTIMAL TOKENS, ABOUT 20 PER PARAMETER (HOFFMANN ET AL. 2022): A RULE OF THUMB

$ compute.py chinchilla --flops 1e23
COMPUTE-OPTIMAL · a rule of thumb, 20 tokens per parameter
  from C = 1.00e23 FLOPs: N = √(C ÷ (6 × 20)) = 2.89e10 parameters (28.9 billion)
  D = 20 × N = 5.77e11 tokens (577 billion)
formula: D ≈ 20·N and C ≈ 6·N·D, so N ≈ √(C ÷ (6·20)) and D ≈ 20·N
source: Hoffmann et al. 2022, Training Compute-Optimal Large Language Models (Chinchilla), Table 3: about 20 tokens per parameter at every size listed; Chinchilla itself is 70B parameters on 1.4T tokens at Gopher's compute budget
limit: a rule of thumb for the lowest training loss per training FLOP, fitted on that paper's data and setup. It ignores the cost of serving: a model that will answer many requests is often trained on far more tokens per parameter (Llama 3 405B: 15.6T tokens, about 39 per parameter, Dubey et al. 2024).
assumption: the ratio 20 is the default; set --ratio to test another

train · TRAINING FLOPS ABOUT 6·N·D (KAPLAN ET AL. 2020), GPU-HOURS, WALL-CLOCK DAYS, THE BILL FR

$ compute.py train --params 7B --tokens 2T --gpu h100 --gpus 256 --mfu 0.4 --price 2.5
TRAINING · 7 billion parameters on 2 trillion tokens
  training compute C = 6 · N · D = 6 × 7.00e9 × 2.00e12 = 8.40e22 FLOPs
  peak per GPU: 989.5 TFLOPS (dense BF16, NVIDIA H100 SXM)
  sustained per GPU = peak × MFU = 989.5 × 0.40 = 395.8 TFLOPS
  GPU-hours = C ÷ sustained ÷ 3600 = 58,952
  wall-clock on 256 GPUs = 230.3 hours = 9.6 days
  bill = GPU-hours × your price per GPU-hour = 58,952 × 2.5 = 147,381 (in your currency)
formula: C ≈ 6·N·D (+ 6·layers·context·d_model per token when given); GPU-hours = C ÷ (peak × MFU) ÷ 3600; days = GPU-hours ÷ GPUs ÷ 24; implied MFU = C ÷ (peak × GPU-hours × 3600)
source: Kaplan et al. 2020, Scaling Laws for Neural Language Models, Table 1 and section 2.1 (2N FLOPs per token forward, twice that backward); peak from the spec sheet named in `gpus`
limit: N is the parameters each token passes through (for a mixture-of-experts model, the active ones). The attention term is left out unless --layers, --context and --d-model are given; it is about context ÷ (12 × d_model) of the total. Restarts, evaluation, idle GPUs and lost runs are not counted, so real GPU-hours run higher.
assumption: NVIDIA H100 SXM figures are spec-sheet values checked on 2026-10-09 and they change: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 3.35 TB/s, BF16 1,979 and FP8 3,958 TFLOPS shown with sparsity, "1/2 lower without sparsity"; up to 700 W (configurable). Override with --tflops, --tbps, --mem-gb, --watts.
assumption: MFU 0.40 (the default): the share of peak a well-run large job sustains; Llama 3 405B reported 38-43% in BF16 on up to 16K H100s (Dubey et al. 2024). Measure yours.

train · TRAINING FLOPS ABOUT 6·N·D (KAPLAN ET AL. 2020), GPU-HOURS, WALL-CLOCK DAYS, THE BILL FR

$ compute.py train --params 7B --tokens 2T --gpu h100 --gpus 256 --layers 32 --context 4k --d-model 4096
TRAINING · 7 billion parameters on 2 trillion tokens
  training compute C = 6 · N · D = 6 × 7.00e9 × 2.00e12 = 8.40e22 FLOPs
  + attention 6 · layers · context · d_model · D = 6 × 32 × 4,096 × 4,096 × 2.00e12 = 6.44e21 FLOPs (7.67% more)
  C = 9.04e22 FLOPs
  peak per GPU: 989.5 TFLOPS (dense BF16, NVIDIA H100 SXM)
  sustained per GPU = peak × MFU = 989.5 × 0.40 = 395.8 TFLOPS
  GPU-hours = C ÷ sustained ÷ 3600 = 63,474
  wall-clock on 256 GPUs = 247.9 hours = 10.3 days
formula: C ≈ 6·N·D (+ 6·layers·context·d_model per token when given); GPU-hours = C ÷ (peak × MFU) ÷ 3600; days = GPU-hours ÷ GPUs ÷ 24; implied MFU = C ÷ (peak × GPU-hours × 3600)
source: Kaplan et al. 2020, Scaling Laws for Neural Language Models, Table 1 and section 2.1 (2N FLOPs per token forward, twice that backward); peak from the spec sheet named in `gpus`
limit: N is the parameters each token passes through (for a mixture-of-experts model, the active ones). The attention term is left out unless --layers, --context and --d-model are given; it is about context ÷ (12 × d_model) of the total. Restarts, evaluation, idle GPUs and lost runs are not counted, so real GPU-hours run higher.
assumption: NVIDIA H100 SXM figures are spec-sheet values checked on 2026-10-09 and they change: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 3.35 TB/s, BF16 1,979 and FP8 3,958 TFLOPS shown with sparsity, "1/2 lower without sparsity"; up to 700 W (configurable). Override with --tflops, --tbps, --mem-gb, --watts.
assumption: MFU 0.40 (the default): the share of peak a well-run large job sustains; Llama 3 405B reported 38-43% in BF16 on up to 16K H100s (Dubey et al. 2024). Measure yours.

memory · WEIGHTS + KV CACHE (2 × LAYERS × KV-HEADS × HEAD-DIM × CONTEXT × BATCH × BYTES), AND THE

$ compute.py memory --params 70B --bytes 1 --kv-bytes 2 --layers 80 --kv-heads 8 --head-dim 128 --context 32k --gpu h100 --gpus 2
MEMORY · 70 billion parameters at 1 byte each
  weights = N × bytes = 7.00e10 × 1 = 70.0 GB
  KV cache per token per sequence = 2 × layers × kv-heads × head-dim × kv-bytes = 2 × 80 × 8 × 128 × 2 = 327,680 bytes (320.0 KiB)
  KV cache = per token × context × batch = 327,680 × 32,768 × 1 = 10.74 GB
  total = 80.74 GB
  on 80 GB GPUs keeping 10% back: 72.0 GB usable each → 2 GPUs (1.12 GPUs' worth)
  on 2: FITS · 63.3 GB left over
formula: weights = N × bytes; KV = 2 × layers × kv-heads × head-dim × context × batch × kv-bytes; GPUs = ⌈total ÷ (GPU memory × (1 − reserve))⌉; training model states = 16 bytes × N
source: the KV formula and the 7B example as in NVIDIA's Mastering LLM Techniques: Inference Optimization (2023; kv-heads × head-dim in place of hidden size for grouped-query attention); 16 bytes per parameter from Rajbhandari et al. 2020 (ZeRO)
limit: activations, the runtime's own buffers and memory fragmentation are covered only by the reserve; training activations are not counted at all. Splitting a model across GPUs adds copies the sum leaves out. Use the model's config file for layers, KV heads and head size.
assumption: NVIDIA H100 SXM figures are spec-sheet values checked on 2026-10-09 and they change: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 3.35 TB/s, BF16 1,979 and FP8 3,958 TFLOPS shown with sparsity, "1/2 lower without sparsity"; up to 700 W (configurable). Override with --tflops, --tbps, --mem-gb, --watts.
assumption: 10% of each GPU kept back for activations, the runtime and fragmentation (the default; set --reserve to your measured figure)

memory · WEIGHTS + KV CACHE (2 × LAYERS × KV-HEADS × HEAD-DIM × CONTEXT × BATCH × BYTES), AND THE

$ compute.py memory --params 70B --bytes 1 --kv-bytes 2 --layers 80 --kv-heads 8 --head-dim 128 --context 32k --batch 8 --gpu h200
MEMORY · 70 billion parameters at 1 byte each
  weights = N × bytes = 7.00e10 × 1 = 70.0 GB
  KV cache per token per sequence = 2 × layers × kv-heads × head-dim × kv-bytes = 2 × 80 × 8 × 128 × 2 = 327,680 bytes (320.0 KiB)
  KV cache = per token × context × batch = 327,680 × 32,768 × 8 = 85.90 GB
  total = 155.90 GB
  on 141 GB GPUs keeping 10% back: 126.9 GB usable each → 2 GPUs (1.23 GPUs' worth)
formula: weights = N × bytes; KV = 2 × layers × kv-heads × head-dim × context × batch × kv-bytes; GPUs = ⌈total ÷ (GPU memory × (1 − reserve))⌉; training model states = 16 bytes × N
source: the KV formula and the 7B example as in NVIDIA's Mastering LLM Techniques: Inference Optimization (2023; kv-heads × head-dim in place of hidden size for grouped-query attention); 16 bytes per parameter from Rajbhandari et al. 2020 (ZeRO)
limit: activations, the runtime's own buffers and memory fragmentation are covered only by the reserve; training activations are not counted at all. Splitting a model across GPUs adds copies the sum leaves out. Use the model's config file for layers, KV heads and head size.
assumption: NVIDIA H200 SXM figures are spec-sheet values checked on 2026-10-09 and they change: Lenovo Press LP1944, NVIDIA HGX H200 product guide (updated 7 Nov 2025), Table 2: 141 GB HBM3e, 4.8 TB/s, BF16 990 and FP8 1,979 TFLOPS without sparsity, 700 W. Override with --tflops, --tbps, --mem-gb, --watts.
assumption: 10% of each GPU kept back for activations, the runtime and fragmentation (the default; set --reserve to your measured figure)

infer · S PER TOKEN ABOUT 2·N; DECODE BOUND BY MEMORY BANDWIDTH, PREFILL BY COMPUTE; SAYS WHICH

$ compute.py infer --params 70B --bytes 1 --kv-bytes 2 --gpu h200 --gpus 2 --batch 8 --prompt 2k --layers 80 --kv-heads 8 --head-dim 128 --mbu 0.7 --mfu 0.5
SERVING · 70 billion parameters at 1 byte on 2 × NVIDIA H200 SXM, batch 8
  FLOPs per generated token ≈ 2 · N = 1.40e11
  peak compute = 1,979.0 TFLOPS (dense FP8, NVIDIA H200 SXM) × 2 × MFU 0.50 = 1.98e15 FLOPS
  bandwidth = 4.8 TB/s × 2 × MBU 0.70 = 6.72e12 bytes/s
  DECODE, one step for the whole batch:
    bytes read = weights 70.0 GB + KV cache 5.37 GB (2,048 tokens × 8 sequences) = 75.37 GB
    memory time = bytes ÷ bandwidth = 11.22 ms · compute time = 2 · N · batch ÷ peak = 0.566 ms
    BOUND: MEMORY BANDWIDTH (arithmetic intensity 14.86 FLOPs/byte against the ridge at 294.5)
    ceiling: 89.2 tokens/s per sequence · 713.3 tokens/s for the batch
    the KV reads grow with the batch as fast as the compute does, so at this context it stays memory-bound at any batch
  PREFILL of 2,048 prompt tokens × 8: FLOPs = 2 · N · prompt · batch = 2.29e15
    compute time 1,159 ms · weight read 10.42 ms → BOUND: COMPUTE · time to first token at least 1,159 ms
  memory: weights + KV = 75.4 GB against 282 GB on 2 GPUs: fits before overheads
formula: decode step time = max(bytes read ÷ bandwidth, 2·N·batch ÷ peak); tokens/s per sequence = 1 ÷ step time; prefill = 2·N·prompt·batch ÷ peak; ridge = peak ÷ bandwidth
source: Kaplan et al. 2020 (2N FLOPs per token forward); the roofline model, Williams, Waterman and Patterson 2009 (a step is bound by whichever of compute or memory traffic takes longer); peaks from `gpus`
limit: a ceiling, not a benchmark: attention FLOPs, the KV writes, communication between GPUs, scheduling and kernel efficiency are left out. Real servers reach a fraction of it; measure and set --mbu and --mfu.
assumption: NVIDIA H200 SXM figures are spec-sheet values checked on 2026-10-09 and they change: Lenovo Press LP1944, NVIDIA HGX H200 product guide (updated 7 Nov 2025), Table 2: 141 GB HBM3e, 4.8 TB/s, BF16 990 and FP8 1,979 TFLOPS without sparsity, 700 W. Override with --tflops, --tbps, --mem-gb, --watts.
assumption: compute peak in FP8 because the weights are 1 byte or less

cost · COST PER MILLION TOKENS, OR A BILL, IN YOUR CURRENCY

$ compute.py cost --gpu-hour-price 3.10 --tokens-per-second 713.3 --gpus 2 --utilisation 0.6
COST PER MILLION TOKENS
  tokens per hour = tokens/s × 3,600 × utilisation = 713.3 × 3,600 × 0.60 = 1,540,728
  cost per hour = price per GPU-hour × GPUs = 3.1 × 2 = 6.2
  cost per million tokens = cost per hour ÷ (tokens per hour ÷ 1,000,000) = 4.0241 (in your currency)
formula: cost per million = price × GPUs ÷ (tokens/s × 3600 × utilisation ÷ 10^6)
source: arithmetic; the price and the throughput are yours (measure the throughput, or take the ceiling from `infer`)
limit: one throughput for all tokens: prompt tokens (prefill) and generated tokens (decode) run at very different speeds, so cost them in two runs. No currency is assumed.

energy · AND FACILITY POWER (KW, MW), ENERGY (KWH) AND, WITH YOUR GRID FACTOR, CO2

$ compute.py energy --gpus 1000 --gpu h100 --days 30 --pue 1.3 --grid-kg-per-kwh 0.35
ENERGY · 1,000 GPUs at 700 W for 720.0 hours
  IT power = GPUs × watts × load = 1,000 × 700 W × 1.00 = 700.0 kW
  facility power = IT × PUE = 700.0 × 1.30 = 910.0 kW = 0.91 MW
  energy = GPU-hours × watts × load × PUE ÷ 1000 = 720,000 × 700 × 1.00 × 1.30 ÷ 1000 = 655,200 kWh = 655.2 MWh
  CO2 = kWh × your grid factor = 655,200 × 0.35 kg/kWh = 229,320 kg = 229.32 t
formula: IT kW = GPUs × W × load ÷ 1000; facility kW = IT kW × PUE; kWh = GPU-hours × W × load × PUE ÷ 1000; CO2 = kWh × grid factor
source: PUE = total facility energy ÷ IT equipment energy (The Green Grid; ISO/IEC 30134-2:2016); the grid factor is yours
limit: the GPU figure is the board alone: the rest of each server (CPUs, memory, network, fans) adds power it leaves out; use the server's measured draw ÷ its GPUs for a closer figure. Grid factors vary by place and hour; the card supplies none.
assumption: NVIDIA H100 SXM figures are spec-sheet values checked on 2026-10-09 and they change: NVIDIA H100 Tensor Core GPU datasheet (Feb 2023): 80 GB, 3.35 TB/s, BF16 1,979 and FP8 3,958 TFLOPS shown with sparsity, "1/2 lower without sparsity"; up to 700 W (configurable). Override with --tflops, --tbps, --mem-gb, --watts.
assumption: watts per GPU = the board's maximum power from the spec sheet (700 W)
assumption: load 1.00: every GPU at its maximum power the whole time; set --load to the average share you measured

train · TRAINING FLOPS ABOUT 6·N·D (KAPLAN ET AL. 2020), GPU-HOURS, WALL-CLOCK DAYS, THE BILL FR

$ compute.py train --params 7B --tokens 2T --gpu a100 --gpu-hours 184320
TRAINING · 7 billion parameters on 2 trillion tokens
  training compute C = 6 · N · D = 6 × 7.00e9 × 2.00e12 = 8.40e22 FLOPs
  peak per GPU: 312.0 TFLOPS (dense BF16, NVIDIA A100 80GB SXM)
  reported GPU-hours: 184,320
  implied MFU = C ÷ (peak × GPU-hours × 3600) = 8.40e22 ÷ (3.12e14 × 184,320 × 3600) = 0.406
formula: C ≈ 6·N·D (+ 6·layers·context·d_model per token when given); GPU-hours = C ÷ (peak × MFU) ÷ 3600; days = GPU-hours ÷ GPUs ÷ 24; implied MFU = C ÷ (peak × GPU-hours × 3600)
source: Kaplan et al. 2020, Scaling Laws for Neural Language Models, Table 1 and section 2.1 (2N FLOPs per token forward, twice that backward); peak from the spec sheet named in `gpus`
limit: N is the parameters each token passes through (for a mixture-of-experts model, the active ones). The attention term is left out unless --layers, --context and --d-model are given; it is about context ÷ (12 × d_model) of the total. Restarts, evaluation, idle GPUs and lost runs are not counted, so real GPU-hours run higher.
assumption: NVIDIA A100 80GB SXM figures are spec-sheet values checked on 2026-10-09 and they change: NVIDIA A100 Tensor Core GPU datasheet (80GB, Nov 2020): 80 GB, 2,039 GB/s, BF16 312 TFLOPS dense (624 with sparsity), max TDP 400 W; no FP8. Override with --tflops, --tbps, --mem-gb, --watts.

energy · AND FACILITY POWER (KW, MW), ENERGY (KWH) AND, WITH YOUR GRID FACTOR, CO2

$ compute.py energy --gpu-hours 1082990 --watts 400 --pue 1 --grid-kg-per-kwh 0.057
ENERGY · 1,082,990 GPU-hours at 400 W
  energy = GPU-hours × watts × load × PUE ÷ 1000 = 1,082,990 × 400 × 1.00 × 1.00 ÷ 1000 = 433,196 kWh = 433.2 MWh
  CO2 = kWh × your grid factor = 433,196 × 0.057 kg/kWh = 24,692 kg = 24.69 t
formula: IT kW = GPUs × W × load ÷ 1000; facility kW = IT kW × PUE; kWh = GPU-hours × W × load × PUE ÷ 1000; CO2 = kWh × grid factor
source: PUE = total facility energy ÷ IT equipment energy (The Green Grid; ISO/IEC 30134-2:2016); the grid factor is yours
limit: the GPU figure is the board alone: the rest of each server (CPUs, memory, network, fans) adds power it leaves out; use the server's measured draw ÷ its GPUs for a closer figure. Grid factors vary by place and hour; the card supplies none.
assumption: load 1.00: every GPU at its maximum power the whole time; set --load to the average share you measured

cost · COST PER MILLION TOKENS, OR A BILL, IN YOUR CURRENCY

$ compute.py cost --gpu-hour-price 2 --gpu-hours 2.788M
BILL · 2,788,000 GPU-hours at 2 per GPU-hour
  bill = GPU-hours × price = 2,788,000 × 2 = 5,576,000 (in your currency)
formula: bill = GPU-hours × price per GPU-hour
source: arithmetic; the price is yours
limit: rental only: storage, networking, staff, failed runs and the experiments before the final run are not in it.

train · TRAINING FLOPS ABOUT 6·N·D (KAPLAN ET AL. 2020), GPU-HOURS, WALL-CLOCK DAYS, THE BILL FR

$ compute.py train --params 7B --tokens 2T --gpu a100 --dtype fp8
error: NVIDIA A100 80GB SXM has no sourced dense FP8 figure in the table; give --tflops from its spec sheet, or use --dtype bf16

gpus · THE BUILT-IN ACCELERATOR TABLE: MEMORY, BANDWIDTH, DENSE BF16 AND FP8, POWER; EACH WITH

$ compute.py gpus h900
error: no GPU called 'h900' in the table; the table holds: a100-sxm-80gb, h100-sxm, h100-pcie, h200-sxm, b200, mi300x, mi325x, tpu-v5p, tpu-v6e, tpu7x. Never guess a spec: take it from the maker's sheet and pass it with --tflops, --tbps, --mem-gb, --watts

THE RUNS ARE PASTED FROM THE CARD’S OWN WITNESS.MD AS PRINTED. FIGURES MARKED FAKE ARE THE STUDIO’S OWN EXAMPLES, INVENTED FOR THE RECORD; PUBLISHED FIGURES ARE NAMED WITH THEIR SOURCES. NO PRIVATE PERSON IS NAMED.

QUESTIONS AT THE TABLE

Asked before the wire.

What does it need from me?

Name. Ask what the work is and what it must agree with.

Does it send anything anywhere?

No. The machine is a standard-library Python program that runs on your own computer and sends nothing anywhere; the words run wherever an AI reads Markdown. No server, no account, no key.

What is on the record?

The self-test (33/33) and 7 of its 7 commands run on real inputs, pasted into WITNESS.md as they printed; the punch on the face is the SHA-256 of SKILL.md, so a downloaded copy can be checked against this room.

Can it be wrong?

Yes — it is an AI reading a text file. Training time comes from 6·N·D and an MFU you set; serving speeds are roofline ceilings, not benchmarks; memory counts weights and the KV cache with a reserve for the rest; energy counts the GPU board times PUE. Spec-sheet figures are dated assumptions you can override, and a chip with no sourced figure is left out. It never estimates password cracking or brute force, gives no investment, GPU-stock or crypto-mining advice, and supplies no prices or grid factors.

What will it never do?

← THE INSTRUMENTS · THE FLOOR →