Your AI Finished an Hour Ago. Nobody Told You.

It's 9:41 on a Tuesday night and the migration has been running for forty minutes.

You're not doing anything. That's the strange part. Claude Code is doing the work: renaming tables, rewriting queries, running the test suite after every change. Your contribution for the past forty minutes has been sitting in front of a scrolling terminal, holding the laptop open like a pot that boils over the moment you stop watching.

Somewhere around minute fifty you'll want to go to bed. You won't go. Because the moment that matters — the one where the agent either finishes clean or hits the constraint nobody remembered — is going to arrive in a terminal buffer on a machine you're no longer looking at. If you leave, the work keeps happening. The news stops.

So you stay. The most capable autonomous software ever built, and you're supervising it the way you'd supervise rice.

I know that evening too well. I build with agents every day, mostly on machines I'm not sitting in front of, and I finally got tired enough of babysitting them to do something about it. I built Page. This piece is about the problem it solves, because the problem is bigger than any one product: the handoff between an AI that can work without you and the human who left the room was never built.

The scrollback problem

Something changed in the last couple of years, and the furniture of our working lives hasn't caught up with it.

AI agents used to be conversation. You typed, they answered, you typed again. The unit of work was one exchange, and you were present for all of it by definition. Now the unit of work is the session: an agent picks up a task, plans it, executes it, checks its own output, and keeps going. An hour of unattended work is normal. An overnight run is not exotic.

And in the middle of those long runs, things happen that you would genuinely want to know about the moment they happen. The build goes green. The root cause turns up in a file nobody suspected. The agent reaches the step you told it to be careful with, and it needs a decision only you can make.

Here is where those moments currently go: into scrollback. Into line 3,000 of a log on a machine in another room, or another city. The agent announces its discovery with exactly the same volume as it announces everything else, and then keeps scrolling. If you've ever come back to a finished session and spent ten minutes scrolling up to find out when it finished and what it decided along the way, you know the ritual. The work was autonomous. The finding out was manual.

That gap — between an agent that can work without you and a human who has no way to hear from it — is the thing that kept me chained to my own terminal. It's the gap Page closes.

It's not a notification problem

The obvious objection: your phone already buzzes plenty. The last thing anyone needs is a new source of pings.

That objection is exactly right, and it's why the answer isn't "notifications for your terminal." A notification system treats everything that happens as the same kind of event: something occurred, here is a string about it. Slack does this. Email does this. Every webhook-to-phone bridge ever duct-taped together does this. They flatten.

But listen to what an agent actually wants to tell you mid-session. It's not one kind of thing. It's four:

Save this. "The beacon relay bug is caused by duplicate peer IDs." A finding. You don't need to act on it at 11pm. You need it to not be lost.

Bring this back later. "Remind him to call the vet at 4." A thing with a time attached, useless before that time and urgent after it.

Tell me when it's done. "Migration complete, 240 tests passing." A status change on something you were waiting for.

I need you to decide. "Tests pass. Deploy to production, or hold for review?" A question. The agent cannot proceed — should not proceed — until a human answers.

Flatten those four shapes into one buzz and you get noise, because the reader has to open every single one to find out whether it was a shrug or a fire. Keep the shapes, and something interesting happens: the inbox starts meaning something. A note can sit quietly. A reminder can wait until 4pm to exist. An update can be one glance. And a question can be loud, because a question is the one shape that has a human on the critical path.

Page keeps the shapes. Every page is typed — note, reminder, update, or question — and the type decides how it behaves: when it arrives, how it sounds, whether it expects anything back from you.

The question is the important one

Three of those types make life more convenient. The fourth is the reason I built the thing: it changes what you can safely let an agent do.

Here's the flow, in its entirety:

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

That command blocks. The agent that ran it is now standing still, mid-session, holding its work. Your phone shows a question with three buttons. You're at dinner. You tap Ship. In the terminal, possibly hundreds of miles away, the word Ship prints to stdout, and the session moves.

Sit with the inversion for a second. We've spent years on hold with software — spinners, progress bars, "your call is important to us." This is software on hold for you. The human is the slow, expensive, occasionally-at-dinner service that the machine has to wait on. And it waits politely, for hours if it has to.

What that buys you is not convenience. It's permission. Everyone who works with agents has a version of the same standing worry: what's the biggest thing I can hand this system without babysitting it? The honest answer has always been bounded by the scariest irreversible step in the task. Nobody hands an agent a deploy, a mass email, a DROP TABLE, and then goes for a walk.

With a blocking question in the loop, you can draw the line differently. The standing instruction becomes: do everything, and page me before anything irreversible. The agent gets the whole task. You keep the three decisions that were ever actually yours. Both of you got a better deal.

What this looks like in practice

Page is a remote inbox with a one-line install:

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

That drops two things on your machine: a page CLI you can use directly, and an MCP server your agents use on their own. Hook it into Claude Code with one command:

shclaude mcp add pager -- node ~/.local/share/pager/mcp.js

Codex takes four lines of config. After that, the sentence "page me when the build finishes" is a working instruction, not a wish. The agent has six tools — send, remind, ask, update, list, and wait-for-response — and it uses them the way it uses any other tool: when the situation calls for it.

The three human-side flows cover most days:

shpage "Rate limiter idea: token bucket per API key"   # a note, now
page "Call the pharmacy" --at 4pm                    # a reminder, later
page ask "Merge the PR?" --choices "Yes,Wait"        # a question, blocking

Pages land in the inbox at a-gnt.com/page and in your email on every plan, free included, along with the CLI, the MCP server, scheduling, and questions. The whole working system, no card required. Pro, at $19.99 a month, adds the two delivery channels that cost real money to run: native push notifications on your phone and text messages. If you want the buzz-in-your-pocket version rather than the check-your-email version, that's the line.

Accounts are a-gnt accounts, or a phone number and a six-digit code. Tokens are minted per device, at login or from the CLI. The iOS app syncs reminders to Apple Reminders and Calendar on the device itself.

What it doesn't do

Page doesn't read your codebase. It doesn't watch your sessions, doesn't summarize your week, doesn't generate anything. It has no opinions. It moves exactly what your agent hands it, in the shape your agent chose, to wherever you are — and nothing else.

It's also not a chat app. You can't reply to a note with a paragraph and expect a conversation; the only structured answer that flows back is your tap on a question's choices. I kept it that way on purpose. The moment the inbox becomes a place where discussion happens, it becomes another place you have to manage, and the entire point is that you don't manage it. You glance at it.

And your agent won't page you until you tell it to. There's no ambient surveillance of your terminal. The instruction has to exist — in your prompt, in your project's standing instructions, wherever you keep the sentences your agent always follows. One line is enough. Something like: when a long task finishes or you need a decision, page me. You write it once and forget it's there, until the first time it matters.

Autonomy is a contract about interruption

There's a bigger idea under this, worth saying plainly.

The anxiety about autonomous agents — the practical, Tuesday-night kind — has never really been "what if it does something evil." It's been "what if it does something, and I just wasn't around." Silence is the thing that erodes trust. An agent that can't reach you when it matters gets watched constantly, which means it was never really autonomous at all. You just relocated your attention from doing the work to staring at the work.

The fix isn't a smarter agent. It's a better contract. You're allowed to leave; it's obligated to reach you when — and only when — something crosses the threshold you set. A note when it learns something. A buzz when it finishes. A question, and a full stop, when the next step is one only you should take.

That contract is what the best human working relationships already run on. Nobody hovers over a colleague they trust. They say take it from here, and grab me before anything ships. The grab-me part was never optional. It was the load-bearing clause that made take it from here possible.

Agents just needed a way to grab you.

9:41, again

Run the evening back. The migration starts. You watch it for two minutes, because old habits, and then you type one more sentence — page me when it's done, and ask before deploying — and close the laptop. The house gets the rest of your Tuesday.

At 10:15 the phone buzzes once. Migration complete. 240 tests passing. Deploy? Three buttons. You press Ship without getting off the couch, and somewhere in a terminal you can't see, the word lands and the machinery moves.

The work didn't need you for the hour. It needed you for the second. Page's whole job is knowing the difference — and the install takes less time than one trip back downstairs to check the terminal.