Repository navigation
Token Reduction as an Energy‐Efficiency Action: A 225‐Billion‐Token Case Study Against SCI for AI
By J. Gravelle, GSF-credentialed Green Software Practitioner and maintainer of jCodeMunch-MCP. An independent practitioner contribution applying SCI for AI (Green Software Foundation, ratified December 2025) to the LLM-tooling layer, with production telemetry.
Short on time? Start with Token Reduction as an Energy-Efficiency Action for the methodology and bounds in two minutes. This page is the full case study behind it.
Since telemetry deployment on 3 March 2026, opt-in production reporting from participating jCodeMunch installations shows a cumulative 225,266,057,553 input tokens that would have been delivered to LLM coding assistants under baseline behaviour, but were not. The figure is the running total on a public counter at https://j.gravelle.us/APIs/savings/total.php, which any reviewer can independently query against the analysis below. As of submission, 24,645 reporting sessions have contributed.
At the per-input-token energy estimates published in current peer-reviewed work, that figure maps to a measurable contribution to the per-task denominator that the SCI for AI specification was designed to credit at its Consumer boundary:
| Estimate | Energy saved | CO₂eq (U.S. grid avg ~400 gCO₂/kWh) | U.S. home-years (10,500 kWh/yr) | Car-years (EPA 4.6 tCO₂/yr) |
|---|---|---|---|---|
| Conservative (0.1 mWh/input token) | 22.5 MWh | 9.0 tonnes | 2.1 | 2 |
| Upper (0.3 mWh/input token) | 67.5 MWh | 27.0 tonnes | 6.4 | 6 |
The grid intensity used is the U.S. national average. If inference runs in a lower-carbon grid region (Iowa wind, Washington hydro), the CO₂ figures above would be smaller; the 400 gCO₂/kWh assumption is therefore upper-bound relative to most U.S. inference regions. The regulatory gap that no frontier-model provider currently discloses per-query inference data-centre location is itself part of the analysis below, and is one of the gaps that SCI for AI's EU AI Act alignment is designed to close.
SCI for AI was ratified by the Green Software Foundation in December 2025 and extends the globally adopted SCI specification (ISO/IEC 21031:2024) with AI-specific considerations: persona-based boundaries, standardised functional units, full-lifecycle coverage from data preparation through inference, and an embedded water-footprint dimension alongside carbon. It is the first consensus-based AI carbon standard, developed by Microsoft, UBS, Google, Accenture, NTT DATA, Siemens, IBM, Globant, and others.
In the five months since ratification, the published case studies applying the spec have come from member steering organisations. This contribution is, to the author's knowledge, the first independent practitioner case study filed against SCI for AI's Consumer boundary, and it occupies a part of the AI software stack that the spec covers but that no existing case study has addressed: the LLM-tooling layer between a developer and a frontier model.
This gap is becoming structurally important. The IEA's April 2025 Energy and AI report, updated in April 2026, finds that data-centre electricity demand grew 17% in 2025 and that capital expenditure from the five largest technology companies on AI data-centre infrastructure is set to grow 75% in 2026 alone. The same report notes that power consumption per AI task is declining rapidly, but total demand is rising because inference volume is rising faster. The leverage point in the IEA's framing is the per-task denominator — and the per-task denominator is exactly what SCI for AI is designed to measure.
This case study applies SCI for AI to jCodeMunch, an MCP server that compresses the context delivered to LLM coding assistants. The goal is not to advertise a number. The goal is to show that SCI for AI's Consumer-boundary methodology works cleanly at the LLM-tooling layer, and to invite other tooling vendors to publish comparable scores against the same specification.
Each participating jCodeMunch installation computes per-call usage.input_tokens deltas at the MCP-server boundary, between the tokens the LLM coding assistant requested versus the compressed payload jCodeMunch returned to serve that request. Per-session aggregates are reported to the public counter cited above. The top 1,000 reporting sessions account for 95.4% of the cumulative total, a long-tail distribution consistent with SCI for AI's focus on workloads where per-task waste is largest: high-volume installations are where the per-task efficiency gap matters most.
Sessions before telemetry deployment, opted-out sessions, and non-default configurations are excluded from the figure. Users opt in by leaving JCODEMUNCH_SHARE_SAVINGS=1 (the default); opt-out is a single environment variable. The reported total is therefore a conservative lower bound on actual ecosystem-wide reductions rather than an extrapolated estimate.
Against the 15–25% end-to-end per-task reduction rate established in the case study below, the 225-billion realised reduction implies a delivered volume of approximately 675 billion to 1.275 trillion tokens of LLM input actually processed in these workflows, against an implicit baseline of 0.9 to 1.5 trillion tokens that would have been consumed without the tool.
A skeptical reviewer will reasonably ask which per-input-token energy estimate underpins the CO₂ conversion, and why it should be trusted. The fair answer is that the absolute conversion depends on the estimate; the per-task SCI for AI reduction ratio does not. The rest of this article walks through why the ratio holds regardless of which per-token estimate a reader is willing to credit, which is the property that makes the underlying claim auditable.
SCI for AI inherits the base SCI calculation:
SCI = ((E × I) + M) per R
Where E is energy consumed (kWh), I is region-specific grid carbon intensity (gCO₂eq/kWh), M is the amortised embodied emissions of the hardware, and R is the functional unit chosen to describe how the software scales.
The AI-specific extensions are persona-based boundaries and lifecycle scoping. The Consumer boundary encompasses the Operation and Monitoring lifecycle stage — what deployers and end-users of AI systems experience. The Producer boundary covers training, fine-tuning, and the upstream lifecycle stages that frontier-model providers control. This case study is squarely at the Consumer boundary: jCodeMunch users are deployers consuming inference from an upstream provider whose Producer-boundary emissions are out of scope for this analysis.
The specification names three categories of action that legitimately reduce an SCI score (inherited from base SCI): energy efficiency, hardware efficiency, and carbon awareness.
Critically for any "green AI" claim, the specification explicitly excludes the following from SCI reduction: carbon offsets, Removal Units, Emission Reduction Units, Certified Emission Reductions, Electricity Attribute Certificates, Power Purchase Agreements, and Renewable Energy Credits. Only elimination counts. Neutralisation does not.
This matters here because most public claims about "sustainable AI" rely on PPAs and RECs at the data-centre level. SCI for AI inherits the base specification's rejection of those as reduction mechanisms. A tool that genuinely reduces inference workload, that causes fewer GPU-seconds to be consumed in the first place, is one of the few interventions the specification actually credits.
SCI for AI also aligns with the EU AI Act's environmental compliance regime, positioning the specification as the international standard the EU will defer to for general-purpose model energy disclosure. Reductions reported against SCI for AI are therefore not just methodology-defensible but regulatory-defensible.
For an AI-augmented developer workflow at the Consumer boundary, a defensible scope contains the developer's local machine (IDE, MCP client, terminal sessions); the MCP server process (jCodeMunch in this study), running locally or on a small VM; and the upstream LLM provider's inference infrastructure, to the extent it is invoked by the workflow.
The first two components are minor contributors. A laptop running an IDE consumes on the order of 20–50 W under load. jCodeMunch is a Python process backed by SQLite and an in-process BM25 index; query latency is sub-5 ms and resident memory is dominated by the index, not by inference. Neither dominates the calculation.
The dominant term is the upstream inference workload, which sits within the Consumer boundary's Operation and Monitoring lifecycle stage. Frontier-model inference is energy-intensive precisely because it runs on accelerator hardware optimised for throughput, not minimum-energy-per-token. This is where the calculation has to be honest, and it is also where the optimisation lever lives.
For organisations using LLM coding assistants, this energy lives in the buyer's scope 3 — emissions from purchased software services. It is currently invisible on most corporate ledgers because the LLM provider does not yet itemise per-customer energy. The forthcoming Greenhouse Gas Protocol updates and the EU AI Act's general-purpose model reporting requirements are likely to change that. Tools that reduce upstream inference per task will accordingly reduce reported scope-3 figures once disclosure mechanisms catch up.
SCI for AI defines standardised functional units for cross-AI-system comparison. For an LLM coding assistant at the Consumer boundary, the most defensible practitioner-level instantiation is per developer-task: a single self-contained unit of work such as "explain this function," "find where authentication is handled," or "refactor this module to use the new error type."
This choice has two properties that make it defensible under the specification. First, it is the unit the buyer actually scales by — engineering teams scale by tasks completed, not by tokens consumed. The functional unit should match the customer's experience of value. Second, it decomposes into tokens: a developer-task corresponds to one or more LLM calls, each with a measurable input-token count, output-token count, and a per-call energy cost. The denominator is operationally tractable and inherits directly from the per-query units SCI for AI defines for inference workloads.
A coarser unit (per developer-day) or finer unit (per LLM call) are both valid alternatives, but per-task best matches the level at which procurement decisions are made and aligns with the spec's preference for functional units that map to user-visible outcomes.
The headline carbon-savings numbers rely on a defensible point estimate for per-input-token energy. The methodology underneath does not. This section explains why the ratio of saved tokens to baseline tokens, which is the unit SCI for AI cares about, is invariant under the choice of per-token energy, even when the literature spans an order of magnitude.
The honest difficulty with per-token energy estimates is that they vary widely across published sources. Recent reporting from the IEA, U.S. Department of Energy national-laboratory data-centre energy work, ML.ENERGY leaderboard measurements, TokenPowerBench (AAAI-26), and most importantly the peer-reviewed Oviedo et al. Energy Use of AI Inference study (Microsoft Research, published in Joule via ScienceDirect, April 2026, which estimates median 0.31 Wh per query at IQR 0.16–0.60 for frontier-scale models on H100 nodes) all give different ranges. None claims precision better than roughly an order of magnitude at the per-query level, and decoding (output-token generation) dominates total energy in all of them, leaving prefill (input-token processing) at roughly 20–30% of the total.
The per-input-token energy range used in the headline (0.1 to 0.3 mWh per token) is derived from those bounds. It is conservative-to-moderate against typical-query estimates and likely below actual values for the long-input workloads characteristic of code-comprehension tasks, where prefill share rises.
If a developer-task requires T tokens of LLM input under the baseline, and T' tokens under the with-tool case, and per-token energy is some unknown but bounded e, then:
- Baseline operational energy contribution from inference:
E_base = T × e - With-tool energy contribution:
E_tool = T' × e - Energy reduction ratio:
(T − T') / T
The ratio is invariant under the choice of e. Whatever the true per-token energy is, the percentage reduction in inference energy equals the percentage reduction in tokens delivered, provided the LLM completes the task to the same standard in both cases.
This is the heart of the SCI for AI claim at the Consumer boundary. A tool that cuts input tokens by N% cuts the inference-side E term by N%. With I and M constant across baseline and with-tool runs (same grid, same hardware), the SCI for AI score drops by approximately N%.
The auditability of this claim rests on a single observable: input-token counts are returned by the LLM provider's API on every call. Any user can independently reproduce the ratio against their own workload by logging usage.input_tokens with and without the tool interposed. So the 225-billion-token figure is the production-aggregate result. The per-task SCI for AI reduction is the rate at which that aggregate accumulates. Both are observable from API logs. The carbon-equivalent conversion is downstream of choosing a per-token energy estimate, and reasonable people can argue over the bounds. The methodology underneath is not affected by where in the bound they land.
jCodeMunch is an MCP server that indexes a codebase and serves compressed, query-relevant context to an LLM coding assistant in place of the assistant's default approach (full-file reads, broad directory traversals, repeated grep-style searches). The compression is structural: the tool serves AST-level symbol summaries, dependency graphs, and call-site neighbourhoods rather than raw source dumps. Every retrieval result is a complete AST node, not a fixed-size text chunk.
Two independent measurements anchor the per-task token reduction. The end-to-end measurement is the SCI-for-AI-bearing figure, because the specification cares about realised per-task C/R at the Consumer boundary, not retrieval-stage micro-savings. The retrieval-layer benchmark is reported as mechanism evidence: it explains where the end-to-end savings come from.
A back-to-back harness run on 2026-03-28 measured tokens consumed per query against three open-source repositories of varying size. The baseline is dense-retrieval RAG (k=5 chunks at chunk_size=512, the configuration that produced the lowest token count among standard RAG settings); the with-tool case is jCodeMunch's AST-based BM25 retrieval. Both harnesses iterated the same indexed file set.
| Repo | Files | Best-RAG tokens/query | jCodeMunch tokens/query | Reduction |
|---|---|---|---|---|
| expressjs/express | 165 | 2,887 | 924 | 68% |
| fastapi/fastapi | 951 | 2,850 | 1,834 | 36% |
| gin-gonic/gin | 98 | 4,352 | 1,124 | 74% |
Compared against a "read all files" baseline, closer to an LLM coding assistant's default exploratory behaviour on an unfamiliar repo, the reductions are 99.3%, 99.7%, and 99.4% respectively. The retrieval-layer reduction therefore brackets at roughly 36–74% against an already-optimised retrieval baseline, and 99%+ against the full-file-read baseline.
These numbers explain why end-to-end savings are achievable. They are not themselves the SCI for AI claim.
A 50-iteration A/B test contributed by community member @Mharbulous and reported in the project's public issue tracker (jgravelle/jcodemunch-mcp#128) on 2026-03-18 ran the same naming-audit task on a Vue 3 + Firebase codebase, alternating between two variants: native Read/Grep/Glob filesystem tools, and jCodeMunch's get_file_outline / get_symbol / find_importers / search_symbols. Same Sonnet 4.6 model, 25 iterations per variant, 600-second timeout. Full methodology and per-iteration data are archived at benchmarks/ab-test-naming-audit-2026-03-18.md in the repository.
| Metric | Native | jCodeMunch | Delta |
|---|---|---|---|
| Successful iterations | 18/25 (72%) | 20/25 (80%) | +8 pp |
| Timeouts | 10/25 (40%) | 8/25 (32%) | −8 pp |
| Mean cost/iteration | $0.783 | $0.738 | −5.7% |
| Mean cache creation | 104,135 | 93,178 | −10.5% |
| Mean duration (s) | 318 | 299 | −6.0% |
Isolating iterations with no per-finding subagent overhead and matching by file count, the tool-layer savings on real agentic tasks fall in the 15–25% range, lower than the synthetic retrieval-layer figure because each iteration also incurs variant-independent fixed overhead (system prompt, skill loading, three-subagent consensus voting per finding) that dilutes the comparison.
This 15–25% per-task reduction is the rate underwriting the headline 225-billion-token cumulative figure, and is the realised reduction against SCI for AI's Consumer-boundary functional unit. The retrieval-stage 36–74% / 99%+ numbers explain the mechanism; the end-to-end 15–25% number is what the production telemetry actually accumulates.
SCI for AI requires that any reduction claim be made against a baseline calculated with identical methodology: same boundary, same R, same assumptions, differing only by the action under evaluation. Both measurements above satisfy this. The synthetic benchmark uses the same indexed file set, same query set, same token-counting methodology, differing only by retrieval mechanism (RAG-512 vs jCodeMunch BM25). The end-to-end A/B test uses the same model, same task, same codebase, same iteration count, alternating variants to control for session-order effects, differing only by the tool surface available to the agent.
Token counts are directly measurable from LLM provider API logs. Per-token energy is held as an unknown but bounded constant e, which cancels in the ratio. I is the local grid intensity at the LLM provider's data centre, measurable from public regional grid-mix data. M is unchanged because the same hardware is used in both cases.
The result is a per-task SCI for AI Consumer-boundary ratio that does not depend on resolving the per-token-energy controversy. This is, the author submits, an unusually clean fit for the SCI for AI specification's design intent.
Three structural features distinguish this claim from typical "green AI" marketing.
The reduction mechanism is elimination, not neutralisation. The tool causes fewer tokens to be processed. No offsets, no PPAs, no RECs are involved. SCI for AI explicitly rejects all of those as score-reduction mechanisms. The intervention is of the kind the specification was designed to credit.
The math is auditable end to end. The cumulative figure is published on a live public endpoint that any reviewer can query. Per-task reductions are reproducible by any user against their own workload using usage.input_tokens from any major LLM provider's API. There is no hidden parameter that requires trusting the vendor.
The claim is proportional first, absolute second. The article leads with absolute numbers (22.5–67.5 MWh, 9–27 tonnes CO₂eq, 2–6 home-years, 2–6 car-years) but defends them with the percentage-reduction methodology that survives any per-token-energy disagreement. The honest disclosure is that the absolute conversion depends on which point estimate one trusts within the published bounds; the proportional reduction does not.
What would invalidate the underlying claim, in keeping with the specification's spirit, is straightforward. The author named three failure modes and tested each against the available data.
The first failure mode would be more LLM calls per completed task. If with-tool runs systematically required more follow-up calls because the compressed context was insufficient, the per-task token saving would be smaller than the per-call saving. The 50-iteration A/B test found the opposite: with-tool runs completed more tasks within the timeout (80% vs 72%) and ran shorter on average (299 s vs 318 s). Per-task call counts did not rise.
The second would be lower-quality outputs that get rejected and re-run. If with-tool runs produced worse answers, effective R would shift downward and per-task SCI for AI would need to be recomputed on accepted outputs only. The same A/B test reported equivalent finding quality across shared categories, with the with-tool variant uniquely surfacing one finding category (orphaned-file detection via find_importers) that the native variant could not produce. No quality regression was observed.
The third would be MCP-server energy approaching upstream-inference magnitude. If the tool itself ran on energy-intensive infrastructure, the boundary would have to include it explicitly. jCodeMunch is a local Python process with sub-5 ms BM25 query latency and no GPU dependency; index build for the largest repo measured (951 files) takes 5–15 seconds of single-core CPU time and is incremental thereafter. The server-side term is two to three orders of magnitude smaller than the inference term it offsets.
These are the failure modes a rigorous reviewer should probe. They are tested rather than assumed.
This case study raises three methodology questions that the LLM-tooling layer will need answered as more vendors publish SCI for AI scores at the Consumer boundary.
First, whose I applies to upstream inference? When a developer in one grid region uses an LLM provider whose inference runs in another, the SCI for AI calculation must use the inference-side grid intensity, not the developer's. This is not yet conventionally documented in the LLM provider's public data, and is precisely the kind of disclosure gap that EU AI Act alignment is designed to close.
Second, how should M be allocated when accelerator hardware is shared across millions of customers? Per the specification, M is allocated by time-share and resource-share. For multi-tenant inference hardware serving millions of inferences per hour, the resource-share allocation is non-trivial and currently relies on provider disclosure that is mostly absent.
Third, what baseline should aggregate industry comparisons use? A reduction claim is only meaningful relative to a baseline. The most defensible baseline for LLM-tooling claims is the same workflow without the tool, but cross-vendor comparisons would benefit from a published reference workload for the LLM-tooling layer specifically. SCI for AI's standardised functional units provide the foundation; the LLM-tooling-layer instantiation does not yet exist.
These questions are filed publicly at Green-Software-Foundation/sci-ai as an open invitation to the SCI for AI working group. The analysis above is published independently of that conversation, with the working-group questions left open for community input.
The author would welcome correspondence from other LLM-tooling vendors interested in publishing comparable Consumer-boundary case studies, and from members of the GSF SCI for AI working group with views on these questions. A fourth question, the integration of the water-footprint dimension SCI for AI introduces alongside carbon, is deferred pending standardised inference-stage water-disclosure mechanisms from frontier-model providers; the absence of that data, rather than its presence, is the relevant finding for the working group.
The author is a credentialed Green Software Practitioner and maintains jCodeMunch and related developer tools. The 225-billion-token cumulative figure is derived from opt-in production telemetry from participating installations since 3 March 2026, reported to a public counter at https://j.gravelle.us/APIs/savings/total.php. Token-reduction methodology and per-repo benchmark data come from two publicly archived sources: a synthetic retrieval benchmark run on 2026-03-28 against expressjs/express, fastapi/fastapi, and gin-gonic/gin (harness, queries, and per-repo results in the project's benchmarks/ directory, with the cross-tool comparison written up in benchmarks/RAG_COMPARISON_NOTES.md); and a 50-iteration end-to-end A/B test on a Vue 3 + Firebase codebase contributed by community member @Mharbulous via jgravelle/jcodemunch-mcp#128, archived at benchmarks/ab-test-naming-audit-2026-03-18.md. Per-repo retrieval-side reductions are reported here against two baselines (full-file read at 99.3% / 99.7% / 99.4%; optimised RAG-512 at 68% / 36% / 74%); the aggregate "99.6% across 15 task-runs" figure that appears elsewhere in project communications is the same data summed across queries before taking the ratio rather than averaged across repos, and is mathematically consistent with the per-repo numbers. Per-input-token energy bounds are derived from Oviedo et al., "Energy Use of AI Inference: Efficiency Pathways and Test-Time Compute," Microsoft Research, published in Joule via ScienceDirect, April 2026 (median 0.31 Wh per query, IQR 0.16–0.60), cross-checked against ML.ENERGY leaderboard v3.0 measurements and TokenPowerBench (Niu et al., AAAI-26). SCI for AI specification references are to the Green Software Foundation specification ratified December 2025, available at https://sci-for-ai.greensoftware.foundation/ and https://github.com/Green-Software-Foundation/sci-ai, which extends ISO/IEC 21031:2024 with AI-specific Consumer and Producer boundaries, standardised functional units, and lifecycle scoping.
Start here
Cut your token costs
Green Software / SCI
Features
- Cross-Repository Dependency Tracking
- Expanded Context Providers
- Get Context Bundle
- Incremental Blob-SHA Indexing
- Search Debug Mode
- Suite-Wide Tool Profile Config
- Template-Language Indexing
- Tokenizer True Benchmark Harness
Releases