From 3f241088d3a58ca5e2a2c4779d4b0522e70fdbd0 Mon Sep 17 00:00:00 2001 From: Transaction Science Date: Sun, 18 Oct 2026 08:32:52 -0400 Subject: [PATCH] jcp-efficiency: the outcome anchor is not ours alone; the signature is MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three places claimed the outcome anchor as the thing nobody else has: - `src/lib.rs` — "the four figures that matter, plus the one thing the incumbents omit — the **outcome anchor**" - `MAPPING.md` §0 — "seals all four **with the outcome anchor the rates omit**" - `jcp/README.md` — "with the one thing the rates omit: the **outcome anchor**" That is no longer true. Panigrahy, Tyagi, Abkin, Houngninou and Mahapatra, *Energy per Successful Goal: Goal-Level Energy Accounting for Agentic AI Systems* (arXiv:2605.22883, v1 2026-05-20, v2 2026-10-12), defines EpG as "total workflow energy across all attempts, including failures and retries, divided by successfully completed goals" — the same denominator `uj_per_completed_unit()` computes, waste included — with a measurement framework attributing RAPL and ARM counters to workflow energy. What survives the finding, and is now stated as the claim rather than assumed inside a broader one: the paper is a *calculation and reporting* convention. It describes measurement, attribution and a reproducibility protocol; no part of it signs or attests the figure. So `efficiency/1` adds not the anchor but the **artifact** — a signed, honest-provenance, verifiable receipt carrying it. MAPPING.md already said exactly that in its opening ("supplies the one thing that standard, and every deployed disclosure regime, lacks: a signed, honest-provenance, verifiable receipt carrying an outcome-anchored figure"), which is why that sentence needed no change: it was scoped correctly and the three downstream restatements were not. MAPPING.md §0 now cites the prior art in the same ingest-not-compete form §1 already uses for GSF SCI-for-AI, including the licence constraint (arXiv non-exclusive — cited and briefly quoted, never reproduced). Naming it is within the naming rule, which permits standards, bodies, protocols, papers and open-source projects to be named factually; `check-public-names.sh` scopes to `wai/` in any case. Guards run locally before pushing, since this is public text: comparative-prose clean (2307 files), no vanity metrics (277 Markdown files), check-spec-refs 1613 citations all resolving. `cargo test -p jcp-efficiency`: 54 + 6 pass. Co-Authored-By: Claude Opus 5 --- jcp/README.md | 2 +- jcp/jcp-rs/crates/jcp-efficiency/MAPPING.md | 23 +++++++++++++++++---- jcp/jcp-rs/crates/jcp-efficiency/src/lib.rs | 7 +++++-- 3 files changed, 25 insertions(+), 7 deletions(-) diff --git a/jcp/README.md b/jcp/README.md index 011474d60..7990b615d 100644 --- a/jcp/README.md +++ b/jcp/README.md @@ -44,7 +44,7 @@ jcp/ - **`jcp-prompt`** — a **signed, content-addressed prompt registry**: immutable prompt **versions** (double-brace `{{ variable }}` templates) with mutable **aliases** (`dev` / `staging` / `production`) resolved by `prompts:/@` (or `prompts://`) URIs — the registry shape the serving ecosystem already uses. The difference: each registered version and each alias **promotion** seals as a hash-chained **`prompt/1`** receipt, and a version's id *is* its template, so swapping the text under a name changes the id and re-pointing an alias is a signed entry in an ordered log. The exact instructions an agent ran under — and which version was live when — become tamper-evident artifacts, not a row someone with write access can edit. - **`jcp-trace`** — ingests an agent run's **OpenTelemetry GenAI trace** (`gen_ai.*` semantic conventions: `chat` / `tool` / `retriever` spans with token usage) and its **evaluation assessments** (judge / human / code feedback), attaches **per-span joules** (measured where a meter is present, else `Estimator` from token counts — provenance never silently upgrades), and seals one **`eval/1` JCR-1 receipt**: the per-span token + joule breakdown with the headline `uj_per_accepted_token` at the **weakest** provenance present, the assessments, a deterministic **quality-gate** verdict (the sealed, declarative analog of a CI assert), and a **readiness projection** an ARL validation-axis claim consumes. The observability stacks *record* a trace and *log* a judge score in a table; this is the interop projection that **seals** the same trace, puts a joule on it, and hash-chains it via `EvalLog` — no new cryptography. The **gate is content-addressed**, so the sealed receipt commits to exactly which bar it was judged against (a tamper-evident artifact, not a mutable in-code `assert`), and **`align_threshold` / `Judge`** calibrate a judge's decision threshold to human pass/fail labels — judge alignment as a reproducible number, not a UI click. Behind the `server` feature, a std-only **OTLP `/v1/traces` receiver** lets any OpenTelemetry exporter POST a `gen_ai.*` trace (with its assessments) and get the sealed `eval/1` receipt back the instant the run ends. - **`jcp-intercept`** — **attested interceptor chains**: a composable, ordered pipeline of transforms *around* each model and tool call — the `before_model` / `after_model` / `before_tool` seams an agent's middleware stack runs, composed onion-order (forward in, reverse out) and stopping at the first refusal or human-approval hold. An interceptor may inspect or **rewrite** the request (redact a secret before it reaches the model, trim stale context), **refuse** it, or **hold** it for a human. The difference from the incumbent's arbitrary in-process hooks: every step seals an **`intercept/1`** JCR-1 receipt carrying the request digest **before and after** the step (so a redaction or a trim is provable — the content itself never sealed, only its hash), the seam, the outcome, and the **metered joules** at their honest provenance (where the meter reads a counter, a seam pass is one reading divided among its steps by each step's thread CPU time, so the steps sum to it exactly and each share is graded `ModelBased`), hash-chained — the exact transform pipeline that produced a model request becomes reconstructable and verifiable by anyone, and a step cannot run un-sealed. Three reference interceptors — `Redact` (a content transform), `CallLimit` (a guardrail), `Approve` (a human-in-the-loop hold) — each reuse a primitive the family already holds rather than reinventing it. -- **`jcp-efficiency`** — the **energy-efficiency spec**, surfaced as a sealed receipt. The dark-factory economics turn on four figures — **joules per accepted token, tokens per second, value per token, and the tokens/joules/dollars spent per COMPLETED, VERIFIED unit of work** — and the incumbents publish, at best, a *rate* (cost per token) that can't tell you whether the spend bought a result. An **`efficiency/1`** JCR-1 receipt records all four at honest provenance, hash-chained, with the one thing the rates omit: the **outcome anchor** (`completed` + a verdict). A measurement that didn't complete is spend that bought nothing, and the receipt says so. `aggregate` then splits value-delivered from total spend across a chain — charging *every* attempt (including the failed ones) against the results actually delivered — so `tokens_per_completed_unit` / `uj_per_completed_unit` / `value_per_joule` become the honest efficiency a "cost per token" number is designed to hide. Integers and strings only (JCR-1 forbids bools/floats); the rate figures recompute from the sealed inputs on read. +- **`jcp-efficiency`** — the **energy-efficiency spec**, surfaced as a sealed receipt. The dark-factory economics turn on four figures — **joules per accepted token, tokens per second, value per token, and the tokens/joules/dollars spent per COMPLETED, VERIFIED unit of work** — and the incumbents publish, at best, a *rate* (cost per token) that can't tell you whether the spend bought a result. An **`efficiency/1`** JCR-1 receipt records all four at honest provenance, hash-chained, and sealed against an **outcome anchor** (`completed` + a verdict) — goal-denominated energy accounting is a live line of work (`jcp-efficiency/MAPPING.md` §0 cites it); what the receipt adds is that the anchor is signed and verifiable rather than reported. A measurement that didn't complete is spend that bought nothing, and the receipt says so. `aggregate` then splits value-delivered from total spend across a chain — charging *every* attempt (including the failed ones) against the results actually delivered — so `tokens_per_completed_unit` / `uj_per_completed_unit` / `value_per_joule` become the honest efficiency a "cost per token" number is designed to hide. Integers and strings only (JCR-1 forbids bools/floats); the rate figures recompute from the sealed inputs on read. - **`jcp-energy`** — the metering ladder (SPEC §5.1): RAPL package counters (Linux powercap, wraparound-corrected, `HwShunt`, only while every package counter is live — `rapl_status()`), NVML GPU energy behind the `nvml` feature (`HwShunt` and `Partial`, since it does not read the CPU's share; only while live — `nvml_status()`), the macOS kernel's per-process CPU energy count (`proc_pid_rusage`'s `ri_energy_nj`; `HwShunt`, whole for in-process CPU work, only while live — `process_energy_status()`; it covers this process's threads, not children, the GPU or DRAM, so a span that reaps a child process or ends with one is `Partial`; each end of a span is read only once the metering thread is seen to have left its core, because the kernel counts a thread's energy into its process's only then, and a span with an end not so checked is the estimate, never a reading; it is live on macOS 27.0.1 where IOReport's CPU rails are not), Apple Silicon IOReport (`HwShunt`, only while every CPU energy rail, each die's on a multi-die part, is live — on macOS 27.0.1 that rail is republished in lumps, so there the rung is declined and `ioreport_status()` says why; `Meter::detect_explained()` names the rung selected and why each one above it was declined), a time×power model at a power the host calibrated (`ModelBased`, `Meter::time_power`), and estimates no host calibrated (`Estimator`): time × the documented default power — the rung `Meter::detect()` falls to, always available — and a constant per-op figure. A vendor counter's reading is real but vendor-opaque and relayed by the platform, and it counts as a reading only while the counter is live (SPEC §5). Measured when the platform exposes it, estimated when it doesn't — and the provenance always says which; a hardware backend that fails mid-reading degrades honestly to the default-power estimate. - **`jcp-gateway`** — the **energy-native MCP gateway**: a JCP enforcement point that sits in front of an MCP server so an existing client/server pair keeps its transport while every `tools/call` becomes capability-scoped, joule-budgeted, and sealed. The novel mechanic is two-phase metered enforcement: the call is *authorized* before it runs (no debit, because the cost isn't yet known), the upstream call is **metered** by the sibling Sandbox standard's energy probe (Apple Silicon IOReport, RAPL, NVML — vendor energy counters, whose readings are real but vendor-opaque and relayed by the platform, and which count as readings only while the counter is live for the work, SPEC §5; otherwise the figure is an estimate and is graded as one), and the metered joules are debited from the grant — so the budget that stops a runaway agent is denominated in joules, not a token estimate. Where the upstream server is a local process whose CPU energy the host's kernel counts live (macOS `proc_pid_rusage`), each call is read on that server's own process tree, the work's own process rather than the machine (SPEC §5.1, rung 3): sealed `HwShunt`, and `Whole` only when nothing was seen missing from the tree (no descendant reaped or exited in the span, no GPU client held, no in-process Neural Engine memory, every member read and quiet at both ends) and the operator has declared, with `--upstream-self-contained`, that the server hands no work to a process outside its tree; otherwise `Partial`, with the response's `_meta` naming why. Every decision, allow and deny, seals into a **hash-chained receipt log**: excise, reorder, or splice a receipt and the chain breaks at that point. A denied call never reaches the server (the live 2025–26 MCP exploits land on tool *output*, which the gateway frames as untrusted `data` that can never exercise a capability), and the `jcp-gateway` binary runs it over stdio in front of any MCP-server subprocess. This is the chokepoint the AI-gateway field occupies, on the two axes nobody there holds: the unit of account is the joule, and the audit is cryptographic and tamper-evident rather than a dollar figure and a span. - **`jcp-wire`** — the `jcp/1` wire binding (SPEC §11): 4-byte length prefix + canonical det-CBOR over any byte stream, with TCP and Unix-socket endpoints and a client. The decoder rejects non-canonical bodies, so a message has exactly one wire form. Requests carry the full delegation chain and are **caller-signed** — the endpoint authenticates from the request itself and denies an impersonation `bad-signature`, sealed like any other decision. Responses carry the deterministic decision and the sealed receipt. diff --git a/jcp/jcp-rs/crates/jcp-efficiency/MAPPING.md b/jcp/jcp-rs/crates/jcp-efficiency/MAPPING.md index f5ad3a7f0..ecb1095d8 100644 --- a/jcp/jcp-rs/crates/jcp-efficiency/MAPPING.md +++ b/jcp/jcp-rs/crates/jcp-efficiency/MAPPING.md @@ -17,10 +17,25 @@ tokens/second, value/token, and the tokens/joules/dollars spent **per completed, verified unit of work**. The incumbents publish, at best, a *rate* (cost per token). A rate cannot tell you whether the spend bought a result, which is why a large share of agentic projects are cancelled for cost/unclear-value. `efficiency/1` -seals all four **with the outcome anchor the rates omit** (`completed` + a -verdict): a measurement that did not complete is spend that bought nothing, and -`aggregate()` charges every attempt — including the failures — against the results -actually delivered. +seals all four **against an outcome anchor** (`completed` + a verdict): a +measurement that did not complete is spend that bought nothing, and `aggregate()` +charges every attempt — including the failures — against the results actually +delivered. + +**The anchor is not ours alone, and the record should say so.** Goal-denominated +energy accounting is a live line of work. *Energy per Successful Goal* (EpG) — +"total workflow energy across all attempts, including failures and retries, +divided by successfully completed goals" — is defined in Panigrahy, Tyagi, Abkin, +Houngninou and Mahapatra, *Energy per Successful Goal: Goal-Level Energy +Accounting for Agentic AI Systems* (arXiv:2605.22883, v2 2026-10-12), with a +measurement framework that attributes RAPL and ARM hardware counters to workflow +energy. That denominator is the one `uj_per_completed_unit()` computes, waste +included. Like SCI-for-AI in §1, it is a *calculation and reporting* convention: +the paper describes measurement, attribution and a reproducibility protocol, and +no part of it signs or attests the resulting figure. So what `efficiency/1` adds +is not the anchor but the artifact — a signed, honest-provenance, verifiable +receipt that carries it, which is what the §1 table itemises. (arXiv +non-exclusive licence: cited and briefly quoted, not reproduced.) ## 1. GSF SCI-for-AI → `efficiency/1` (ingest, not compete) diff --git a/jcp/jcp-rs/crates/jcp-efficiency/src/lib.rs b/jcp/jcp-rs/crates/jcp-efficiency/src/lib.rs index 57b232263..67b21a143 100644 --- a/jcp/jcp-rs/crates/jcp-efficiency/src/lib.rs +++ b/jcp/jcp-rs/crates/jcp-efficiency/src/lib.rs @@ -7,8 +7,11 @@ //! per token — are **rates**, and a rate can't tell you whether the spend bought a //! *result*. That's the gap this closes. //! -//! An [`Efficiency`] measurement carries the four figures that matter, plus the one -//! thing the incumbents omit — the **outcome anchor** (`completed` + a verdict): +//! An [`Efficiency`] measurement carries the four figures that matter, sealed +//! against an **outcome anchor** (`completed` + a verdict). The anchor is not +//! this crate's invention — goal-denominated energy accounting is a live line of +//! work (see `MAPPING.md` §0) — but a signed, provenance-graded receipt carrying +//! one is what `efficiency/1` is: //! //! 1. **joules per accepted token** — measured µJ at [honest provenance], not a //! vendor estimate. -- 2.54.0 (Apple Git-157)