Build1 distinct publisher3 min readUpdated
A one-developer tool refuses to guess which task burned the tokens, and in the process shows how much agent-cost reporting is arithmetic dressed up as observation.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Follow any of these and your For You feed starts watching them — no settings page required.
An allocation rule cannot fail, and that is the objection to using one. Divide a window's token total by commit count and the parts always sum to the whole, which looks like corroboration and is only division; the agreement comes from the rule, not from anything anyone observed [2]. The author's list of how the mapping actually breaks is the load-bearing part: one session can cover several tasks, one task can span several sessions, a branch can sit untouched while the operator investigates something else or reviews another person's work, and elapsed time says nothing about the computational weight of the prompts and tool calls inside it [3].
So the tool is built to be structurally incapable of the guess. `agent-cost measure` takes session IDs and nothing else, and the caller that already knows the task selects them [4]. The one adapter described, `spec-lane`, runs the binary as a subprocess and validates the JSON, the `measure/v1` protocol version, the schema, and the absence of forbidden personal dimensions, while the measurement side never learns what the task was [5].
The design the post sketches runs local observations, then auditable normalized facts, then explicit pricing status, then caller-selected sessions, then task-attribution policy, then an optional dashboard [15]. That puts four trust gates between a log line and a chart, with the chart last of six [16]. Most cost dashboards ship the first element and the last one and quietly interpolate the middle, which is where a session number becomes a task number without anybody signing for it.
The uncertainty handling is where the boundary earns its keep. An unknown model comes out `unpriced`. A Claude cache write with no TTL breakdown is priced at the cheaper five-minute rate and stamped `lower_bound`. Codex logs do not expose cache-write tokens, so no zero-valued cache-write row is invented [9]. Malformed events, unreadable files and cumulative counters that go backwards stay visible in `data_quality` [10]. "Fail closed" here means unsupported pricing or attribution does not become a confirmed value downstream [11], and unattributed usage is left unattributed rather than split into something that looks precise [12].
The stated requirements were logs staying on the machine, a small runtime dependency surface, auditable custom metrics, and machine-readable output another tool can consume [1]. Runtime makes no network calls and declares no Python dependencies, and the price catalog carries a version and SHA-256 digest into the output [7]. The author then limits his own claim: installing from PyPI still means trusting a registry, an installer, a build backend, a runtime and an operating system, and the tool needs read access to the logs [8]. Scoping a zero-network claim to runtime behaviour is rarer than making it.
This is one developer writing about his own package, `coding-agent-cost 0.1.0`, rerun in temporary `uvx` directories where the doctor command located the local sources [13]. He is explicit that broader CLIs, local visual dashboards and OpenTelemetry stacks are answering different questions rather than doing this badly [14]. Which leaves the reader's own test: if your per-feature agent cost cannot be traced to a named set of session IDs, it is a convention.
Ranked by verification strength, evidence, and original report placement.
The author says he built agent-cost not because he was unaware of existing token and cost trackers (multi-agent reporting CLIs, local dashboards, OpenTelemetry-style observability stacks) but because his operational workflow required agent logs to stay on the machine, a small runtime dependency surface, custom metrics he could audit, machine-readable output another tool could consume, and above all that session measurement and task attribution remain two different claims.
The post names an attractive shortcut for task-level cost reports: measure usage in a time window, find the issues or branches active during that window, and apportion the total by working time or commit count. It always produces numbers that add up, but the agreement comes from the allocation rule, not from an observation.
One session can cover several tasks; one task can span several sessions; a branch can stay unchanged while the operator investigates a different issue or reviews someone else's work; and elapsed time does not describe the computational weight of prompts and tool calls.
agent-cost measure accepts only session IDs selected by its caller and does not infer a task from a branch, pull request or timestamp; a workflow that already owns the task-to-session binding passes the corresponding session set.
The spec-lane adapter invokes agent-cost as a subprocess and checks the JSON, the measure/v1 protocol version, the schema, and forbidden personal dimensions; agent-cost does not learn what the task is.
agent-cost reads logs that Claude Code and Codex CLI have already written locally and normalizes each usage event into a fact with a model, token kind, timestamp and count.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Detailed but wholly self-reported
Every factual claim rests on one first-person post by the tool's author. The technical detail is unusually specific and internally checkable (CLI invocations, measure/v1 protocol, unpriced and lower_bound labels, data_quality field, catalog version and SHA-256 digest), and the author pastes a dated rerun transcript, which is better than an unverified announcement. But there is no independent test, no second publisher, and the reasoning claims about session-to-task mismatch are argued rather than measured, so evidence stays below the midpoint.
0.1.0 with one author-owned integration
Adoption evidence exists but is minimal: a published, uvx-installable coding-agent-cost 0.1.0 package and exactly one disclosed consumer, the author's own spec-lane adapter. No downloads, installs, external users, teams or contributors are reported anywhere in the supplied source.
Self-limiting rather than overstated
The post repeatedly narrows its own claims: the zero-network property is scoped to runtime with installation-time PyPI trust explicitly left in place, the output is called an estimated list-price figure rather than a bill, 'fail closed' is defined down to mean unsupported values do not become confirmed downstream, and competing tools are framed as fits for other jobs rather than inferiors. The one place framing outruns evidence is the implicit generality of the argument that mainstream task-cost reporting is arithmetic dressed as observation, which is asserted from a single practitioner's experience. Net: slightly understated.
Author writing about his own package
The sole source is the tool's creator publishing on a developer platform about his own released package and his own spec-lane adapter, which is a clear promotional interest and the reason no independent check exists. It is tempered by unusual self-disclosure of limits (supply-chain risk, estimated rather than billed cost, explicit statement that agent-cost alone will not label a session as belonging to an issue) and by the absence of any disclosed commercial, funding or vendor relationship in the supplied material.
Coherent single-source account, unverified
Confidence is capped by structure rather than by contradiction: one publisher, one author, no independent verification, and an early 0.1.0 artifact. Within those limits the account is specific, internally consistent and self-limiting, and its central conceptual claim (session usage observable, session-to-task attribution a separate claim) does not depend on the tool being good. Nothing in the supplied material contradicts any claim.
build
Making docs cite a test at a known commit turned into a coverage audit1 distinct publisher
product
A 2x LLM bill is not a bug report: token spend is an observability problem1 distinct publisher
build
A cost monitor overcounted 4.9x, then went dark for a week when set -e did its job1 distinct publisher
build
2,513 tool calls, zero refactorings: what agents actually do when you ask them to refactor1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 22, 2026