I'm Betting My Company on Proactive Agents · Polylane Join the waitlist

Join the waitlist<br>Continue with GitHub<br>or

Join with email

Agents can do almost anything you ask them to, and that’s the problem: you still have to ask .

I keep hearing people call agents “digital coworkers”. That framing is wrong. A coworker who sits in silence until you hand them a perfectly-scoped task, completes it, then goes back to waiting, is not a coworker. Every agent you’ve ever used works exactly like this. The models got smarter, the harnesses got better, the runs got longer, but the interface never changed: you bring the work, the agent brings the labour.

And most people haven’t noticed, because the prompt box has quietly become what AI is in our heads.

Ask anything about your stack...

The default interface of AI.<br>Every interface is still a prompt box

The input box is how this whole era started. ChatGPT put one on top of a model and became the fastest-growing product in history, and we all copied it. Every AI product since has been a variation on the same interaction: human types, machine responds, machine waits.

Claude Code was the next evolution. The agent moved into your terminal, picked up your files, your shell, and your git history, and started doing real work instead of talking about it. It changed what agents could do, but not how they start: you type, it works, it stops, and it waits for you to type again.

~/app<br>$ claude<br>✳ 12 files · main · last session 2h ago<br>> fix the failing checkout tests<br>? for shortcuts

The same input box, in a terminal.<br>Then agents moved to the cloud. Codex, Devin, Claude Code on the web. They run for hours instead of minutes, spin up sub-agents to parallelise the work, and don’t die when you close your laptop. You hand one a task before lunch and come back to a pull request.

The prompt even stopped being a keyboard-only thing. Background agents can be kicked off by an alert or a webhook, and most agent platforms now offer automations: when this event fires, or this cron ticks, run an agent with these instructions.

Triage Sentry alerts<br>Enabled

When a Sentry alert fires<br>Do investigate, open an incident if it's real<br>Then post the findings to #incidents

An automation: the agent acts on an event, following instructions you wrote.<br>But what is an automation? It’s a prompt you wrote in advance . You predicted the failure mode, picked the event, and wrote down what to do about it. The trigger fires the agent, but the judgement inside it is yours, frozen at setup time. An automation catches exactly what you anticipated, and nothing else.

You are the scheduler

Strip away the tooling and the division of labour hasn’t moved in three years. The agent does the work. Deciding what the work is remains your job.

You read the dashboards, you listen to the users, you figure out what matters, and you compress everything you’ve learned into a prompt, either live at the keyboard or ahead of time in a trigger. The agent executes brilliantly, but every piece of judgement in the system originates with you.

The next evolution: agents that find the work

I’m betting the next evolution is agents figuring out the job to be done. No prompt, no trigger to configure, no instructions written in advance. You connect your stack, and the agent finds the work by itself: it watches the same signals you watch, notices what’s off, decides whether it matters, and starts working on it autonomously.

This is easy to say, and brutally hard to build, because proactivity is three problems stacked on top of each other, and skipping any one of them gives you something worse than the agent behind an input box.

Context. Obviously, the agent needs a live model of the world it operates in, not a snapshot you pasted into the context window at prompt time. A reactive agent with bad context gives you a bad answer. A proactive agent with bad context drops your prod database because it thought it was staging.

Judgement. This is what has been giving me the hardest time. At any given moment, thousands of things in a production system are slightly off. An agent that flags all of them is a noise machine, noise machines get muted, and muted agents are dead agents. The entire value of proactivity lives in the gap between “something changed” and “something matters”:

"signal": "memory up 3% on checkout-edge",<br>"verdict": "no anomaly",<br>"reasoning": "within the seasonal range for this hour on this worker"<br>},<br>"signal": "new error pattern, 2 minutes after deploy 9f3c2a1",<br>"verdict": "incident",<br>"reasoning": "error class never seen on this worker, tightly correlated with a deploy"<br>Action. Noticing without acting is just a smarter alert, and alerts are the thing I’m trying to kill. The agent has to finish the job, inside boundaries that make autonomy safe: reversible actions, receipts for everything, and a hard gate before anything irreversible happens.

None of these three involve the agent deciding what good looks like . It decides what’s...