# Value Dashboard — what does the package cost, what does it bring?

> This page answers **one** question in real numbers: *How many more tokens does the package cost me, and how much does it save back afterwards?* Generated by `scripts/render_value_md.py` from the latest `value-v1` report; source: `internal/bench/reports/value/latest.json`.

## How to read this page

**Panel A (token ladder)** — read top to bottom. Each rung states: *what it does*, *how many input tokens it adds or saves per request*, and *where we stand cumulatively*. The bold **NET** line at the end is the answer. Deliberately pure tokens — no € comparison, since subscription users pay no per-request API prices.

**Panel B (behavior)** — four real comparisons, *with* vs. *without* the package. This is where the non-token value lives: fitting skill selection, stops on risky actions, fewer clarifying questions, more completed tasks.

**Confidence markers** on each rung: `✅ measured` = a real value from a report in the repo · `⏳ pending` = not yet measured, the rung contributes 0 to the sum · `⚠️ vendor-claim` = a vendor's claim, not measured by us.

## Reference scale

- **1,000** requests, on average **8,000** input tokens and **600** output tokens per request
- Model tier (workload assumption): `sonnet`
- Anyone running a different workload recomputes it themselves — the methodology is disclosed; nothing is hardcoded or hidden.

## Panel A — Cost ladder (cumulative, min → max)

Reads top to bottom. Positive Δ values = the package *costs* tokens (rule load is the honest up-front tax); negative Δ values = the package *saves* tokens.

| Rung | What it does | Δ tokens | Cumulative | Source |
|---|---|---:|---:|---|
| **Without package** | Baseline — the bare request without package rules. | +0 | +0.00% | `n/a` · ✅ measured |
| With package (rule load) | The always-active rules land in the context of every request. ⚠️ costs first | +59 783 | +747.29% | `internal/bench/reports/projection-cost.json` · ✅ measured |
| | _Footnote:_ Eager default: all 79 rule files always-on in the `.claude` projection path (0B.6-confirmed for the primary tool). Not just the kernel — this is the honest up-front load; tokens ≈ chars / 4. | | | |
| + thin (rules as pointers) | Non-kernel rule bodies become router-resolved pointers. | -46 222 | +747.29% | `internal/bench/reports/projection-cost.json` · 🔁 available (default off) |
| | _Footnote:_ Available behind `lean_projection.mode=thin` (default `eager-all` — hence NOT in the default NET). With thin active: rule layer 59783 → 13561 GPT tok (−46222, −77.3%). MUST-LOAD floor `task trigger-coverage` 26/26 green; live A/B validation pending (harness declined). Rollback = one flip. | | | |
| + condense (rule shrink) | Build step shrinks rule files before shipping. | -186 | +744.96% | `internal/bench/reports/telegraph-v2.json` · ✅ measured |
| | _Footnote:_ Aggregate across non-Thin-Root categories; Thin-Root files (AGENTS.md variants) net negative (~−4%) and are excluded from the rung — surfaced separately. | | | |
| + rtk (filter CLI output) | rtk cuts verbose CLI output before the model input. | -585 | +737.65% | `internal/bench/reports/rtk/latest.json` · ✅ measured |
| + terse (shorter replies) | Telegraph style aims at terser model replies. | +56 | +738.35% | `internal/bench/reports/telegraph-v1.json` · ✅ measured |
| | _Footnote:_ Honest: measured median = -9.27% against 'be terse' — telegraph delivers more tokens here, not fewer. We measure, we do not hide. | | | |

**NET: extra cost** ⚠️ — **+59 068 tokens / request**, cumulative **+738.35%** vs. baseline.

## Panel B — Behavior (with vs. without)

Four real comparisons from actual bench runs. This is where the value lives that tokens alone do not measure: whether the agent picks the right skill, stops on risky actions, asks fewer clarifying questions, and completes more tasks.

| Metric | What it means | With package | Without package | Δ | Mode |
|---|---|---:|---:|---:|---|
| Right-skill selection | How often the right skill activates (top-K hit). | 50.0% | 0.0% | 50.0% | ✅ live |
| Destructive-op stops | How often the agent stops / asks before destructive ops (of 5). | — | — | — | ⚠️ dry-run |
| Ask-vs-act ratio | Ratio of clarifying questions to actions — lower = more decisive. | 0.000 | 0.000 | 0.000 | ✅ live |
| Task completion rate | Share of tasks the agent completes fully. | 84.6% | 0.0% | 84.6% | ✅ live |

## Glossary

Plain-language definitions for the non-developer reader.

- **Token** — the unit a language model bills in. Rule of thumb: one token ≈ 4 characters of German/English prose. 1,000 tokens ≈ 750 words.
- **Input tokens** — everything the model reads per turn (system prompt, always-active rules, your message, earlier conversation). The package adds rules here — installation costs input tokens.
- **Output tokens** — what the model writes back. Usually fewer than input. More expensive per token than input.
- **condense** — a build step that shrinks the rule files before shipping (`.agent-src.uncondensed` → `dist/agent-src`). Saves input tokens on every request.
- **rtk** — the *Rust Token Killer*, a CLI wrapper that filters verbose output (`git status`, lint output, test runners) before the model reads it. Saves input tokens on tool calls.
- **terse / telegraph** — a style (short phrases, dropped articles) the agent uses for terser answers. Saves output tokens — when the corpus rewards it.
- **Without package / With package** — the two arms of the A/B comparison.
- **Δ tokens** — input-token difference per request against the baseline. Deliberately the only cost unit: a € comparison would imply per-request API prices that subscription users do not pay.

## Methodology & sources

This page is a **derived** view — not its own measurement. It summarizes three existing bench surfaces (see the 'Source' column in Panel A). The machine-readable raw reports remain the source of truth:

- `internal/bench/reports/telegraph-v1.json` / `telegraph-v2.json` — Telegraph/condense measurements.

- `agents/runtime/frugality/baseline.jsonl` — the package load (Metric A footprint).

- `internal/bench/reports/rtk/latest.json` — the rtk measurement (new, Phase 2).

- `internal/bench/reports/ab/*-ab-trackb-{with,without}.json` — A/B Track B (behavior).

- `internal/bench/reports/*-dev.json` — dev-corpus selection accuracy.


**A/B technical appendix:** [`docs/benchmark.md`](benchmark.md) carries the cache-key, integrity, and methodology details of the A/B bench — anyone who wants to see the variant-axis proof reads on there.


**Notes from the report:**

- Cost is reported in tokens only — no € figure. Per-call API pricing misleads subscription users; tokens are the currency-neutral metric.
- Pending rungs contribute 0 to the cumulative until measured.
- Reference scale: 1000 requests × 8000 input / 600 output tokens per request.

_Last rendered: `2026-06-06T08:42:18+00:00`_
