The Energy Receipts

What Does AI Memory Save in Energy for a Returning User?

A measured study of context rebuild vs. restore on one real power-user workload (Indelible, 2026-07-15)

1. The Question

When an AI working session ends, its accumulated context — everything the model learned by reading files, searching, and conversing — is normally thrown away. A returning session must either rebuild that context (re-read, re-search, re-ask) or restore it from persistent memory. Indelible stores sessions encrypted on the BSV blockchain so returning sessions restore instead of rebuild. How much energy does that replacement actually save? Every number below traces to one of four measurement reports (Tasks A–D): local scripts run against real transcripts and save receipts on this machine, plus primary-source-verified published energy baselines.

2. The Data

• Transcripts (Task A): 14 real Claude Code session transcripts, 1.27 GiB, Jun 5 – Jul 15 2026, one project, one machine. 24,506 API calls (deduplicated by message.id; usage blocks verified to repeat across lines). Totals from API-reported usage fields: 12.59B input-side tokens processed (3.04M uncached input + 286.8M cache-creation + 12.30B cache-read — 97.7% of all input-side tokens are cached-context re-reads) + 51.2M output tokens. Mean input-side context per API call: ~514k tokens.
• Compaction census (Task C): 79 unique context-replacement (compaction) events across the 14 transcripts, May 4 – Jul 15 (72 days ≈ 1.1 events/day), each with exact before/after context sizes from API usage fields. (Date reconciliation: the census keys on message timestamps inside the transcripts; long-running sessions carry history back to May 4, earlier than the Jun 5 file-window start reported in Task A.) Full 79-row table + conversion script: ENERGY_STUDY_APPENDIX_RECEIPTS.md.
• On-chain corpus (Task B) — the scale line: ~5 months (Feb 18 – Jul 15 2026), 5,289 unique sessions, ~262k messages persisted to chain (5,403 on-chain save txids; 40.8 MB deduplicated indexed text). Receipted save costs (last 27 days only): 3,069 transactions, 53.97M sats (~0.54 BSV).
• Baselines (Task D): primary-source verified — Google Gemini 0.24 Wh median text prompt (measured in production, includes host/idle/PUE); OpenAI 0.34 Wh average query (self-reported, no methodology); Oviedo et al. (Joule 2026) 0.31 Wh median frontier-model query; Epoch AI long-context estimates ~2.5 Wh @ 10k input tokens, ~40 Wh @ 100k input tokens; long-context inversion where prefill reaches 67–84% of query energy (arXiv 2602.05712).

3. Method: tokens → energy

Rebuild-vs-restore is an input-context question, so per-query chat medians (0.24–0.34 Wh, short prompts) cannot be applied flat. We derive a per-input-token band from Epoch AI's two published long-context points:

• 2.5 Wh / 10,000 tokens = 0.25 mWh per input token
• 40 Wh / 100,000 tokens = 0.40 mWh per input token

Basis: 0.25–0.40 mWh per input token that must actually be (re)computed (ESTIMATE — Epoch's own modeled figures; the upper slope reflects superlinear attention cost). We apply this band only to tokens forced through fresh computation (re-derived context; restore-boundary first calls). We deliberately do not energy-convert the 12.30B cache-read tokens: cached re-reads are cheaper per token and no verified published figure quantifies the discount (Task A/D caveats). The long-context regime is exactly where input dominates query energy (prefill 67–84% of total when input ≫ output — Task D, verified), so pricing the input side is the honest lens for this workload.

Arithmetic (script synth-arith.mjs in the study scratchpad, run against the task-report figures):

• Rebuild per boundary: (971,805 − 71,266) = 900,539 tokens × 0.25–0.40 mWh = 225–360 Wh
• Restore per boundary: 71,266–106,621 tokens × the band = 18–43 Wh
• Net = rebuild − restore, worst-cases crossed: ~183–342 Wh per boundary

4. RESULTS

Per returning-session event (n=79 measured boundaries; token figures exact from API usage):

Compression ratios — the measured evidence that distilled memory replaces raw context:

• Full context → first-call-after-restore: 12.3× median / 12.5× mean (min 1.3, max 23.2; exact usage fields)
• Full context → the carried memory summary itself: ~208× median (summary ~4,611 tokens replaces ~972k)
• Measured Indelible on-chain restore injections are smaller still: 0.35k–2.6k tokens per load_context/recall_context call — vs 7.9M tokens of file-read/search results accumulated in the same session's cold re-derivation (replicated: 6.7M in a second session). A restore injection is 3–4 orders of magnitude smaller than the session's total re-derivation reading.

Measured window totals (79 events, May 4 – Jul 15): 71.98M tokens of context replaced vs 7.10M tokens of post-restore first calls (both exact sums) → ~16–26 kWh net avoided in 10 weeks (ESTIMATE via the band).

Extrapolated per year for this heavy user (measured cadence 1.1 boundaries/day → ~400/yr):

• ~361M tokens of re-derivation avoided per year
• Gross avoided 90–144 kWh/yr, minus restore cost 7–17 kWh/yr → net ~73–137 kWh/yr (ESTIMATE)
• Equivalent to ~215,000–570,000 median chat queries per year at the published 0.24–0.34 Wh figures.

5. HONEST CAVEATS

1. Inference is a slice, not the whole. These savings apply to inference energy only. Inference is estimated at 80–90% of AI computing power (MIT Technology Review, May 2025 — an industry estimate with no single named primary study; Task D). All Wh figures exclude training, embodied hardware, network transit, and end-user devices.
2. One power user, not a population. All transcript data is one project on one machine (14 sessions, dominated by two mega-sessions), with a 1M-token context window — sessions far larger than typical consumer use. The corpus scale line (5,289 sessions / 262k messages / 5 months) is one user's real history. Do not population-scale these numbers.
3. Restores add tokens too — net accounting shown. The restore path is not free: the first call after a restore is 71k–107k tokens (18–43 Wh est.), the standing per-session memory injection is ~27.7k tokens (est., chars/4), and post-compact file re-injections add ~59k–298k tokens per long session. All results above are net (rebuild minus restore).
4. The per-token band is an estimate and an extrapolation. Epoch's 2.5/40 Wh points are modeled, not measured; applying the slope linearly to ~900k-token contexts extends beyond their stated 100k range. Superlinear attention would make rebuild more expensive than our band (conservative in our favor); provider caching mitigations would make both sides cheaper. Token figures labeled chars/4 are estimates; all before/after context sizes are exact API-reported usage.
5. No claim about the "30% of datacenter energy" number circulating on X. We did not verify it, we do not use it, and nothing here depends on it. Separately, IEA "Energy and AI" figures could not be verified from the primary source (HTTP 403) and are excluded from all arithmetic.
6. The natural experiment is compaction boundaries. Claude Code's compaction is itself a context-replacement mechanism; we measured its boundaries as the ground truth of what replacement saves. Indelible's on-chain restore is the cross-session, cross-machine, permanent version of the same move — and its measured injections (0.35k–2.6k tokens) are smaller than the in-harness summary (~4.6k).

6. The Defensible Claim

Measured on one real power user's complete 5-month AI workload (5,289 sessions and ~262,000 messages persisted to the BSV blockchain; 12.6 billion input-side tokens across 24,506 API calls in 14 local transcripts), every return-to-work event replaces a median 971,805 tokens of accumulated working context with a 71,266-token restored one — a measured 12.3× compression, with the carried memory summary itself ~208× smaller than the context it replaces, and Indelible's on-chain restore injections smaller still at 0.35k–2.6k tokens versus ~7.9 million tokens of cold file-re-reading per long session. Converting only the avoided recomputation at Epoch AI's published long-context rates (2.5 Wh per 10k, 40 Wh per 100k input tokens), each restore-instead-of-rebuild event nets an estimated ~183–342 Wh — the energy of roughly 540–1,400 median chatbot queries at Google's measured 0.24 Wh and OpenAI's reported 0.34 Wh — which at this user's measured cadence of 1.1 events/day extrapolates to ~73–137 kWh of inference energy avoided per year for a single heavy user, net of the restore calls themselves. These are one user's measured numbers under estimate-labeled published conversion rates, covering inference only (itself an estimated 80–90% of AI compute), and make no use of unverified viral datacenter statistics.

Sources: Task A (transcript usage analysis), Task B (on-chain corpus), Task C (compaction census + rederive-vs-restore), Task D (primary-source-verified baselines). Conversion arithmetic: scratchpad/energy/synth-arith.mjs. Estimates are labeled; all before/after context token figures are exact API-reported usage.