a hungry orb that eats your agent's context

it snorbsyour context.

try it: scroll to feed the orb · move your cursor and it follows

every agent turn re-reads the whole chat from cache. snorb makes that physical: as the orb eats words, “context” grows and the opus-vs-sonnet price gap shrinks from 1.88x toward 1.26x.

↓ see the cost story tools ↓

$0.20per 1M cache reads. same on both models.
1.88x → 1.26xopus / sonnet per turn, 20K → 400K.
$1.50to switch models at 300K. a 20K handoff: $0.10.

pump.fun ↗

nom

$snorb

HouP…pump

scroll to feed me ↓

every turn, your agent
re-reads all of this.

user the login flow logs people out at random. fix it, keep the tests green.

tool_use read_file src/auth/session.ts tool_result four hundred lines of session logic, refresh timers, a cookie helper and one very suspicious setTimeout.

assistant the refresh races the logout. if the token expires mid request, the retry fires after the cookie is cleared and the user gets bounced.

tool_use grep "refreshToken" tool_result nine matches across middleware, the api client, two hooks and a test that nobody has run since spring.

tool_use run_tests auth tool_result three failing, one flaky, the rest asleep. stack traces, snapshots, a wall of yellow warnings.

assistant adding a single flight lock around refresh so concurrent calls wait for one promise instead of racing each other into the void.

tool_use edit_file src/auth/session.ts tool_result diff applied. forty lines in, twelve out, one comment that says do not touch.

tool_use run_tests auth tool_result green. green. green. one flaky test still flaky, as is tradition.

this fake agent log is snacks for snorb. scroll to feed it · scroll back up (or hit spit it out on the meter) to restore the words.

01 cost story · keep scrolling to grow the cache

three beats. same models, same price sheet. watch the “2x” gap melt.

context size20.0Ktokens

1.88x

how many times more an opus turn costs vs sonnet

step 1 · 20K fresh session. opus really is ~2x here — most of the turn is new tokens + output, where opus costs double.

step 2 · 150K deep in the session. old context is a cache read at $0.20 / 1M on both models. the gap is melting.

step 3 · 400K most of every turn is old context, billed the same on both. opus only needs ~21% fewer turns to cost the same.

sonnet

$0.033

opus

$0.062

re-reading old context writing new bits model output

example turn: 5,500 new tokens + 1,500 output · 5-min cache · anthropic list prices.

cost calculator

how: drag the sliders. left = your turn shape. right = live bill for sonnet vs opus.

how big the conversation is 150K new stuff each turn 5,500 model output each turn 1,500

turns if sonnet 30 turns if opus 20

prices: anthropic list rates (per 1M) · sonnet 5.5 $2 in / $10 out / $2.50 write (5m) / $4 write (1h) / $0.20 read · opus 5.5 $4 / $20 / $5 / $8 / $0.20. source

opus costs this many × sonnet (per turn)1.49xopus must finish in 33% fewer turns to tie

sonnet 5.5

$0.059

opus 5.5

$0.088

re-read old write new output

10Kcontext in cache (log)1M

total · sonnet$1.76

total · opus$1.75

basically a tie

the escalation tax

caches are per model. switch a running session at 300K and opus re-writes all of it before reading a single file.

switch with the transcript$1.50

clean 20K handoff$0.10

≈ 17 opus turns at 150K, burned on re-caching

the coffee-break tax

default cache lives 5 minutes. walk away longer and the next turn re-writes the whole context.

one miss · sonnet$0.38

one miss · opus$0.75

1-hour cache adds ≈ $0.008 / $0.017 per turn. pays off at ~1 miss per 45 turns.

snorb a wallet

how: paste a solana address (or use phantom / sample). we pull real txs via helius — read-only — then show what an agent would pay to keep re-reading them.

public address only. never asks you to sign. never touches keys.

check your own logs

how: drop a usage.jsonl (one line per api call). we compute $/turn and $/pass per model in your browser — nothing uploads.

drop usage.jsonl or tap to pick a fileone json object per line · fields: task, model, passed, usage

results land here. read them in this order: $/turn ratio → avg turns ratio → $/pass.

the expensive model is not
always the expensive task.

sonnet turn thirty one. still circling the same three files, reading the same diff again, hoping it changed.

handoff.md the task, the failing check, the three files that matter. nothing else. no transcript, no dead ends, no forty turns of guessing.

opus fresh session, small context, reads the evidence, writes the fix, runs the check, done in a handful of turns.

snorb burp.

cheat sheet

tape these above your agent loop. short rules, big savings.

price turns, not tokens.cost per task = cost per turn × turns to finish.

output is the real 2x.thinking is billed as output. heavy output drags the ratio back toward 2x.

long sessions shrink the gap.old context is a cache read at the same $0.20/1M on both.

escalate early.pick the model while the context is still small.

escalate clean.new session + short handoff: the task, the failing check, the 3 files that matter.

pause a lot? 1-hour cache.running straight through? don't.

don't flip effort mid-session.changing top-level effort per turn breaks the cache.

judge by $/pass."opus feels better" is not a routing rule.