Ledger v3.0 · 19 Nov 2026 · GPU Board Energy Metered by Loupe
Coding models measured in joules.
Python brownfield pass rate statistically tied with Claude Opus 5.5 (+2.75 pp, 95% CI −2.2 to +11.7 pp), at about a third of Opus’s estimated GPU board energy (modeled range 23%–88%) and a quarter of the API cost ($0.50/1M in & out, $0.05 cached; −20% on --flex). Every response returns its measured GPU board joules. Drop-in for Claude Code, OpenAI, and Codex.
No-charge Evaluation Preview (no card collected) · Already invited? Open Portal ↗
96.4% (tied Opus)
TypeScript 87/89 + 2/2 OSS
JavaScript 86/89 + 1/2 OSS
Java 72/89 (Opus 86/89)
Per-Language Results · Ledger v3.0 (19 Nov 2026)
Python, TypeScript, JavaScript & Java—including where Opus leads.
Headline energy means nothing without a quality floor and per-language candor. Across 28 repositories, EcoCoder averaged 587 J of GPU board energy per passing brownfield test at a 96.1% pass rate (3,405 / 3,544), led or tied on TypeScript and JavaScript monorepos, ran ~25% slower on Python (193.9 vs. 154.6 min), and trailed Opus on the Java monorepo (72/89 vs. 86/89):
Opus* est: 5,743 kJ
--flexOpus: $33.14
Opus: 93.7% (3,070)
recli: 97.3% vs. 98.4%
193.9m vs. 154.6m
Opus* est: 177 kJ
--flexOpus: $1.38
OSS: 2/2 (16.4 kJ)
tsc --noEmit clean; pathe + ohash 2/2
4.8m vs. 4.1m Opus
Opus* est: 146 kJ
--flexOpus: $1.27
OSS: 1/2 (17.3 kJ)
commander ✓, semver ✗
3.5m vs. 3.3m Opus
Opus* est: 161 kJ
--flexOpus: $1.41
OSS: 2/2 (7.2 kJ)
| Suite (Ledger v3.0 · 19 Nov 2026) | EcoCoder GPU Board | Opus Est. Board* | EcoCoder Cost (--flex) |
Opus Cost | EcoCoder Passed | Opus Passed |
|---|---|---|---|---|---|---|
| Python (All 19 SlopCodeBench) | 1,882.8 kJ (596 J/pass) | 5,743 kJ* est [2.4k–15.9k] | $8.81 ($7.05) | $33.14 ($28.85 5m) | 3,160 / 3,277 (96.4%) | 3,070 / 3,277 (93.7%) |
Python (18-Repo Post-Hoc ex-recli) |
1,631.8 kJ (555 J/pass) | 5,155 kJ* est | $7.65 ($6.12) | $30.23 | 2,939 / 3,022 (97.3%) | 2,975 / 3,022 (98.4%) |
| TypeScript (61k-LOC Monorepo) | 44.4 kJ (510 J/pass) | 177 kJ* est | $0.32 ($0.26) | $1.38 | 87 / 89 (97.8%) | 85 / 89 (95.5%) |
| JavaScript (44k-LOC Monorepo) | 37.2 kJ (433 J/pass) | 146 kJ* est | $0.26 ($0.21) | $1.27 | 86 / 89 (96.6%) | 86 / 89 (96.6%) |
| Java (64k-LOC Monorepo) | 33.5 kJ (465 J/pass) | 161 kJ* est | $0.24 ($0.20) | $1.41 | 72 / 89 (80.9%) | 86 / 89 (96.6%) |
| All 22 Brownfield Repos | 1,997.9 kJ (587 J/pass) | 6,227 kJ* est [2.7k–17.2k] | $9.64 ($7.71) | $37.19 | 3,405 / 3,544 (96.1%) | 3,327 / 3,544 (93.9%) |
| 6 Held-Out OSS Commits (TS/JS/Java) | 40.9 kJ | 136 kJ* est [58–377] | $0.60 ($0.48) | $1.23 | 5 / 6 resolved ($0.120/res) | 6 / 6 resolved ($0.206/res) |
| All 28 Repositories Combined | 2,038.8 kJ (0.57 kWh) | 6,363 kJ* est [2.7k–17.6k] | $10.24 ($8.19) | $38.43 ($38.42 rnd) | 22 brownfield + 6 OSS (full per-repo ledger →) | |
Terms & boundary: Brownfield means extending an existing multi-file codebase rather than generating a fresh file from scratch; isomorphic monorepos implement the identical 6-package service specification natively in TypeScript, JavaScript, and Java to isolate language behavior; SPI contracts verify cross-package service-provider interfaces (6/6 passed in all three languages). The 18-repo ex-recli row was added post-hoc after observing an Opus CLI-dispatch failure on recli (95/255). All EcoCoder energy figures measure GPU board energy only; *Opus figures are estimated (formula & assumptions →).
587 J
Measured GPU board energy per passing brownfield test (1,997.9 kJ / 3,405 passed)
GPU board boundary →
~⅓*
Of Opus’s estimated GPU board energy (modeled range 23%–88% lower across 19–28 repos)
45B–250B scenario band →
−73%
Lower Standard API cost vs. Opus ($10.24 vs. $38.43; −79% repriced on --flex at $8.19)
$0.50/1M in & out, $0.05 cached →
25.2 Wh
Mean measured GPU board energy per brownfield repo (90.8 kJ · $0.44 Standard)
3,600 kJ = 1 kWh →
GPU Board Energy Telemetry · Powered by Loupe
Every response returns its measured GPU board joules.
Token counts hide physical compute work. Reading cached repository context, prefilling fresh files, and decoding patches draw very different power on an accelerator, so Loupe samples NVIDIA NVML board sensors on every EcoCoder turn (GPU board energy only, excluding host CPU, system DRAM, network, and facility cooling).
Direct NVML Board Sensors
Per-turn GPU board joules alongside USD spend.
Loupe integrates live GPU board watts over execution time into joules (3,600 kJ = 1 kWh) and returns X-LeanLM-Energy-Joules on every response. Across 22 brownfield repos, EcoCoder averaged 90.8 kJ (25.2 Wh) of GPU board energy vs. 283 kJ* (78.6 Wh*) estimated for Opus (modeled range 121–783 kJ/repo).
Warm Prefix Reuse
93.7%–97.1% KV-cache hits skip prefill watts.
Multi-turn coding agents re-send repository context dozens of times per task. Serving 97.1% of prompt tokens from warm GPU prefix cache on the 19 Python repos (and 93.7% across the 3 TS/JS/Java monorepos) avoids repeated prefill compute—cutting both GPU board joules and input cost ($0.05/1M).
Async Batching & Code Hygiene
--flex packs GPU batches, and clean edits cut follow-on turns.
Passing --flex (or header X-LeanLM-Flex: eco) queues non-interactive subagent and CI runs so the scheduler can pack deeper GPU batches—discounting your token rate by 20% ($0.40/$0.04/$0.40 per 1M). On an independent live --flex run of xjq (CP4→CP5), EcoCoder passed 167/167 tests for 14.6 kJ GPU board energy and $0.10 (vs. 19.6 kJ / $0.20 Standard in the main table, and Opus 5.5 at 167/167, 91 kJ* est, $0.60). And in a single-repository sequential case study (~3,500 LOC vs. our unguided baseline), starting from an EcoCoder-maintained checkpoint cut next-feature turns by 49%–63% (case study →).
# Every API response returns measured GPU board joules + USD spend:
X-LeanLM-Energy-Joules: 1842.6
X-LeanLM-Cost-Usd: 0.0142
$ ecocoder stats
Session GPU board energy: 44.4 kJ (12.3 Wh) · NVIDIA NVML board sensors (excludes CPU/DRAM/cooling)
Session spend: $0.32 · 93.7% cached prompt tokens (TS monorepo)
Published Token Pricing & Drop-In Setup
$0.50 / 1M in & out ($0.05 cached). −20% with --flex.
EcoCoder speaks standard Anthropic (/v1/messages), OpenAI (/v1/chat/completions), and Codex (/v1/responses) wire protocols. Every Standard turn bills at $0.50/$0.05/$0.50 per 1M tokens (and every --flex turn bills 20% lower at $0.40/$0.04/$0.40), with $0 cache-write fees (open the 64k cached coding preset in the calculator →).
ecocoderLive terminal sessions in Claude Code, Codex CLI, and pi on US NVML GPU nodes. Zero cache-write fees and zero escalation surcharges.
ecocoder --flexPass --flex (or header X-LeanLM-Flex: eco) for delegated @ecocoder subagents, batch refactors, and CI (typical 2–30 s queue time; $0.35/repo repriced mean—still 65%+ below Opus Batch).
| Model / Lane | Uncached Input | Cached Input | Output | All 28 Repos (v3.0) |
|---|---|---|---|---|
ecocoder Standard |
$0.50 / 1M ($0 write) | $0.05 / 1M (−90%) | $0.50 / 1M | $10.24 · 2,039 kJ GPU board |
ecocoder --flex −20% Async |
$0.40 / 1M ($0 write) | $0.04 / 1M (−90%) | $0.40 / 1M | $8.19 repriced · 2,039 kJ |
claude-opus-5-5 (Standard) |
$4.00 / 1M ($8 1h write) | $0.20 / 1M | $20.00 / 1M | $38.43 · 6,363 kJ* est [2.7k–17.6k] |
claude-opus-5-5 (Async Batch ref) |
$2.00 / 1M | $0.20 / 1M | $10.00 / 1M | ~$22.58 repriced (EcoCoder Flex: −64%) |
Anthropic reference rates per anthropic.com/pricing. Direct HTTPS setup below processes prompts in memory with zero repository file staging; our optional ecocoder CLI helper stages eligible source files in an ephemeral workspace purged on exit (Privacy Policy →).
read -rsp "EcoCoder API key: " ECOCODER_API_KEY && echo && export ECOCODER_API_KEY export ANTHROPIC_BASE_URL="https://api.leanlm.ai" claude --model ecocoder
128k context window · SSE tool streaming · Also supports Codex CLI, pi, @ecocoder --flex subagents, and our SHA-256-verified Python 3 CLI (2-minute setup & API specs →).
Questions
Frequently asked questions
Why do you measure GPU board joules per passing test alongside API dollars?
Token counts hide physical compute work because reading cached repository context, prefilling fresh files, and generating output tokens draw very different power on a GPU—and energy without a quality floor is easy to game with tiny models that fail tests. Loupe samples NVIDIA NVML board sensors on every EcoCoder turn (GPU board energy only, excluding host CPU, DRAM, network, and cooling; 3,600 kJ = 1 kWh), averaging 587 J per passing test across 22 brownfield repos at a 96.1% pass rate.
How does EcoCoder compare with Claude Opus 5.5 across all 28 repositories?
On 19 Python SlopCodeBench v1.0 repos (3,277 tests), EcoCoder is statistically tied with Opus 5.5 (96.4% vs. 93.7%, +2.75 pp, 95% CI −2.2 to +11.7 pp; post-hoc ex-recli: 97.3% vs. 98.4%; wall time 193.9 vs. 154.6 min), using 1,882.8 kJ of measured GPU board energy vs. 5,743 kJ* estimated for Opus (modeled range 2,445–15,890 kJ, 23%–88% lower) and $8.81 Standard ($7.05 --flex) vs. $33.14. On 3 TS/JS/Java monorepos, EcoCoder led TypeScript (87/89 vs. 85/89), tied JavaScript (86/89), and trailed on Java (72/89 vs. 86/89). Across all 28 repos (including 5/6 vs. 6/6 OSS commits), spend is $10.24 Standard ($8.19 --flex) vs. $38.43 unrounded ($38.42 sum of rounded subtotals) and 2,038.8 kJ measured GPU board energy vs. 6,363 kJ* estimated Opus energy (modeled range 2,709–17,609 kJ; full Ledger v3.0 →).
What is EcoCoder’s token pricing, and how does --flex compare with Opus Batch?
Every Standard turn bills at $0.50 per 1M uncached input tokens, $0.05 per 1M cached input tokens (90% discount, $0 cache-write fee), and $0.50 per 1M output tokens ($0.44/repo mean across 22 brownfield repos). Passing --flex (or X-LeanLM-Flex: eco) applies a 20% async discount ($0.40 / $0.04 / $0.40 per 1M, or $0.35/repo mean), remaining ~64% below repriced Claude Opus 5.5 Batch ($2 / $0.20 / $10 per 1M).
Do you train on customer code, and what does the CLI stage?
Stellar Content Inc. (d/b/a LeanLM) never trains, fine-tunes, or distills models on customer code or prompts. Direct HTTPS connections process prompts in volatile memory without syncing repository files and log only numeric turn receipts (token counts, GPU board joules, USD cost, status, and latency) for 90 days. By contrast, the optional ecocoder CLI wrapper stages eligible tracked and untracked non-ignored source files (≤1 MiB/file, 15 MiB max; inspect locally with ecocoder sync-preview) in an ephemeral tenant workspace deleted on session exit (≤24h sweep on abnormal disconnect; Privacy Policy → · Security →).
How do evaluation keys and design-partner access work?
EcoCoder is currently offered as a no-charge Developer & Design-Partner Evaluation Preview. Enter your email below for a $10.00 hard-capped evaluation key (no credit card collected; ~22 Standard or ~28 --flex brownfield runs). Commercial team onboarding is gated to our design-partner waitlist at [email protected].
Built by
Chris Cholette — Founder, LeanLM
Engineering executive with 15+ years leading platform and infrastructure organizations at Navan, Salesforce/MuleSoft, and Sunrun. Built Loupe and EcoCoder to measure coding models in physical GPU board joules and passing tests rather than token sticker prices (about & company facts → · LinkedIn ↗).
No-Charge Developer & Design-Partner Preview
Request a $10 evaluation key.
Enter your email and we’ll provision an eco_live_... evaluation key ($10.00 promotional cap, no credit card collected, zero training on your code). Interested in the commercial design-partner waitlist? Email [email protected].
Request received — watch your inbox for your $10 EcoCoder evaluation key.
Optional: which client will you connect first?
By requesting a key, you agree to our Terms of Service and Privacy Policy. Already provisioned? Sign in at api.leanlm.ai/portal →