Everyone is developing and running agents. The pitch decks have converged on the same verb: the software will now act, not just answer, and it will act on your behalf, inside your systems, at a speed no team could match. I have spent my career building and operating inside large corporates, and I think most of what is being shipped under that banner is the most expensive way an organisation has ever found to stand still.
The visible layer of AI theatre, two years of it now, is old news and mostly harmless: the chatbot bolted to the homepage, the Copilot licence nobody opens, the pilot that shone in the demo and died the first time a real workflow touched it. Everyone already knows that layer is set dressing.
The layer worth arguing about is the one that looks like the opposite of theatre. It is the claim that the machine itself is now inventing: that because a model produced something surprising, something genuinely new has entered the world, and that pointing an agent at a problem is the same as solving it in a way it has never been solved before. Most of the time it is not. The demo that dazzles is the survivor of a hundred prompts that produced nothing, and we never see the hundred; a striking output is a draw from a distribution whose shape is hidden, and the human watching supplies the story of genius afterward. What you are looking at is optimisation wearing the costume of a breakthrough, and an agent is optimisation given hands.
Refinement is not invention
AI does not invent so much as refine, extraordinarily well, and refinement is search. The model finds the best answer inside a defined space: protein structures, candidate materials, vulnerabilities in a codebase, patterns no human team could pull out of the noise in a working lifetime. I use these capabilities every day and they compound. But the space itself, the assumptions, the frame, the question worth asking, came from somewhere else, usually from a human who is no longer in the loop by the time the agent runs.
Finding what is already there is not the same as creating what does not yet exist. Real innovation means abandoning something that works in pursuit of something that might work better, and that is the one move optimisation structurally cannot make, because from inside the objective function abandonment scores as error. Every step away from the current optimum looks worse before it looks better. A system built to climb does not choose to step down.
Clayton Christensen wrote the organisational version of this in 1997, and it remains the most useful thing anyone has said about why good companies die. The firms that fell to disruptive innovation in The Innovator’s Dilemma were not the badly run ones. They failed because they were well run: they listened to their best customers, funded the improvements those customers asked for, and rationally passed on the cheaper, worse-on-paper technologies that did not yet serve anyone worth serving. Good management, by every metric the business already tracked, was the thing that killed them. The disruption looked like error from inside the numbers, right until it was the market.
An agent is a pure sustaining-innovation engine. It lets a company climb its current curve, refine its current product for its current customers, faster and more cheaply than any team in history. That is not an escape from Christensen’s trap. It is the trap with the last friction taken out. Climbing the familiar curve always felt like progress until the moment the curve fell away, and the only defence was the occasional expensive pause where someone looked up and asked whether the curve was still the right one. Make the climbing free and you make that pause more costly by comparison, and fewer companies will ever take it.
If the frame is wrong, an agent is a quicker and more confident way to arrive at the wrong place, and it will keep arriving there, on schedule, until a human decides the frame was the problem.
Convergence is the tell
You can watch it happen in the output. The price of a token has collapsed, so everyone generates everything, and the floor floods with slop. Underneath the volume the work is converging: everything reads the same, and the surprises stop surprising. Strip the interface away and a model is a lossy, probabilistic index over the public commons it was trained on. When it writes code it recombines the open source it ingested, the libraries and patterns and public answers that taught it what working code looks like, and it does not reach outside that distribution, because for the model there is nothing outside it to reach.
Meanwhile the well it draws from is running dry. It was dug by people publishing and answering in the open, and the agent now writes the code those people used to write, while the contribution that once flowed back upstream collapses into private windows that train the next model and give nothing back. The model is consuming its own supply, converging on a mean it can no longer escape.
Photography is the precedent worth sitting with. When the camera arrived, painting did not die. It was forced to work out what human seeing was actually for, and whole movements came out of the reckoning. The same reckoning is on offer now, but only if we are honest about the division of labour. The machine searches the space. A human decides when the space itself is wrong. Collapse those two jobs into one and you get fluent, confident, converging mediocrity at industrial scale.
The direction of travel settles it. Open model weights are proliferating fast: OpenAI and Google publish them, and the Chinese labs are the real engine, turning out capable open weights on monthly release cycles. Almost every company is layering its own agent toolset on top, most of it open source too. The model and the scaffolding are both becoming things anyone can download, run, and wire together, which makes convergence the destination rather than a phase: every vendor’s toolset a different wrapper over the same weights, everyone building the same agent from the same commons. Nothing at the model layer locks anyone in any more, frontier models included: developers already route across them by default.
The cost of changing your mind
Here is the part that gets missed, and you only see it from where the system actually runs. Hype needs scarcity, and the scarcity is gone: when the model is a download, the scaffolding is open source, and the output converges on the same mean, the magic drains out of the pitch and what remains is procurement and architecture. That moment, the hype dying into the ordinary, is precisely when ownership starts to matter, and almost nobody priced in the option to abandon.
Abandonment has a bill attached. You can only walk away from something that works if walking away is affordable, and the affordability is set a layer down, in infrastructure nobody thinks of as a decision at all.
Taleb’s Antifragile is the frame that makes sense of the whole trade. Some positions are harmed by volatility, some are indifferent to it, and a rare few gain from it. A team that rents its whole stack is fragile to every model release, every price change, every vendor decision, because each one is a shock it can only absorb, and each one it has to ask permission to answer: from a vendor, from a contract cycle, from a compliance gap that was always someone else’s roadmap item.
A team that owns its serving stack, its data, its audit trail, and its routing layer is the opposite. It can switch models the week a better one ships, exit a vendor when the pricing turns, and carry a working system into a regulated market when the window finally opens: every model release a chance to trade up, every price move a chance to re-route, every shock an option it can exercise rather than a cost it has to eat. Resilience merely survives the disorder; this is the antifragile position, the one that compounds because of it. The option to abandon is a convex payoff, cheap to hold and worth more with exactly the volatility that is punishing everyone who did not buy it.
The lesson is older than the agent era. I learned it building data platforms on regulated data and running large-scale delivery infrastructure, with no AI anywhere near either. The point was never the cleverness of any one design. The point was that owning the layer that mattered gave the work the option to move: to bring new inputs in, to change how the system ran, to act on a decision the moment it was made instead of when a contract permitted. That ownership was what let each team change approach the day something better existed, because nothing that mattered sat behind another company’s change window.
Getting into serious AI has never been cheaper, but running it at scale is a bill that arrives every month, and neither number is what separates the organisations that will invent with this technology from the ones that will only ever refine with it. The barrier is who owns the layer that lets them move without asking, and in the agent era that layer is finally concrete enough to name: the harness. Not the agent, which is disposable, and not the model, which is swappable, but the instrumented environment they both run inside, the part that does not change when they do.
You protect, with guardrails and abuse controls that keep an agent inside its lane. You isolate, with containment so a tool call cannot reach further than you allowed. You observe, with the tracing, cost attribution, and audit trail that let you prove what an agent did and change it when it is wrong. All three controls live in the harness and none of them in the agent, and that is what makes the agent disposable: own those three and every model underneath becomes swappable, and shrinkable to the point where its precision barely matters.
The serving bill is where quantisation earns its place. It takes a model from sixteen bits a weight down to four, and lower again, each step a controlled lobotomy that trades fidelity for a smaller bill, until the model is cheap enough to run at scale on hardware you own. How far down you can push it is fixed not by what is safe in the abstract but by whether you can catch the model when it is wrong, because the reliability has left the weights and moved into the loop that verifies the output and runs the model again when it fails. Intelligence needs structure before it is productive, and the loop is that structure: it lives in the harness you own, not in the model it corrects.
You can quantise past the point anyone without that loop would dare, and shrink the model to almost nothing, precisely because the layer that checks it is yours.
Rent those layers and you have handed the decision to change your mind to whoever holds the contract, and an enterprise rarely hands it over just once. The platforms arrive through the enterprise sales motion, sold silo by silo: one agent suite into the contact centre, another into engineering, another into finance, each with its own contract and its own renewal date, until the option to abandon is fragmented across agreements nobody reads together. One harness under all of them breaks the silos, and breaking the silos is what stops the lock-in reassembling a layer up.
The organisations that spent on that layer did not buy defence. They bought the option to abandon, the one antifragile asset in this market: it appreciates as the pace increases.
The question underneath the agent
So are agents worth building? That is the wrong end of the question. If everyone can build the same agent, and they can, because it is the same commons recombined into the same shape, then the agent is the disposable layer, not the thing worth owning. Build them, and build them to be thrown away.
Use them for what they are genuinely extraordinary at: complexity, scale, speed, and search inside a frame you trust. Keep humans on the one job the machine structurally cannot do, which is deciding the frame is wrong and that something which currently works must be abandoned. And put your commitment where it compounds, in the harness underneath that lets you throw the agent away without asking, because in a field moving this fast the option to abandon is worth more than any agent you could build on top of it.
Everyone is developing and running agents. Almost nobody is asking the question that decides whether any of it compounds.
It is not whether you can adopt AI. It is whether you can still abandon anything.