The Joule Standard

The Joule Standard is a ten-paper research program on a narrow question: how does energy become economically useful work, machine intelligence, settlement assurance, and coordination?

The project does not treat energy as a theory of value. A joule is a physical unit. Value depends on an outcome, a boundary, a counterfactual, an attribution rule, and often a set of weights. The papers make those choices explicit and the Python package turns their accounting rules into small, testable examples.

Read the web editions at joule-standard.vercel.app or inspect the publication source.

The program

No.	Paper	Main question	Code
1	Value per Joule: Foundations of an Energy-Normalized Economics	What must be declared before value can be divided by energy?	foundations.py
2	From Exergy to Intelligence: A General Theory of Economic Transduction	How can typed energy-to-outcome chains be composed without confusing physical and economic quantities?	transduction.py
3	Quality-Adjusted Intelligence per Joule	How should machine intelligence account for difficulty, correctness, reliability, usefulness, and energy?	intelligence.py
4	Trust per Joule: The Thermoeconomics of Proof-of-Work Settlement	What settlement assurance can a named proof-of-work threat model produce from energy?	pow_assurance.py
5	Tokens Are Not Value: Economic Accounting for AI Inference	How does inference expenditure reach verified outcomes, adoption, and realized value?	inference_accounting.py
6	Marginal Value of Energy in an Automated Economy	Where should the next joule at a node and time be allocated?	marginal_allocation.py
7	The Cognitive Rebound Effect: Why Efficient AI May Increase Energy Demand	When does demand for cheaper cognition offset an efficiency gain?	rebound.py
8	Energy Markets for Machine Intelligence and Cryptographic Settlement	How can heterogeneous flexible compute participate in constrained electricity markets?	energy_markets.py
9	A Value-per-Joule National Accounting System	How can energy-normalized satellite accounts supplement GDP without double counting?	national_accounts.py
10	The Joule Standard: A Unified Economics of Work, Trust and Intelligence	What minimal vector-valued structure is shared across the other nine papers?	synthesis.py

Paper 10 is the synthesis. There is no separate eleventh synthesis paper.

What is in the repository

papers/latex/            LaTeX sources and the shared paper style
papers/pdf/              Canonical reviewed PDFs
images/                  300 DPI first-page cover images
reviews/                 Preserved AGY review rounds and canonical verdicts
research/                Claim, notation, boundary, and paper registries
src/joule_standard/      Python reference implementation
tests/                   Generic unit and invariant tests
scripts/                 Paper, HTML, and publication validators
website/                 Static Next.js publication site
docs/papers/             Durable byte-identical HTML paper mirror
context/                 Source prompts that define the research program
.knowledge-base.md       Shared source and provenance registry

The paper sources are canonical. HTML editions are generated from accepted LaTeX sources and checked for citation targets, equation anchors, MathML, metadata, internal links, and static assets.

Evidence labels

Every paper uses the same labels:

• PROVED: a deductive result under the assumptions in its statement.
• CONDITIONAL: a result that depends on a model, scenario, or research design.
• COMPUTATIONAL: a claim reproduced by code or a numerical fixture.
• OBSTRUCTED: a claim blocked by identification, data, or comparability.
• OPEN: a question the program does not settle.

A finite test suite is executable evidence. It is not a formal proof and it is not an empirical estimate.

Required toolchain

The reference models need Python 3.11 or later. Rebuilding every publication artifact additionally requires:

• latexmk with a TeX Live distribution;
• Poppler tools, including pdfinfo, pdftotext, and pdftoppm;
• Pandoc 3.10 for byte-stable native MathML paper editions;
• rsvg-convert from librsvg for social cards;
• ImageMagick identify for image checks;
• Node.js 24 and npm 11 for the static site.

The committed PDFs, covers, HTML editions, and social cards let readers inspect the release without installing that complete publishing toolchain.

Run the reference implementation

Python 3.11 or later is recommended.

python3 -m venv .venv
source .venv/bin/activate
PIP_CONSTRAINT=constraints-dev.txt python3 -m pip install -r requirements-dev.txt
python3 -m pytest

The current modules use the Python standard library so accounting identities and counterexamples remain inspectable. Pytest is the only development dependency required by the test suite. constraints-dev.txt records the resolver versions exercised by CI; the published library keeps no runtime dependencies.

Build and verify the papers

Build one paper in an isolated temporary directory:

scripts/build_paper.sh value-per-joule

The build also records an exact fingerprint of that paper's TeX source and the shared publication style. In check mode, the script recompiles the paper and compares its extracted words and numbers with the canonical PDF while allowing line wrapping to differ across TeX and Poppler versions. The source fingerprint continues to catch punctuation or style changes that the layout-insensitive comparison intentionally ignores.

Run the paper publication gate:

python3 scripts/verify_papers.py

The gate requires:

• the shared GrokRxiv sidebar and common author block;
• no Unicode em or en dash in reader-facing source;
• at least 20 actual PDF pages;
• a 2550 by 3300 cover image at 300 DPI;
• preserved substantive AGY review rounds;
• a canonical review ending in VERDICT: ACCEPT or VERDICT: MINOR REVISIONS.

Material changes after review require another review round.

Build and verify the website

Generate reviewed HTML editions and copy their publication assets:

python3 scripts/generate_paper_covers.py
python3 scripts/generate_web_papers.py
python3 scripts/generate_og_cards.py
python3 scripts/verify_publication_copies.py

Build the static site and run the route gate:

npm --prefix website ci
npm --prefix website run lint
npm --prefix website run build
python3 scripts/verify_site.py

The static validator checks all ten paper routes even when a paper is still in review. Accepted papers must also expose working MathML, citation links, equation anchors, PDFs, and covers.

website/generated/ feeds the Next.js paper reader. docs/papers/ is a byte-identical durable HTML mirror used by the prepublish artifact gate.

For local visual review:

npm --prefix website run dev

Measurement contract

A value-per-joule claim should state at least:

1. the named outcome or outcome vector;
2. the operational, facility, network, embodied, or lifecycle boundary;
3. the counterfactual;
4. the time and location of the energy input;
5. the energy convention, including primary, final, or electricity terms;
6. the attribution rule for shared inputs and joint outputs;
7. the uncertainty model and any scalar weights.

Ratios from different contracts are not directly comparable until a bridge is shown. A larger average ratio also does not prove that the next joule belongs to the same use.

Program-wide nonclaims

• Tokens are not intelligence or economic value.
• Bitcoin energy does not back the BTC price.
• Hashes and transactions are not context-free units of settlement assurance.
• Benchmark capability is not realized economic value.
• Flexible compute is not automatically beneficial to an electricity grid.
• Efficiency does not necessarily reduce or increase total energy demand.
• A national value-per-joule vector is not a politically neutral welfare ranking.
• Energy is not a currency or a conserved measure of value.

Authorship and review

The papers use the common author block:

Matthew Long The YonedaAI Collaboration YonedaAI Research Collective

Native Codex agents write and fix the papers and reference code. AGY performs the independent paper reviews. Claude reviews Python and website code after the corresponding implementation is stable. Review artifacts are committed with the work so a publication verdict can be traced to the exact correction round.