Skip to content

EcoCoder — 587 J GPU board energy / passing test · 73%–79% lower API cost.

Request a $10 preview key
LeanLM / EcoCoder

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 ↗

Ledger v3.0 (19 Nov 2026) across all 28 repositories: Claude Opus 5.5 used an estimated 6,363 kJ GPU board energy (modeled range 2,709–17,609 kJ, $38.43 unrounded API cost, 93.9% brownfield passed); EcoCoder Standard measured 2,039 kJ NVML GPU board energy (587 J per passing brownfield test, $10.24 API cost, 96.1% brownfield passed); EcoCoder --flex repriced the Standard trace at 0.80x for $8.19. ALL 28 REPOS (v3.0) · GPU BOARD ENERGY API COST PASSED claude-opus-5-5 6,363 kJ* est [2.7k–17.6k] $38.43 93.9% ecocoder 2,039 kJ NVML (587 J/pass) $10.24 (−73%) 96.1% ecocoder --flex 0.80× repriced Std trace $8.19 (−79%) 96.1%
claude-opus-5-56,363 kJ* est · $38.43
Estimated GPU board range [2,709–17,609 kJ] · 93.9% brownfield passed
ecocoder (NVML)2,039 kJ · $10.24 (−73%)
Measured GPU board energy (587 J/passing test) · 96.1% passed
ecocoder --flex$8.19 (−79%)
0.80× repricing of Standard trace ($0.40/$0.04/$0.40 per 1M)
Ledger v3.0 (19 Nov 2026) · Boundary: GPU board energy only via NVIDIA NVML sensors (excludes host CPU, DRAM, network, and cooling). All 28 repos = 22 brownfield repos (3,544 tests) + 6 OSS commits; *Opus 5.5 GPU board energy is estimated across 45B–250B active scenarios ([2,709–17,609 kJ], 25%–88% lower). Opus $38.43 sums unrounded receipts ($33.14 + $4.05 + $1.23 = $38.42 rounded subtotals; full ledger →).
Python 96.4% (tied Opus) TypeScript 87/89 + 2/2 OSS JavaScript 86/89 + 1/2 OSS Java 72/89 (Opus 86/89)

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):

Python 19 SlopCodeBench repos · 3,277 tests
Statistically Tied (+2.75 pp)
Board J / Pass
596 J
1,882.8 kJ NVML
Opus* est: 5,743 kJ
Cost (Std / Flex)
$8.81
$7.05 --flex
Opus: $33.14
Tests Passed
96.4%
3,160 / 3,277
Opus: 93.7% (3,070)
95% CI [−2.2, +11.7 pp] · Post-hoc ex-recli: 97.3% vs. 98.4% 193.9m vs. 154.6m
TypeScript 61.2k-LOC monorepo + 2 OSS
Monorepo + 2/2 OSS
Board J / Pass
510 J
44.4 kJ NVML
Opus* est: 177 kJ
Monorepo Cost
$0.32
$0.26 --flex
Opus: $1.38
Passed + OSS
97.8%
87/89 (Opus 85/89)
OSS: 2/2 (16.4 kJ)
Strict tsc --noEmit clean; pathe + ohash 2/2 4.8m vs. 4.1m Opus
JavaScript 44.2k-LOC monorepo + 2 OSS
Monorepo Tied · 1/2 OSS
Board J / Pass
433 J
37.2 kJ NVML
Opus* est: 146 kJ
Monorepo Cost
$0.26
$0.21 --flex
Opus: $1.27
Passed + OSS
96.6%
86/89 (tied Opus)
OSS: 1/2 (17.3 kJ)
Tied on monorepo; commander ✓, semver ✗ 3.5m vs. 3.3m Opus
Java 64.1k-LOC monorepo + 2 OSS
Opus Monorepo Lead
Board J / Pass
465 J
33.5 kJ NVML
Opus* est: 161 kJ
Monorepo Cost
$0.24
$0.20 --flex
Opus: $1.41
Passed + OSS
80.9%
72/89 (Opus 86/89)
OSS: 2/2 (7.2 kJ)
2/2 Apache OSS resolved; trails Opus by 14 tests on monorepo 3.4m vs. 3.8m Opus
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 →

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 →).

Loupe per-turn HTTP headers & TypeScript monorepo session receipt
# 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)

$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 →).

Standard Interactive · ecocoder
$0.50 in · $0.05 cached · $0.50 out / 1M

Live terminal sessions in Claude Code, Codex CLI, and pi on US NVML GPU nodes. Zero cache-write fees and zero escalation surcharges.

22-Repo Mean
$0.44 / repo
−74% vs. Opus Std ($1.69)
GPU Board / Repo
90.8 kJ
25.2 Wh (587 J/passing test)
Async & CI (−20%) · ecocoder --flex
$0.40 in · $0.04 cached · $0.40 out / 1M

Pass --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 →).

Direct HTTPS setup (zero repository file staging)
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 →).

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 ↗).

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 →