Bill the invocation, not the hour — Tom<br>Most of my code is written by an agent now. I bill people for it, and I can’t tell you how long anything took. I suspect most agencies can’t either. I’ve been trying to fix that.

METR ran a controlled study and found that AI made tasks take 19% longer, not shorter, while the developers using it reported feeling faster. The unit we bill by, the hour, is the one thing about our own work we understand least. That worries me. I invoice people, and I'm billing them in a unit I can't even measure on myself.

Contractors and agencies bill hours. I've come to think hours are a fiction everyone agrees to maintain. One survey across consulting, legal, and accounting found that 22% of professionals record less than 70% of their time, and the leakage isn't random: email, phone calls, and meetings bleed the most, because they don't feel like deliverables. The person doing the work writes a story in their head, "reviewed the contract for Acme." The person billing needs a number, a client code, a matter, a rate. The gap between the story and the number is where revenue quietly dies. Timesheets are uncompensated labor, and a brain trained by hourly billing to ask "does this earn?" of every minute correctly refuses to do uncompensated labor.

So we automate, hopefully. Two flavors, and both feel wrong for what I do now.

Automatic tracking becomes surveillance: screenshots, keystroke logs, idle flags beamed to a manager in real time. Toggl, to its credit, refuses to ship that. Their own honest framing is that manual timers give you control and data quality, while automated capture gives you coverage and less friction, and there is no winner. And then agentic work breaks at both, at least from where I sit.

The agent runs for three minutes doing real work, calling tools, reading files, while I'm on another tab. Whose time is that? A provider stalls mid-stream for thirty seconds. The stopwatch bills it. I don't think it should. It's a retry, not work. The timesheet was built for a world where a human typed and a clock ticked. Now the agent types and the human thinks, and I think the clock is measuring the wrong body.

I really like using Modal, as it frames the serverless problem cleanly. Utilization is output achieved divided by capacity paid for. The whole game is to not pay for idle: match provisioned supply to demand, scale to zero. Marc Brooker's line, quoted by Modal: cost scales with peak traffic, value scales with average traffic. The gap between peak and average is exactly what serverless closes.

What if we took that to the agency? The agent is the on-demand function. A turn is an invocation. Bill the invocation by duration. Human idle is scale-to-zero: it costs nothing by default. Human oversight is provisioned capacity: you opt into a block, idle and steering bill against it, the leftover rolls forward. You set the budget. The engine spends it.

The first version of this idea you reach for is "just auto-track everything." That's surveillance with a receipt. Pure automatic billing charges the minutes you spent, including the minutes that went nowhere. You walked away. You changed your mind. The agent did nothing useful. The stopwatch bills all of it.

What we ended up trying is almost the opposite. Measure automatically, but only commit a bill when the work landed. Two rules do most of the work.

01Compose Measured locally<br>02Queue Staged, not billed<br>03Invoke Tokens + tool time<br>04Deliver Outcome lands<br>05Commit Receipt changes

Nothing becomes billable until the work crosses the delivery boundary.

Idle bills only when your next submit produces agent work. You sit and think for ten minutes, then send a prompt and the agent runs. That idle bills. You sit and think for ten minutes, then close the laptop. That idle bills nothing. I've come to think idle with no output is wasted, and it shouldn't be billable.

Steering bills only typing that actually reached the agent. You queue a follow-up while the agent runs, then revert it, re-edit, re-send. That bills once, at delivery. You queue it and delete it. That bills nothing. No agent outcome, no bill.

Bill forward progress, not process. That's the part I'm most sure about. The clock still runs. It only rings when something landed.

There's a third choice that matters more than it looks: we detect engagement, we don't demand it. A human-time window opens on your first keystroke after a turn, not on a Start button you'll forget to press. But a single stray key bills nothing. Only a real typing burst counts. So it's automatic, and it still respects that you have to actually be there. Nobody starts a timer. Everybody who bills was present.

The interesting part is how you stop the abuse without becoming a cop.

Token-normalized billing. Agent time per turn is output tokens divided by a reference tokens-per-second, plus real tool-execution time.

agent_ms = (output_tokens / reference_tps × 1000) + tool_ms

75 reference tokens / second<br>3s...