An Odometer and a Doorbell

Leave an agent running and one of two things happens. It finishes, or it stops and waits for you. Neither one comes with a knock on the door.

I run agents on my own server every day, and almost nothing I've learned about running them has to do with the models. The models are fine. They are further along, honestly, than the habits I've built around them. The problem I keep hitting is dumber than intelligence and it has two halves.

The first half is that I don't know what the work cost. The second half is that the work can't reach me.

So I built two small tools, one for each half. Gauge is an odometer. Page is a doorbell. Neither one makes a model smarter by a single percentage point. Together they're the difference between an agent I have to sit and watch and an agent I can walk away from, and that turns out to be the only difference that matters.

An engine you can't measure and can't stop isn't a tool. It's a hazard with good manners.

Gauge answers a question you currently can't ask

Here's something strange about the last two years. We got software that can spend money and time on your behalf, in the background, at a rate you can't see, and the standard interface for it is a spinner.

If you pay for Claude Code or Codex on a subscription, you get a flat monthly number and then a wall. You hit a limit, or you don't. There is no gas gauge on the dashboard. There's no per-project accounting, no way to look at a week and say that one was expensive and that one was nearly free. You have a vague feeling that the refactor you kicked off on Tuesday was heavy. The feeling is all you get.

But the data is already on your disk. Both tools write transcripts as they work. Every request, every response, every token, sitting in files on your own machine, unread.

Gauge reads them. That's the whole trick.

npx github:joey-io/gauge

Nothing leaves the machine. There's no account, no telemetry, no server to send anything to. It walks the transcripts those tools already wrote and adds them up, and then it lets you slice the total: by project, by session, by model, by day, and by five-hour window. That last slice sounds like an odd unit until you look at one. A day broken into five-hour blocks is the first time most of us see the shape of our own working rhythm, and the shape is rarely the one we'd have described.

There's also gauge statusline, which puts a single line in Claude Code's status bar. One line. You stop opening a dashboard because the number is just there, the way the fuel gauge is just there, in the corner of your eye while you drive.

Now the part where I tell you the limits, because a number you can't trust is worse than no number.

The dollars Gauge shows are API-list-equivalent. That means: what this usage would have cost at published API rates. It is not your bill. If you're on a subscription, your bill is whatever you already paid, and it doesn't move. I made that choice deliberately and I'd make it again, because subscription plans don't publish their quota mechanics. Nobody outside those companies can tell you exactly how a session maps to your limit. Anyone who claims to is guessing and dressing the guess in a dollar sign.

So Gauge doesn't call itself a receipt. It's an odometer. It tells you how far you drove in units everyone understands. What that mileage costs you is a separate question with a separate answer.

And even as a pure relative measure, it changes what you notice. The finding that surprised me most is about subagents. When an agent spawns helpers, those helpers write their own transcripts, and they nest. Deeply. Deep enough that it's easy to build a tool that walks the obvious directory, reports a confident total, and quietly misses the majority of the work. In testing, roughly half the spend was down in those nested transcripts.

Half. Not a rounding error. If you've ever wondered why a task felt heavier than its final summary suggested, that's a strong candidate. The visible conversation is the tip. The fan-out underneath it is where the actual work happened, and it had been invisible the entire time.

The other slice worth sitting with is by model. Once you can see which model did which work and what that work weighed, the question of which model should I have used here stops being a matter of taste. Some of what you route to the heavy model is genuinely hard. Some of it is a file rename. You will not guess correctly about which is which, and the transcripts already know.

Gauge is MIT. There's a $3 supporter license if you want to pay for it, which is optional in the boring, literal sense of the word: it adds no features, it gates nothing, the tool is identical either way.

Page turns a stop into a question

The other half of the problem is the one I wrote about at length in Your AI Finished an Hour Ago. Nobody Told You., so I'll be brief here and then get to the part that piece didn't cover.

An agent working unattended produces two kinds of moments where it needs a human. The soft kind: it's done, and you'd like to know. The hard kind: it's reached a fork it shouldn't take alone, and it needs a decision. Both moments end the same way today. The agent writes something to a terminal nobody is looking at, and time passes.

Page is a remote inbox for whatever an agent decides is worth bringing back to you.

curl -fsSL https://a-gnt.com/page/install | sh
page login

It ships a page CLI and an MCP server, so Claude Code and Codex can page you without a line of glue code between them. You don't write an integration. The agent already knows how.

Everything that arrives is one of four typed things, and the typing is the design. A note is save this. A reminder is bring this back at 4pm. An update is tell me when the job finishes. A question is I need you to decide.

Four types, because an inbox where everything has the same weight is a feed, and a feed is something you learn to ignore. If a note and a decision look identical on your phone, you'll swipe past both within a week. Types are how the important thing stays important.

The fourth type is the one I'd hand you if you only tried one feature.

Questions block.

page ask "Deploy?" --choices "Ship,Review,Cancel"

The agent stops. Not "logs a warning and continues." Stops, and holds, and waits for a human. You get the question wherever you are. You tap one of three words. Your choice prints to stdout in the terminal that's been sitting there waiting, and the script picks up from that line and keeps going.

A program that pauses to wait on a human being is normally a bug. Here it's the entire point. That blocking call is a seam you can cut into any workflow, at any depth, at exactly the spot where you'd want to be asked. Not a review at the end, when the expensive thing has already happened and you're reading about it. A stop, at the fork, before.

The free tier covers the inbox, the CLI, the MCP server, the API, scheduling, questions, and email delivery. Pro is $19.99 a month and adds native push and SMS, which is worth it precisely when the answer needs to arrive in seconds rather than minutes. There's a native iOS app, because a decision that lives in your pocket gets answered and a decision that lives in an email gets answered eventually.

The two of them close a loop

Here's the pairing I didn't see until I'd been running both for a while.

Suppose Gauge tells you a project ate three hundred dollars of API-equivalent work last week. That's a real fact about the past, and on its own it's a slightly sick feeling and nothing else. You can't un-spend it. You can resolve to watch more closely, which is a resolution nobody keeps, because the entire reason you're running agents is so you don't have to watch.

Page is how that same project asks permission before it does the expensive thing again.

The number stops being a postmortem and becomes a rule. You know which task is heavy because you measured it. So you put a blocking question in front of that specific task, and now the heavy thing can't start without a human saying yes. The backward-looking instrument tells you where to put the forward-looking one.

That's the loop, and it's the same loop that every other kind of unattended machinery eventually grew. You meter the thing, and the meter tells you where to put the switch.

Neither instrument is smart. Gauge doesn't understand your code. Page doesn't understand your decision. Gauge counts what's already written down. Page carries a question to your phone and carries an answer back. They're both, technically, plumbing.

But look at what the plumbing enables, because this is the shift I think is actually underway and it isn't about capability at all. Work now continues when you aren't watching. That is a genuinely new condition for software, and it's why the tooling around agents feels half-built even when the agents themselves feel finished. We spent decades building interfaces for work that only happened while you looked at it. A spinner is an interface for a person who's staring at the screen. It's useless to a person who left.

Two things replace the spinner. Something that records what happened while you were gone, and something that can find you when the machine hits a wall it shouldn't climb alone. One measures, one interrupts. Neither raises the ceiling on what an agent can do. Both raise the floor on what it's safe to let one do without you in the room.

I keep coming back to how unglamorous this is. The interesting work in this field is model capability, and I'm not going to pretend an odometer competes with that for attention. But nobody has ever handed a person a machine that runs unattended without also handing them a gauge and a stop button. That pairing is old. It's older than software. We simply haven't gotten around to building it for this particular engine, and neither half is hard. They're both small tools. That's the point of them.

There's a version of this argument that sounds like caution, and I want to be clear that it isn't. I'm not asking anyone to run agents on a shorter leash. The opposite. Every hour I've spent hovering over a terminal watching output scroll was an hour the agent didn't need me for, and I only hovered because leaving felt reckless. Measure the work and put a stop at the fork, and leaving stops being reckless. The instruments are what let you be less careful, not more.

So: two commands, and then go do something else.

npx github:joey-io/gauge
curl -fsSL https://a-gnt.com/page/install | sh && page login

Run Gauge first, on the work you've already done this week. Sort by project. Find the one that's heavier than you expected, because there will be one, and there's a decent chance it's a fan-out of subagents you never knew were running.

Then put a page ask in front of it.

Leave the agent running. This time, when it stops and waits, your phone will know. Both tools live at a-gnt.com, and both exist for the same reason: the odometer tells you where the expensive road is, and the doorbell means you're the one who decides whether to take it again.