Thirteen days with an agent

Four labels recur through this piece: Fact read directly from the session store, Inference a conclusion drawn from two or more of those facts, Estimate an assumption used where the data is incomplete, Opinion a judgement call.

Fact Over 13 days, on the mac mini, across 14 repositories, a background process that never opened a file cost more than twice as much as the agent doing the actual engineering. The main session, the one we steered (the “we” here is literal: one engineer and one agent, and the work the two of us produced together), took 29.0% of $3,970.99 in metered cost as inferred by OMP. A background advisor, a second model that watches the live session and flags problems, called zero tools and took 67.1%. That is backward from the obvious guess, and the rest of this piece is built around why. Five questions follow:¹

• How the collaboration ran.
• Which tools mattered most.
• Where the money went, model by model.
• How long any of it lasted.
• When, across the day, any of it happened.

Fact The fourth question alone needs five honest answers, and the obvious one is wrong. One engineer, one machine, 13 days: not a benchmark. The honest limits come next, not buried at the bottom.¹

Opinion Everything below comes from the same snapshot, and every figure is in the tables further down. I am publishing it because the useful part of measuring your own agent is not the totals; it is that the totals point at four or five specific settings you can change this afternoon.

Which model to put on which role

Fact The role split is not just how much each role costs; it is which model answered for it. The main session ran anthropic/claude-opus-5 for 3,994 of its turns at $0.242 a turn. The advisor ran anthropic/claude-fable-5 for 9,438 of its 11,755 turns at $0.239 a turn. The subagents split almost evenly between two models on the same read-heavy work: anthropic/claude-opus-5 for 400 turns at $0.318 a turn, and anthropic/claude-sonnet-5 for 397 turns at $0.066 a turn.¹

Inference That subagent pair is the cleanest experiment in the whole dataset, and I did not design it. Two models, near-identical turn counts, the same job of reading and grepping, and a 4.8 times gap in cost per turn. Nothing in the output justified the difference.¹

Estimate If the advisor had run at the rate the subagents got from claude-sonnet-5, its 11,755 turns would have cost about $778 instead of $2,664.97, which is roughly $1,887, or 47.5% of the whole bill. Treat that as a ceiling rather than a forecast: the advisor reads a larger context than a subagent does, so its per-turn cost would land above $0.066 whatever model runs it. The direction is safe even if the size is not.¹

Opinion The tiny-model row is the one recommendation here with no evidence behind it. anthropic/claude-haiku-4-5 has the fastest time to first token in my performance table at 1,393 ms, but only 40 samples and no turns at all inside the snapshot. I am picking it on latency and saying plainly that I have not proven it.²

The capabilities that earned their place

Fact Four tools carried 77.2% of 6,690 calls: bash 1,958, read 1,728, edit 766, eval 712. Below them, write 442, grep 393, hub 159 for messages between agents, and todo 150.¹

Opinion Two of those deserve singling out. eval at 712 calls is the agent computing an answer instead of estimating one, and almost every number in this piece exists because of it. hub at 159 calls is agents coordinating with each other rather than through me, which is the only reason a thousand-step run stayed coherent. I would not trade either.¹

The capabilities I paid for and barely touched

Fact task, which spawns subagents, was called 12 times in 13 days. Those 12 calls produced 30 subagent rollouts that made 1,307 tool calls for $153.45, which is 3.9% of the bill at $0.193 a turn, the cheapest role I have. Meanwhile the main session did 939 of the 1,728 read calls itself, at more than twice the price per turn.¹

Fact checkpoint and rewind were called twice each. In the same window, 4 sessions hit context compaction, one of them four times, and 9 sessions had their context reset mid-run.¹

Inference Those two facts belong together. Compaction and resets are what happens when a session fills with exploration that could have been checkpointed and discarded. I had the tool for exactly that problem and used it twice.

What I did not know I was doing

Fact The advisor produced a rollout file in 24 of 24 sessions, including one that ran 7 model turns and cost $0.16 in total. It was never gated.¹

Fact Thinking level was set to max 29 times, high 16 times and medium 20 times, and never once to low or off. The result is 4,093,863 characters of hidden reasoning against 1,807,626 characters of prose I actually read.¹

Fact Of the shell command heads I ran inside bash, the two most common are echo at 1,033 and cd at 1,025, which together are more than git at 710. Neither changes a file.¹

Fact I typed /model 17 times and /switch 8 times, 25 manual model changes in 13 days.²

Inference Read those four together and a pattern appears that no single number shows: I was tuning by hand, per moment, instead of setting the thing once. Manual switching is why premium models ended up in places they should not be. In the main session claude-fable-5 cost $0.471 a turn and claude-fable-5-1 cost $0.312, both more per turn than the claude-opus-5 I was trying to be careful about at $0.242. The careful switching made it more expensive, not less.¹

The optimizations I am putting in place

Opinion Five changes, in the order I expect them to pay.

• Set a model per role once, and stop switching by hand. The advisor and the subagents both get a cheap fast model; the session I steer keeps the strong one.
• Gate the advisor on session length or on whether the run is unattended. It should not open a rollout on a 7-turn session.¹
• Delegate reading. task is 12 calls and the cheapest role I have; the main session should be editing, not opening files.¹
• Checkpoint before exploring, not after compacting. Two calls against 4 compacted sessions and 9 resets is the wrong way round.¹
• Drop the thinking level for mechanical steps. Max on every step is how you get 2.26 characters of reasoning for every character you read.¹

Opinion If you take one thing from this piece and apply it to your own setup, open the per-role breakdown of your own store before you touch anything else. Mine said the role that never opens a file was running a premium model on two thirds of my turns, and I would not have guessed that in the right order.

Fact Every number in this piece comes from three local stores on the machine that produced the work: the session rollouts, the append-only log each session writes as it runs (~/.omp/agent/sessions/<project>/<session>.jsonl, plus sibling files for the advisor and for each subagent, a short-lived helper agent spawned for one bounded task); the runtime database agent.db (command_usage, model_perf); and the prompt-recall database history.db (history). 78 rollout files carried at least one event inside the snapshot.^1,2,3

Fact agent.db table client_usage is empty for the whole window, so there is no second source to check cost against; every figure comes from the usage record embedded in each assistant turn. That is list-price accounting, and the store makes clear it is not an invoice: the usage_history table records rate-limit windows (5 hour, 7 day, daily, weekly) for every provider used here, which is what a subscription account reports, not per-token billing. Read $3,970.99 as API list-price equivalent value, not money that left an account.^1,2,3

Fact This is one engineer, one machine, 13 days, 14 repositories. Not a benchmark, not a population, not a claim about anyone else’s setup.^1,2,3

Fact A session object, the saved conversation thread a session file represents, can stay open for nine days if it keeps getting resumed, so raw session span is close to meaningless. Wherever “how long” matters below, this piece uses continuous-activity stretches (gaps under 20 minutes) or unattended stretches (no human message at all), never raw span.^1,2,3

Fact Two things the store cannot answer: (1) the task tool’s arguments are not preserved, so which kind of subagent ran (scout, reviewer, or something else) is not recoverable, and only the 30 named subagent rollouts and their filenames survive; (2) model identifiers are reported exactly as the runtime logged them, preview and internal names included. Nobody is translating anthropic/claude-fable-5 into a marketing name here, and you should not either.^1,2,3

Fact We put 285 messages into 24 sessions over 13 days; the main session answered with 5,295 model turns, 18.6 turns for every message we sent. That ratio is the whole relationship in one number: a short instruction in, a long run out.¹

Fact Most of our instructions were short: mean prompt length was 211 characters, median 51, and 26.0% of everything typed was under 25 characters. The log reads like this: “try now,” “apply it,” “check,” “go both,” “merge it, bump, release.” Not prose; someone glancing at a screen and firing off a verdict (read: me, most evenings). The longest single prompt ran the other way entirely: 7,410 characters, a pasted GitHub webhook payload, dropped in whole because explaining it would have taken longer than pasting it.³

Fact Between two of our messages, the agent took a median of 7 steps (n=286) before it needed a human again; the mean is 37.3, over five times higher, pulled up by a tail that runs to 1,068 consecutive steps with no human input at all. Inference A median of 7 beside a mean of 37 means most exchanges were tight check-in loops, and a few were close to unsupervised.¹

Fact We stopped for a clarifying question exactly 6 times in 13 days. The reverse happened far more often: the background advisor watching our live session interrupted, unprompted, 201 times (more on what that cost shortly). Four of our sessions hit context compaction, the point where the runtime compresses older messages to fit the context window; one of those sessions hit it four times. 9 mid-session resets followed (the store logs that a session’s context was cleared without opening a new file; it does not say why, and we are not going to guess).¹

Fact Across all 17,847 model turns, 73 ended in error (0.41%) and 39 were aborted (0.22%). Opinion That error rate is the real reason a thousand-step stretch felt safe to leave unattended: the failure mode worth worrying about, silent and wrong and expensive, is rare enough in this log to justify not checking in every few minutes.¹

Fact We made 6,690 tool calls in 13 days. Four tools carried nearly four of every five: bash, 1,958 calls, 29.3%; read, 1,728, 25.8%; edit, 766, 11.4%; eval, 712, 10.6%. Together, 77.2%, stated directly by the tooling’s own tally.¹

Fact Inside our 1,958 bash calls, the most common command head was echo, 1,033 times, then cd, 1,025, then git, 710. Behind those: head, grep, tail, jq, sed, curl, and 94 calls to gh.¹

Fact write, grep, and hub (inter-agent messaging) round out the next tier: 6.6%, 5.9%, 2.4%. Below that, usage falls off fast: todo 150 calls (2.2%), run_experiment 94 (1.4%), log_experiment 80 (1.2%), glob 51 (0.8%). Some tools we almost never used: learn, 16 calls; update_notes, 13; task, the one that spawns subagents, only 12, which produced 30 named subagent rollouts, 2.5 per spawn; harness_test, 7; ask, 6; init_experiment, 6; goal, 3; checkpoint and rewind, 2 apiece.¹

Opinion Six ask calls in 13 days does not read as a timid agent. It reads as one that mostly kept moving and reserved the interrupt for the moments that mattered. If it had asked more, I would call that a tuning problem, not a feature to be proud of.¹

Fact Three roles split $3,970.99 across 13 days:¹

Fact The main session, the one we steered, made every edit and ran every command. The advisor made zero tool calls across 11,755 turns: never opened a file, never ran a command, never edited a line. It watched the live session and interrupted, accounting for 65.9% of every model turn logged in 13 days.¹

Inference Dividing cost by turns for each role shows why the advisor’s share is arithmetic, not an anomaly: the main session costs $0.218 a turn ($1,152.57 across 5,295 turns), the advisor $0.227 a turn ($2,664.97 across 11,755 turns), named subagents $0.193 a turn. A single advisor turn is not unusually expensive; there are more than twice as many of them as main-session turns, because the advisor re-reads a growing session on every check, and none of that reading and interrupting ever registers as a tool call.¹

Opinion I used to assume the model doing the typing was where the money went. Measured against this log, the model doing the typing was less than a third of a bill split in a way we did not expect.

Fact Even the silent turns were not free. Total tokens across every role: 4,242,730,543, 4.24 billion, split across four classes:¹

Fact Cache reads, tokens replayed from an already-processed copy of the context and billed well below fresh-input price, are 98.4% of the entire input side; fresh input, tokens the model had genuinely never seen before in that context, is 0.19%.¹

Fact Hidden reasoning: 4,093,863 characters written. Visible prose returned to us: 1,807,626 characters. Inference That is 2.26 characters of reasoning for every character anyone read, computed straight from those two counts. Estimate Thinking was configured at high or max for most of the window (16 high, 29 max, 20 medium, never low, never off), which probably explains more of that ratio than the tasks themselves.¹

Opinion The advisor is not getting switched off; catching 201 bad directions across 13 days is worth something real. But it got priced for the first time while writing this, and it is the most expensive line item in this setup: worth a second look at whether it needs to run in every session or only the unattended ones.¹

Fact We split the work across eight named models, reported exactly as logged; nobody is translating internal identifiers into marketing names here:

Inference claude-fable-5 and claude-opus-5 together, 53.2% plus 24.6%, cover 77.8% of all 17,847 turns; the other six models split the remaining 22.2% between them. Turn share and cost share are not the same axis for any model in this set.¹

Inference claude-opus-4-8 ran 26 turns for $32.27: $1.24 a turn. google/gemini-3.7-flash ran 196 turns, more than seven times as many, for $6.93 total: $0.035 a turn. Which model answers a step matters more to the bill than how many steps there are.¹

Fact Self-measured throughput and latency, from agent.db, this machine only, not a benchmark. Fastest output throughput: gemini-3.7-flash on google-antigravity, 102.1 tokens per second. Slowest: gemini-3.7-flash on google, 32.6.²

Inference Same model name, different provider path: 3.1 times apart on throughput (102.1 against 32.6), and a comparable but not identical 2.8 times apart on time to first token, the delay before a reply starts streaming back: 9,273 ms against 3,291 ms. Routing, not the model, explains the gap; the identifier alone does not predict the experience.²

Fact anthropic/claude-haiku-4-5 has no row in the cost table: it produced no turns inside the cutoff. It appears only in the performance table, 40 samples, 71.8 tokens per second, 1,393 ms to first token, the fastest of the eight rows there. Opinion I trust claude-sonnet-5's 1,657 ms number more anyway; 190 samples beats 40. No model in this table beats it on both figures at once: gemini-3.7-flash on google-antigravity edges it on throughput (102.1 against 95.8 tokens per second) but takes 1.99 times as long to first token (3,291 ms against 1,657 ms), while claude-haiku-4-5 edges it on time to first token (1,393 ms against 1,657 ms) but claude-sonnet-5 produces 1.33 times as many tokens per second (95.8 against 71.8). claude-sonnet-5 is the balance of the three, at 0.7% of the total.²

Fact Ask how long the longest run took, and the honest answer depends entirely on what we are willing to call a run. The same 13 days produce five different measures:¹

Fact Answer 1 is 468.6 seconds, inside one subagent of a harness project; across 17,804 turns with a recorded duration, the mean is 7.9 seconds and the median 3.88. Answer 2 is 1,068 steps, 2.71 hours, inside a session titled “Optimize regex caching and verify iOS benchmarks.” Answer 3 is 3.75 hours, 796 steps, inside a session titled “Summarize work completed so far.” Answer 4 is 4.02 hours, on 22 August, in that same project.¹

Fact Answer 5 is 229.52 hours, from one deployment session, which held exactly 2 human messages, 47 model turns, and $4.00 of cost across its entire nine-day span. Inference That is nearly 57 times answer 4 (229.52 hours against 4.02 hours), and it is the wrong number to reach for: it describes a session object that kept getting resumed, not 229 hours of anything running. This piece discards it on purpose, not by rounding it away by accident.¹

Opinion If only one number survives from this section, keep answer 2: 2.71 hours and 1,068 steps is the real measure of how long anyone was willing to look away.¹

Fact 12 of the 13 days had activity; 26 August had none. The busiest day was 3 September, with 3,654 events.¹

Fact The daily pattern is sharper by hour than by day. Events peak at 09:00, 1,568 of them, and again across an evening block from 18:00 to 23:00. Three hours carry zero events: 01:00, 05:00, 06:00. One odd hour breaks the quiet: 03:00 carries 364 events.¹

Inference That 03:00 activity is a small number of long unattended runs continuing while the human was away, not the human working; the two dead hours on either side of it, 01:00 and 05:00, say the same thing from the other direction.¹

Fact Summed across every stretch with no gap longer than 20 minutes, active time totals 47.6 hours over the 13 days, 87 stretches, a median stretch of 17.4 minutes.¹

Fact The 24 sessions this piece draws on are not evenly worked. Two sit at opposite ends of how a session can run:¹

Inference The least conversational of the 24: 16 human messages carried 988 model turns and 1,012 tool calls, a session that ran mostly on its own once it started. The most conversational session ran the other way: 73 human messages against 337 model turns, 4.6 to 1 against the overall 18.6 to 1. Both extremes sit inside the same 13 days, on the same machine.¹

Opinion First, the advisor. 67.1% of the bill and 65.9% of the turns, for a process that reads and interrupts but never touches a file, is not automatically wrong; catching 201 bad directions across 13 days has real value. But I priced it for the first time while writing this, and I am now checking whether it needs to run on every session or only the ones spent unattended.¹

Opinion Second, the cache-read number. 98.4% of the input side being cache reads is efficient, and I am going to watch that percentage the way I watch an error rate; a drop in it would tell me about a context-management problem before the invoice does.¹

Opinion Third, when. 364 events crossed the log at 03:00 while long unattended runs were still going. If a long unattended run is going to happen, I now start it in the evening, between 18:00 and 23:00, when I am still near the keyboard, not in the early hours when nobody is watching either end.¹

Opinion Fourth, and this is the actual invitation: if an agent runs daily in your setup and you have never opened the table it keeps for its own background processes, open that one first. In my case, that single table accounted for 67.1% of the cost I had not looked at until this week.¹

Items 1 to 3 are local stores on the machine that produced the data. Items 4 and 5 are the external dependencies this page loads.