The Intelligence Factory

An interactive explainer of an AI campus, built from cited public sources: follow power from a 345 kV line to a GPU die at 0.8 V, data from HBM out across NVLink, optics and long-haul fiber, and heat from the die to the air above the roof. Six scales, from the US grid to a 10 cm package.

This is a personal educational project based on cited public sources. It is not an official publication of my employer or of the companies it discusses. The 3D models are schematic, not vendor CAD; routes and layouts are illustrative; the scenario outputs are estimates from a simple model, not an engineering design or a procurement specification. Product and performance claims are attributed to the companies that make them.

It is also a small model. Pick a campus size (10 MW to 5 GW), an accelerator (H100, GB200, GB300, Rubin), a power path (415 V AC or 800 V DC) and cooling (air, chilled liquid, warm water), or start from a real campus, and every scene, chart, count and sentence recomputes. Pin a scenario to compare against it. The model covers NVIDIA systems only; Google TPUs, AWS Trainium and AMD Instinct appear as cited comparisons, not as models.

Figures shown with a label say what kind of statement they are: Spec (the maker or a standards body publishes it), Vendor (a vendor's own comparison, attributed, with its baseline), Reported (a named third party states it), Calc. (this model calculates it) or Assumed (the model picks a value where no single published figure applies). Click a label to see what backs that figure: its sources and where in each, the calculation, or the assumption. The Evidence page lists them all, the Method page lists every calculation and assumption, and the research notes behind them are in research/. Sources were checked on the dates the Evidence page shows; the web moves, so a figure is only as current as its check.

Run

npm install
npm run dev        # http://127.0.0.1:47400
npm test           # engine, clock, content, links and journeys
npm run typecheck
npm run build      # static site in dist/, relative paths, ready for GitHub Pages
npm run artifact   # dist-artifact/: the same page shaped for a claude.ai artifact

Live at https://reedos.dev/intelligence_factory/, served by a Cloudflare Worker with static assets on the route reedos.dev/intelligence_factory/* (the rest of reedos.dev is GitHub Pages). Deploy by hand, both typecheck, test and build first:

• gh workflow run cloudflare.yml --ref main — production (tools/cloudflare-stage.mjs mounts the build under the path, adds _headers caching and _redirects for the root and extensionless URLs).
• gh workflow run pages.yml --ref main — GitHub Pages, kept current as the fallback: delete the Worker route and GitHub serves the same build again.

Every push to another branch also builds a preview at https://<branch>.intelligence-factory-dly.pages.dev/.

The project's own code and text are under the MIT license (LICENSE). Third-party code, fonts and data keep their own terms, and the hero images' rights status is unresolved: see THIRD_PARTY_NOTICES.md.

Links: ?mw=&accel=&power=&cooling=&site= sets the scenario and ?view=scene.layer.part opens a view. The visualizer's guided-tour player and clock strip are parked at the git tag parked/tours-clock (the tour content in src/app/journeys.js and the clocks in src/model/clock.ts stay, for the Evidence and Method pages); old tour links such as #story, #watt, #request and #heat still work, but index.html now forwards them, along with any ?view= or ?clock= link, straight into the visualizer at the right part instead of starting a tour. The page keeps its address bar current, and Share copies it.

Layout

• src/model/engine.ts — the scenario engine: rack power bottom-up, PUE, fabric, ledger, counts
• src/model/clock.ts — four simulations: training swings, grid outage, hot day, inference day
• src/model/sites.ts — real campuses, state grid carbon, the map projection
• src/model/tokens.js — token and energy-per-token arithmetic
• src/data.js — every card, count and sentence, built from the model; src/sources.js — citations, with when each was published and checked
• src/evidence.js — the five labels, what each figure's evidence looks like, and the registers of calculations and assumptions; src/claims.js — every labeled figure, with the key its chip carries
• src/app/ — stage (3D and panels), sections (charts), scenario (the settings bar), links (chart ↔ 3D), journeys (tour content), sources-ui (popovers), share
• src/scenes/ — scene assembly, motion and overlays around Blender-authored GLB geometry; src/app/stage.js selects the authored builders by default and loads assets as levels are entered. ?module=native or ?module=original retains the comparison implementation.
• tools/blender/ — reproducible geometry builders and technical-layout exporters; public/models/ — the committed runtime GLBs
• tools/claims.mjs — every labeled figure across all scenarios that is not backed the way its label says
• tools/ — browser checks: cycle.mjs (every scenario, scene, layer and clock), views.mjs (every tour stop and part is framed clear of overlays with nothing solid in front), perf.mjs (real-GPU cost), links.mjs (every chart link lands), coplanar.mjs (flush surfaces that flicker), shot.mjs and look.mjs (screenshots)

Rebuilding 3D assets

The authored models retain the scenario engine’s dimensions and component positions. Three.js assembles the scenes and animates their signals and mechanisms; Blender owns the shipped static geometry. Geometry remains schematic, not vendor CAD.

Start with the corresponding script in tools/blender/; prerequisites differ by asset. For compute hardware, export-native-reference.mjs --compute writes the technical-layout references used by build-compute.py. The exporter needs @napi-rs/canvas; set IFX_CANVAS_PACKAGE to its installed package path instead of relying on the author’s machine-specific default. Run the builder with Blender in background mode after its reference export. Other builders document their inputs in their file headers. After rebuilding GLBs, run npm run models:compress (meshopt compression; already-compressed files are skipped).

Commit the resulting public/models/ assets with their source changes and increment the affected loader’s ?v=N cache key. Run typecheck, unit tests, the claims audit and the relevant browser framing, flight and performance checks before publishing an asset change. Ordinary README edits do not rebuild the models.

Automatic validation

The checks workflow runs typecheck, unit tests and the production build on pushes and pull requests. Production publication remains a separate manual workflow.