Here is the thing that nobody says plainly: the most significant shift in AI tooling right now has nothing to do with which model is smarter. It is about who blinks first. For the past two years, the mental model has been consistent — you open a chat window, you type something, the agent responds. You are the one who initiates. The agent waits. That is so deeply baked into how we think about these tools that most people haven’t noticed it quietly becoming obsolete.
The new model flips the relationship. Agents no longer wait to be summoned. They watch for things to happen — a pull request opened, an alert fired, a ticket created — and they move without being asked. This sounds like a small implementation detail. It is not. It is a different category of software.
The practical implications are already visible in how engineering teams are starting to wire up their workflows. Instead of an engineer manually requesting a security review before merging, an agent triggers the moment a pull request lands: scanning the diff, cross-referencing known vulnerability patterns, posting a structured summary before the first human reviewer has even loaded the page. Instead of an on-call engineer piecing together context at 2am when an incident fires, an agent is already three steps in — correlating recent deploys, checking error rates, drafting a first-pass incident summary — by the time the human picks up their phone. The agent isn’t responding to the engineer. It is responding to the event.
What’s being built, in aggregate, is a continuous loop rather than a conversation. The old paradigm was episodic: you had a session, you got output, the session ended. The new paradigm is persistent: the agent is always embedded in your toolchain, always listening to the state of your systems, always ready to act on a change signal. Some teams are already running weekly cross-tool digests this way — no one prompts the summary, it simply assembles itself from the week’s activity across repositories, project trackers, and communication threads, arriving on Monday morning as if it had always existed.
This is genuinely exciting, and I want to sit with that for a moment before introducing the complication, because the excitement is earned. The dream of software that handles ambient coordination — the work that exists between explicit tasks, the glue work, the monitoring work, the synthesising work — is real and the distance to it has shortened considerably.
But there is a catch, and it is a serious one. A practitioner whose opinion I respect put it well: the secret nobody tells you about always-on agents is how much they fail behind the scenes. And a silent failure from an always-on agent is categorically worse than a failure from one you summoned. When you invoke an agent and it gives you a bad result, you notice — you were expecting output, you evaluate it, you catch the error. When an always-on agent silently drops a security review, or quietly produces a malformed incident summary, or stops triggering without surfacing a clear error, the failure is invisible. You carry on depending on coverage that no longer exists. The loss of the failure signal is the worst part of the failure.
This is the design challenge that the event-loop paradigm inherits and has not yet solved. The chat paradigm had a natural forcing function for reliability: the human in the loop, waiting for a response, capable of evaluating what arrived. The event-loop paradigm removes that forcing function by design. For it to work safely, the observability has to be engineered back in deliberately — explicit failure states, audit trails, dead-man’s-switch alerts when an agent goes quiet unexpectedly. Otherwise you have not automated the work; you have automated the illusion that the work is being done.
The shift from chatbots to event loops is real and it matters. But the teams who will benefit from it are the ones who treat always-on agents not as a reliability upgrade, but as a new class of infrastructure — one that demands the same discipline around monitoring and failure handling as any other system running in the dark.