Almost every agent in production today is a responder. You ask, it acts. The request is the trigger, the human is the clock, and the agent’s entire existence is bounded by the moment between your prompt and its answer. That is useful. It is also the floor of autonomy, not the ceiling.
The ceiling is initiative: an agent that decides whether to act when nobody asked. It wakes up, looks at the state of the world, and concludes that this particular situation warrants doing something, then does it. No prompt triggered it. The trigger was its own assessment that the moment had arrived. This is a categorically different thing from a more capable responder, and most teams that say they want “autonomous agents” have not actually reckoned with what they are asking for.
Responding versus initiating
A responder, however sophisticated, never has to answer the hardest question, which is “should anything happen right now at all?” A human already answered it by sending the request. All the responder decides is how to fulfill a request whose existence was justified by someone else.
An initiating agent owns that question itself. And it is genuinely hard, because the default correct answer is almost always “no, do nothing.” The world is full of states that look like they might warrant action and do not. An agent with initiative is mostly an agent practicing restraint. The failure mode of a responder is a bad response. The failure mode of an initiator is acting when it should have stayed quiet, which is far more corrosive to trust, because a system that does things you did not ask for and did not want feels less like a tool and more like a liability with a login.
Initiative is not the freedom to act. It is the judgment to decide that this specific moment justifies acting, when the honest default is to do nothing.
What actually wakes an agent up
An agent cannot “notice” anything if nothing pokes it. Initiative needs a substrate of triggers, and in practice there are two, working together.
Events. Something happened in the system. An invoice crossed into overdue. A public federal award record changed for a contract vehicle a client cares about. A payment failed. A lead replied. These are facts arriving on a bus, and an agent subscribed to them gets a chance to assess each one. The event is not a command. It is an invitation to consider whether action is warranted.
Schedules. Time itself is a trigger. Wake every morning and assess the AR aging report. Check weekly whether any tracked federal contract is approaching recompete. The clock pokes the agent and the agent decides if the current state of the world, at this moment, calls for anything.
The crucial design point is that the trigger is never the decision. A naive version wires the event straight to the action: invoice overdue, therefore send dunning email. That is not initiative, that is a cron job with extra steps, and it fires indiscriminately. Real initiative inserts an assessment between the trigger and the act:
def on_event(event, context, envelope):
assessment = agent.assess(event, context) # should we act at all?
if not assessment.warrants_action:
log("considered, declined", event, assessment.reason)
return # the common, correct case
plan = agent.plan(assessment, envelope)
if plan.within(envelope):
execute(plan)
else:
propose_to_human(plan)The assess step is the whole difference. An overdue invoice for a client who always pays on day 35 and is now on day 32 does not warrant a dunning email. An overdue invoice for a new client who has gone quiet does. Same event. Different assessment. Different action, or no action. The agent that can tell those apart has initiative. The one that emails both has a trigger and no judgment.
Initiative needs a tighter envelope, not a looser one
There is a tempting intuition that an agent trusted to act on its own should be granted broad authority. It is exactly backwards. The more an agent acts without a human prompt, the narrower its grant envelope should be, because there is no human in the moment of action to catch a mistake. The request, in a responder, is itself a tiny act of human oversight. Remove the request and you remove that oversight, so the boundary has to absorb the slack.
In practice my initiating agents live at the top of the autonomy ladder for deciding and near the bottom for acting. They are free to assess anything, constantly, with no permission needed, because assessment is read-only and reversible. But the actions they are permitted to take on their own initiative are restricted to a small set of low-magnitude, fully reversible moves. Anything consequential that an initiating agent wants to do gets proposed to a human, precisely because no human asked for it.
The GovCon intelligence engine I architected is the clearest example I have built. It watches public federal award and spending data continuously and decides, on its own, when something is worth surfacing: a competitor won an adjacent award, a vehicle a client depends on is approaching expiry, a new solicitation matches a client’s capability. That decision, to surface or not, is pure initiative, and it is high-autonomy. But the only action it takes is to raise the finding to a human. It does not file, bid, email, or commit anything. The initiative lives entirely in the noticing. The acting stays gated. That split is deliberate, and it is what makes an always-on agent safe to run in a context where a wrong autonomous action would be unacceptable.
The restraint problem is the hard engineering
The part nobody warns you about is that an initiating agent has to be tuned for silence. If the assessment threshold is too low, the agent becomes a nuisance, surfacing or acting on things that did not matter, and humans learn to ignore it. That is the same death as approval fatigue, arriving from the other direction: a system that cries wolf trains everyone to stop listening.
So I instrument the declines as heavily as the actions. Every time the agent considers acting and chooses not to, that gets logged with its reason. Reviewing the declines is how you tune the threshold. An agent that never declines is firing on everything and is about to become noise. An agent that declines on something it clearly should have flagged tells you the threshold is too high. The ratio of considered-to-acted is a health metric I track directly, and for a well-tuned initiating agent it is lopsided. It considers a hundred things and acts on two.
The quiet agent is the trustworthy one
The agents I trust with initiative are not the busy ones. They are the ones that are mostly silent, that wake up constantly and almost always conclude there is nothing to do, and that speak up rarely enough that when they do, I look. That quietness is not the absence of autonomy. It is the highest expression of it, because choosing not to act, correctly, thousands of times, is harder than acting.
The last rung of the autonomy ladder was never about doing more. It is about an agent that has earned the right to decide whether anything should happen at all, and uses that right by mostly deciding that nothing should. Build the assessment, tighten the envelope, log the silences, and you get a system that acts on its own and is still something you would leave running while you sleep.