The Numbers Behind Built to Last & LOOP

Abstract

Two games, two simulation models, zero hidden math

Every result either game shows a player — a company valuation, a CO₂e figure, an end-of-run verdict — is computed from a numeric model. This paper documents those models in full: the state variables, the per-industry parameters, the yearly update equations, the scoring formulas, and the rationale behind every coefficient.

Built to Last is a deterministic, equation-driven business simulation: a company makes one durable product over 10, 20, or 30 years, and the thesis under test is that longevity is a financial strategy that compounds. LOOP is a 90-second arcade round whose every point value encodes the waste hierarchy, and whose end-screen impact figures are calibrated against published life-cycle-assessment literature. We treat the two differently on purpose, and we say which is which.

Provenance Every formula and constant below is transcribed directly from the games' shipping simulation code.

1 · What the model is

You run a company that makes one durable product — washing machines, smartphones, or backpacks — for 10, 20, or 30 years. Each year you see one news event and a small hand of decision cards; you pick one card; the model advances one year and shows you the consequences. At the end it scores your company's Sustainable Enterprise Value and names the kind of company you built.

Three properties matter for reading the rest of this paper:

• Deterministic. The yearly economic step is a pure function of state. There is no randomness in the game loop. Given an industry, a scenario length, a seed, and your sequence of decisions, the entire run is reproducible to the last euro.
• The seed only permutes event order. The seed is consumed exactly once, at construction, to pick a swap permutation over the authored timeline. It never injects noise into a calculation — it just changes which year a given event lands.
• Equation-driven. Everything below — durability, demand, share, service, financials, trust, the slow drift of the world — is a closed-form update applied once per year. No agent-based simulation, no Monte Carlo. That is what makes it legible enough to document exhaustively.

2 · State variables

Everything the model knows about your company at the start of a year fits in three groups: the six levers you steer, the market and economic state, and five hidden world forces you can nudge but never set directly.

3 · The three industries

Each industry is a full parameter set, and the differences are the whole game's texture. Phones are a knife-fight: short lives, huge market, brutal margins, everyone sealing everything shut. Machines are heavy and beloved, with a service market hiding in plain sight. Backpacks are cheap, sturdy, and eminently repairable — lifetime-repair legends and landfill mountains are both made here. The table is transcribed verbatim from the model's industry definitions.

The parameters encode the archetypes directly. Smartphones: a 3.2-year base life, a 6-million-unit market with a thin 5% start, a high 1.6 elasticity, and a 60% starting parts-price habit — short-lived, high-churn, gouge-prone. Their CAPEX_SCALE of 2.5 means every project costs 2.5× the machines-denominated sticker on the card; their footprint per unit is tiny (0.06 t) but they ship in enormous volume. Washing machines: an 8-year life, an 80 €/unit service base — the richest service market — and a heavy 0.45 t footprint per unit. Backpacks: cheap to build (72 €), highly repairable from the start (r0=0.50), almost weightless to make (0.012 t), but with a tiny 10 M€ cash cushion and a punishing −6 M€ credit line — there is no room for error. The lopsided EFF_REF values (13 vs 45 vs 470 IB-years/kt) simply normalize the efficiency term of the score to each industry's physical reality.

4 · The yearly tick

One click advances one year. Internally that is a fixed pipeline, run once, in this order. The numbering follows the model's own internal step labels (which group the event/decision steps as 1–3 and skip a vestigial 4). Crucially, the event resolution order depends on what the event is: judgments of the past — scandals, exposés, virality — resolve on pre-decision state (you cannot un-scandal yourself by picking the quality card the same year), while tests of the present — audits, labels, teardowns, trends — resolve after your decision, so answering the news can actually change the verdict.

5 · Core formulas

One formula card per system. Each equation is the model's actual yearly update; each coefficient is a named constant — every one listed, with its meaning, in the appendix — quoted with the intent recorded beside it in the source. mod(key) denotes the product (for mult) or sum (for add) of any active timed modifiers from cards and events; clamp01 clamps to [0, 1].

Durability & churn

life          = LIFE_BASE · (0.6 + 0.9·q) · (1 + 0.35·r) · mod(life)
failures      = installedBase / max(0.5, life)
repairedShare = clamp( r · (0.2 + 0.8·sn) · (1 − 0.45·pp),  0,  0.95 )
exits         = failures · (1 − repairedShare)

Demand & share

rcPass      = (RC · mod(rc)) ^ 0.6
price       = priceMult · P0 · rcPass
marketAvg   = P0 · rcPass · (1 − 0.2·(C − 0.5)) · mod(avgPrice)
priceComp   = clamp01( 0.5 − ELASTICITY·(price − marketAvg)/marketAvg )
attract     = 0.40·priceComp + 0.25·trust + 0.25·L·(q+r)/2
            + 0.15·reach − 0.20·(C − 0.5)
attract    += clamp( 0.5·(trust − 0.5)·min(1.5, IB/IB0), −0.08, 0.25 )   // WOM
sig         = 1 / (1 + e^(−3.5·(attract − 0.5)))
shareTarget = clamp( share0·(0.18 + 2.0·sig),  0.3·share0,  3.5·share0 )
share      += (shareTarget − share) · 0.35
loyalty     = min(0.7, 0.25 + 0.35·trust)
conquest    = MARKET_UNITS · share · mod(market) · mod(conquest)
unitsSold   = max(0, exits·loyalty + conquest)·mod(sales) + extraUnits

Service revenue

attach     = repairedShare
if r ≥ 0.5:  attach ·= (1 + 0.2·REG)          // right-to-repair expands the market
attach     = min(1, attach)
serviceRev = installedBase · attach · SERVICE_REV_BASE · (1 + 0.8·pp) / 1000 · mod

Financials

units0       = MARKET_UNITS · share0
scaleEcon    = clamp( (unitsSold/units0)^(−0.07),  0.75,  1.25 )
unitCost     = BASE_COST · baseCostFactor
             · (1 + 0.55·(q−0.5) + 0.18·(r−0.5)) · (RC·mod) · mod · scaleEcon
productGross = unitsSold · (price − unitCost) / 1000
serviceGross = serviceRev · 0.55
compliance   = max(0, REG·0.7 − r) · 25 · REG · unitsSold / 1000
footprint    = unitsSold · FP_UNIT · (1 − 0.15·r)
carbon       = carbonTax ? footprint · 90 / 1000 : 0
snCost       = 2.5 · sn · CAPEX_SCALE
interest     = cash < 0 ? 0.08 · (−cash) : 0
profit       = productGross + serviceGross − opex − snCost
             − compliance − carbon − interest

Trust hysteresis

target = 0.50 + 0.35·(q−0.5) + 0.25·(r−0.5) + 0.15·(0.5−pp)
       + 0.15·sn·min(1, IB/IB0) − 0.20·max(0, priceMult − 1 − 0.6·q)
target = clamp01( target + mod(trustTarget) )
rate   = (target > trust) ? 0.12  /* earning */  : 0.55  /* losing */
trust += (target − trust) · rate

World dynamics

L     += 0.015                                   // longevity taste drifts up
RC     = min(2.5, RC · 1.015)                    // resource costs compound
REG   += 0.008 · L            // unless a lobby froze it this year
reach ·= 0.6                                     // campaigns fade
H      = clamp01( 0.9·H + 0.06·max(0, 0.5 − (q+r)/2) )       // regulatory heat
C      = clamp01( C + (0.5 − C)·0.10 + (shareGrowth > 0.15 ? 0.04 : 0) )

6 · Decisions & events

The model's inputs reach it through two channels: the decision card you choose each year, and the event the year hands you. Both are just structured bundles of the same numeric deltas the equations above consume.

How a choice becomes numbers

step(d)        = clamp(d, −0.20, +0.20)           // no lever teleports in one year
q,r,pp,sn     += clamp01( lever + step(Δ) )
cash          += cashCapex · CAPEX_SCALE          // card costs are machines-M€
priceMult      = clamp(priceMult · Δ,  0.5,  2.5)
baseCostFactor = clamp(baseCostFactor · Δ,  0.65,  1.15)
modifiers.push(...)                               // timed mult/add effects, tick yearly

Gates & the once-per-run deal memory

Two mechanisms keep the hand honest. Gates (eligible) only deal a card while its full advertised effect actually fits the state — you cannot seal an already-sealed design, pledge fair prices when your prices are already fair, or promise a ten-year warranty without the quality to back it. Permanent deal memory means any card put in a hand — chosen or not — is barred for the rest of the run. The sole exemptions are the two structural fixtures (STEADY_HAND, EMERGENCY_LOAN) and the two price dials (designed-repeatable). When a slot's authored chain is exhausted, a deterministic pool fallback deals a fresh card; only if the entire non-dial pool is spent does a dial valve fire. A pool-arithmetic test proves the 66 non-dial cards available per industry cover the worst case (a 30-year Marathon deals 58 distinct cards) — so a player never sees the same project twice.

Four representative cards

Notice the symmetry the model enforces: Seal It Shut buys an 11% unit-cost cut by destroying 0.20 of repairability and raising regulatory heat — exactly the levers that, three years later, feed a worse teardown verdict, a thinner service market, and a compliance bill. The card is a loan against the future, and the equations are the lender.

The 37-event system

Events are authored copy plus an outcome() function. 9 of the 37 resolve after your decision (audits, labels, teardowns, trends — so your answer can change the verdict); the rest resolve before it (scandals, exposés, virality — judgments of a past you can't retroactively fix). Many branch on state, so the same headline rewards a prepared company and punishes an exposed one.

The scandal's recall cost shrinking with quality (·(1 − 0.5·q)) is a representative detail: a well-built fleet is cheaper to recall. The model rarely lands a flat penalty — it asks the state what you deserve.

7 · Scoring — Sustainable Enterprise Value

A run's final number is its Sustainable Enterprise Value (SEV), in M€. It is four value terms summed, then scaled by two multipliers that reward the things the game is actually about — earned trust and material efficiency.

runRate   = 6.0 · avg(profit over last 3 years)      // SEV_PROFIT_W
cash      = 1.0 · finalCash                           // SEV_CASH_W
service   = 2.5 · finalServiceGross                   // SEV_SERVICE_W
base      = installedBase · UV / 1000                 // book value of the fleet
trustMult = 0.75 + 0.5 · trust                        //  → 0.75 … 1.25
eff       = Σ installedBase / footprintCum            // IB-years per kt emitted
effMult   = clamp( 0.85 + 0.5·(eff − EFF_REF)/EFF_REF,  0.8,  1.2 )
SEV       = max(0, (runRate + cash + service + base) · trustMult · effMult)

These baselines are not arbitrary — they are calibrated (§9), set at roughly 80% of the strongest reference-strategy median for each cell. sevPct = SEV / BASELINE_SEV is what the archetype classifier reads, so "beating the reference" means clearing ≈1.0.

8 · Archetypes

Every finished run is labelled as exactly one of 11 archetypes (ordered rules, first match wins). The 2026 rework made every lever judgment industry-relative: measured against the industry's own starting habit long0 = (q0+r0)/2, because industries begin with very different defaults (phones 0.375, machines 0.475, backpacks 0.55). The headline metrics: longRel = your average product virtue minus that habit; sevPct = SEV ÷ baseline; offender = a deeds test (≥ max(4, 25% of years) on cheap-tag cards, with longevity picks ≤ 34% of them).

The ordering encodes a moral hierarchy the designers will defend: a genuine turnaround (Pivot Artist) outranks the offender verdicts, so a redeemed company isn't averaged back down into its worst years; and cheap play only earns the grudging Volume Machine when it actually beats the reference — otherwise it is The Throwaway, score or no score.

The bankruptcy post-mortem

A run that hits the credit line gets a gentle, named cause of death — diagnosed from the record, never mocking:

• The Scandal Spiral — a trust shock landed within 4 years of the end.
• The Price War — you sold below unit cost for ≥ 2 years (PM_PRICEWAR_YEARS).
• The Overreach — capex in the final 3 years exceeded 1.5× your starting cash (PM_OVERREACH_SPEND).
• The Slow Bleed — no single mistake; margins quietly went somewhere else (the default).

9 · Calibration methodology

This is the honest answer to "where do the numbers come from?" — and it is the part most unlike a citation. Built to Last is tuned the way a game is tuned: against itself, by robots, until it is fair.

• Deterministic robot playtest. Two reference strategies — a cheap bot that never borrows and a longevity bot that bridges a red year rather than abandon the build — play every industry × scenario × seed. Because the economy is a pure function of state, these runs are exactly reproducible, and the very same bots draw the dashed comparison lines on the end screen. The dashed lines are not illustrations; they are the certified reference.
• Baselines at ≈80% of the strongest robot median. The BASELINE_SEV table is set just below what the best reference strategy typically achieves in each cell (the test harness prints the medians on demand). A human who plays well clears it; a human who plays carelessly does not. Score targets are earned, not gifted.
• The goal is "no single strategy dominates." The hot dials — elasticity, the word-of-mouth flywheel, the cost of quality, the share inertia, the trust hysteresis — are tuned so that cheap play wins on short clocks, longevity wins on long ones, and several distinct paths can clear the baseline. If one strategy swept every cell, the game would have no argument to make.

In plain terms The Built to Last numbers are design decisions calibrated for a fair, legible game, not empirical estimates of real washing-machine economics. They are internally consistent and directionally sensible — quality really does cost money, trust really is slow to earn — but they are ours, chosen, and open to your critique.

1 · What the model is

A fixed-timestep arcade round on a logical 390×844 portrait canvas. Products fall; you flick each into one of four rings. There is no lose-state and no tuning fragility: hard caps bound the worst case by construction, and a daily seed makes every player's track identical, so the leaderboard is a pure skill comparison. Two number systems matter — the scoring (which encodes the waste hierarchy) and the impact (which is the genuinely sourced part).

2 · The mechanic model

The four rings are the EU waste hierarchy, fixed left-to-right forever: Repair · Reuse · Refurbish · Recycle. A product's condition state determines its correct ring — the player never adjudicates a fuzzy classification, they read a badge:

Scoring formula

points     = round( base(ring) · comboMult · goldenMult )
comboMult  = 1 + 0.1 · min(comboBefore, 10)        // caps at ×2.0; resets on miss
goldenMult = golden ? 5 : 1                         // "Designed to Matter"
base       = Repair 120 · Reuse 110 · Refurbish 100 · Recycle 80
             (during the 8 s Right-to-Repair window, Repair base = 240)
end bonus  = CLOSED LOOP +1000   (no losses, no wrong rings — subsumes Zero Waste)
           = ZERO WASTE  +500    (no landfill losses)

Determinism & anti-cheat

The day's seed is HMAC(secret, gameId + Europe/Berlin date). Both client and server expand it with the same pure PRNG (cyrb128 string-hash → sfc32) into the full 90-second script — spawn times, positions, product/state sequence, golden and power-up placements. The client applies score events one at a time as you play; the server re-folds the submitted event log through the identical reducer and rejects any score that doesn't reproduce. Plausibility caps back it up: a product can't resolve faster than 150 ms after spawning, at most 8 wrong bounces per product, at most 400 events per round.

3 · The impact model — the genuinely sourced part

Unlike Built to Last, LOOP's environmental numbers are calibrated against published life-cycle-assessment literature, named below. The end screen turns your round into kept materials, avoided CO₂e and retained value with one formula:

impact = Σ  ( product.footprint × ring_retention )   over every product you looped
              ringRetention:  Repair 0.9 · Reuse 0.9 · Refurbish 0.7 · Recycle 0.25
carKmEquivalent = co2Kg / 0.15        // 0.15 kg CO₂e per car-km, EU fleet tailpipe

The retention values are not invented. WRAP/ERM's washing-machine LCA finds refurbishment "effectively postpones the need to produce a new machine" at near-negligible impact (consistent with the 0.7–0.9 range), while Öko-Institut's end-of-life recycling credit recovers only ~18% of production GWP even for a steel-rich appliance — the favourable case; electronics and textiles recover less. Recycle is defensible anywhere in 0.2–0.25; we use 0.25.

Honest flags Five rows are provisional — bicycle, coffee machine, power drill, headphones, backpack carry order-of-magnitude sanity only, no verified LCA anchor. They are flagged in the source data itself and would benefit from a dedicated source pass (Trek / Shift Cycling Culture for bicycles; ADEME Base Empreinte or brand PCFs for the small appliances and accessories). The car-km factor is 0.15 kg CO₂e/km = EU fleet-average real-world tailpipe (EEA: new cars ~128 g/km real-world 2024, older fleet ~150–180). Tailpipe basis on purpose: the product side is production-only CO₂e, so a lifecycle car factor (~0.19–0.25) would mix scopes and overstate the equivalence. The end screen carries a one-line methodology note — "illustrative magnitudes based on published lifecycle data" — because honesty is the anti-preachiness insurance with a research audience.

Sources (multi-source adversarial verification): Apple iPhone 16 PER (Sept 2024) · Dell & Lenovo product carbon footprints · Samsung QLED 75Q60C environmental report (Carbon Trust certified) · Öko-Institut eco-efficiency analysis of washing machines (2005) · WRAP/ERM washing-machine replacement & refurbishment LCA (2010, ISO-reviewed) · EEB "Coolproducts don't cost the Earth" (2019) · Levi's 501 LCA (2015) · MIT footwear LCA (J. Cleaner Production 2013) · Gallego-Schmid et al. (STOTEN 2018) · ADEME Base Carbone.

4 · Physics constants (brief)

The rest of LOOP's numbers are "feel" constants — they make the flick satisfying and the round soothing. They are explicitly not claims about reality; we list them for completeness, not for scrutiny.

A game is not an oracle. We will say it once more, plainly, because it is the most important sentence in this document: neither model predicts the future, and neither is meant to.

What they are built to be is internally consistent and directionally realistic. Inside Built to Last, quality genuinely costs money, trust is genuinely slow to earn and fast to lose, a service business genuinely compounds, and a world genuinely drifts toward repair — and every one of those relationships is a number you can see above and argue with. Inside LOOP, the points genuinely encode the waste hierarchy, and the impact figures are genuinely anchored to published LCA work, with the unverified rows genuinely flagged.

The two games earn your trust differently, and we have been careful not to blur them. Built to Last's constants are calibrated design choices — honest about being ours. LOOP's impact constants are sourced estimates — honest about their anchors and their gaps. We manufactured no citations for the former and invented no numbers for the latter.

AI Research & Technology Lab  ·  for the Nuremberg Institute for Market Decisions  ·  MDD26

Appendix

Full constant reference

The complete promise delivered: every constant in both models, grouped by system, with its value and one-line meaning. Built to Last contributes ~250 values; LOOP its scoring, schedule, catalog and impact constants. Magnitudes are exact.

A · Built to Last — the global economy

B · Built to Last — decision cards

Card capex is in machines-M€ (× the industry's CAPEX_SCALE); years are modifier durations; drifts are per-year lever deltas. Every value is the game's named balance constant.

C · Built to Last — events

D · LOOP — scoring, schedule & impact

End of reference If a number here doesn't match the live game, the live game wins — this document mirrors the model the game runs, but the game itself is the source of truth. Every value above was transcribed on the 2026 build; corrections and disagreements are welcome.