StarkEno

What will this agent run cost, before you start it?

Every other tool answers afterwards. StarkEno answers first, then scores its own answer against the real run.

pip install starkeno Python 3.11+ · MIT · no account

Two measurements, and the convenient hypothesis dies

A simulator that hides its own error is worth nothing. These are both comparisons between the forecast and the real run, in full, in tokens:

Run 1 · Codex 7 nodes
linear, no retries

predicted · maximum scenario331,500

observed3,035,535

9.15× under its own worst case

Run 2 · Claude Code ~150 turns
loop with retries

predicted11,098,500

observed34,303,668

3.1× under, and 44× under the typical scenario

9.15 and 3.1 are not the same number.

The gap is not a multiplicative constant: the fix will not be one coefficient, and the work ahead is finding out what it depends on. Two points are enough to rule out the convenient hypothesis, not enough to draw a curve. The two runs differ in harness, shape, length and retries all at once, so they isolate nothing.

The direction, at least, is structural rather than arithmetic. The simulator counts context read back from cache only on retries, the way a single model call behaves. A real agent has no memory between turns: it resends its whole accumulated context every turn. In run 2 that re-reading is 97% of the spend, and across a normal week of work it is 60%.

A random error is a dead end. A structural one is a coefficient. That is why the wrong number is on the front page instead of at the bottom of a backlog, and why more measurements are needed, from someone who is not the author. Eight numbers are enough: no database, no transcripts. How to send one →

Try it right now, in three commands

No plugin, no hooks, no server, no network, no account. The example Blueprint ships inside the package, so these commands work the moment it is installed.

pip install starkeno

python -m starkeno preflight esempio  --output esempio.json
python -m starkeno preflight draft    --input esempio.json --format yaml --output bozza.yaml
python -m starkeno preflight analyze  --input bozza.yaml --confirmed --samples 50 \
                                      --format html --output report.html

The three commands running in a terminal — Real commands and real output, from a clean install.

Preflight report: four scenarios with tokens, LLM calls and latency; overall confidence and the provenance of every estimate — This is the screen you will get: same Blueprint, same numbers.

What shape the forecast has

This is where it separates itself from any other estimate.

Four scenarios, not one number

optimistic, typical, prudent, maximum: a single estimate for non-deterministic work would be a fiction, and four of them also tell you how wide the spread is.

It declares its own confidence

Every analysis carries its own confidence level on the front, instead of leaving you to infer it.

It says where every estimate came from

declared you said it, default it assumed it, inferred it worked it out. An estimate of unknown provenance cannot be checked.

It names the prices it does not know

“missing prices in the worst case for…”, instead of quietly using zero: absent money is absent, never zero.

And the bill for what you already spent

The finished, installable half: a stop hook re-reads the transcripts your agent already writes and reconstructs what your way of working costs, broken down by project, model, session, skill and MCP server. Claude Code and Codex in one account.

Column	Why it is there
Work cost	the only part that is actually the work
Loading cost	the price of preparing the work
Re-reading cost	paid again every turn, for the same material
Unknown outcomes	how much of the picture is guesswork
Unclassifiable rows	how much to distrust the rest

The last two rows are the ones other tools do not show you.

StarkEno's local account: weighted total, work cost, loading cost and re-reading cost — Example data, generated from a real transcript already scrubbed.

If all you need is the retrospective, good tools already exist. ccusage reads the same JSONL files and runs under npx. StarkEno exists for the half nobody else attempts: saying the cost beforehand, and then scoring it against the real one.

Nothing leaves your machine

No network call, no account, no telemetry. The bill is an HTML file on your disk and the database is local SQLite. The hooks exit 0 whatever happens: if StarkEno breaks, your work does not. Which is also why starkeno doctor exists, because a silent StarkEno looks exactly like a working one.

This page too. No external fonts, no CDN library, no analytics, no cookies: the only requests it makes are the images, hosted on GitHub. A gate in the publishing workflow fails the deploy if this page tries to contact anyone else.

Where it stands

The account works and installs on Claude Code and Codex.
The simulator runs from the command line, and you just tried it.
The comparison between the two is mounted by hand, with the MCP server: the README says how.
Anyone can make the third measurement, and it needs to be someone who is not the author.

The project on GitHub The gap, in full