Every year gets declared the year of something. 2025 got declared the year of agentic AI, and unlike most of these declarations there is a real technical shift underneath it — just not the one the announcements describe.
The shift is that language models acquired two capabilities that compose: they got better at extended reasoning, and they got reliable at calling external tools. Either alone is incremental. Together they turn a system that produces text into a system that produces effects, and effects are a fundamentally different risk category.
The Ceiling of Chat
Ask a chat model to plan a product launch and you get a good plan. Then it stops. It does not send the brief, book the room, set up the tracking, or notice three weeks later that nobody did the second step. The intelligence is real and the leverage is limited, because a human still has to carry every output across to the system where it does something.
For a lot of knowledge work, drafting was never the bottleneck. Coordination was.
What an Agent Adds
An agent is a model wrapped in a loop. It has a goal, a set of tools it can call, some memory of what it has already done, and permission to decide what to do next based on what came back. It runs until it thinks it is finished or something stops it.
That loop is the entire difference. A chat model maps one input to one output. An agent observes, decides, acts, observes the result of its own action, and decides again. The structure is closer to control theory than to text generation, and the failure modes come from control theory too.
Why It Became Plausible in 2025
Two ingredients arrived close together.
The first is reasoning models that spend inference-time compute on a problem before answering. OpenAI's o1 series was the visible start of this, and every major lab now ships something comparable. Working through a problem in steps before committing to an answer helps most on exactly the kind of multi-stage planning an agent has to do continuously.
The second is that tool calling became dependable. Getting a model to emit a correctly structured function call, with the right arguments, and then interpret the response sensibly, used to be a per-integration engineering project full of parsing hacks. It is now a well-supported primitive with standardised protocols for exposing tools. Unglamorous, and probably more important than the reasoning improvements, because it is what makes the loop close reliably.
Where Agents Actually Work Today
Software engineering is the leading case, and the reason is instructive: the environment gives free, fast, honest feedback. A coding agent can run the test suite. It does not have to guess whether its change worked; it can find out, and it can iterate on being wrong without a human in the loop.
In practice this looks like assigning a well-scoped, well-tested task — a bug with a clear reproduction, a mechanical refactor, a migration across many files — and getting back a pull request. I have had genuinely good results with this and genuinely bad ones, and the difference correlates almost entirely with how good the existing test coverage is. On a well-tested codebase the agent's mistakes get caught and corrected in the loop. On a poorly tested one, it confidently produces code that looks right and is not, and now a human has to review a large diff written by something that does not understand the system.
The other category that works is bounded, read-mostly research: gather information from several sources, cross-reference, produce a structured summary. The tasks are multi-step but the actions are reversible and the failure mode is a bad report rather than a bad outcome.
Where They Do Not
Agents fail badly on long horizons, and the arithmetic explains why. If each step in a plan succeeds with 95 percent reliability, a twenty-step task completes cleanly about a third of the time. Errors do not just accumulate, they compound — a wrong observation at step four poisons every decision after it, and the agent has no external reference telling it something went off the rails. It keeps going, confidently, in the wrong direction.
This is why the demos that impress and the deployments that hold up look so different. Demos are chosen tasks in controlled environments. Real work has ambiguous requirements, undocumented systems, edge cases nobody wrote down and side effects that are not visible from inside the loop.
The second failure class is the one that should worry you more. When a chat model hallucinates, you read something wrong. When an agent acts on a hallucination, it sends the email, drops the table, files the ticket, issues the refund. The output was always unreliable; what changed is that it is now attached to hands. Most of the engineering effort in production agent systems is not on making the model smarter — it is on scoping permissions, requiring confirmation for irreversible actions, sandboxing, logging every action, and making rollback possible.
The Design Questions That Matter
Anyone actually building this ends up confronting the same small set of problems.
Which actions require human approval? Approving everything gives you a slower chatbot. Approving nothing is untenable for anything with real consequences. The useful line is reversibility: let the agent act freely where mistakes are cheap to undo, and gate everything that touches money, external communication, or production data.
How does it fail? An agent that stops and says it is stuck is vastly better than one that improvises. Models are not naturally good at this — the training objective rewards producing an answer — so it has to be built in deliberately, and it is the single biggest determinant of whether a deployed agent is trustworthy.
How do you evaluate it? Benchmark scores on agent tasks are even less informative than benchmark scores on chat tasks, because the environment is half the problem. You need your own task set drawn from your own work, and you need to run it repeatedly, because agent behaviour is stochastic in a way that single-shot evaluation hides.
Who is accountable? If an agent with your credentials takes a costly action, that is your action. This is a legal and organisational question ahead of a technical one, and it is currently being answered by nobody in particular.
What I Actually Expect
Agents will keep working best where the environment gives cheap, honest feedback and mistakes are reversible. That is a real and expanding category, and coding is only the first of them.
Where I would set expectations low is autonomous operation over long horizons in messy environments, which is what most of the marketing depicts. The compounding-error problem is structural, not a matter of one more model generation, and the fixes — better verification, tighter scoping, checkpoints where a human confirms the state — all involve putting humans back into the loop at intervals.
The honest framing is delegation, with all the management overhead the word implies. You scope the task, you define what done means, you check the work. Done well that is a genuine multiplier. Described as autonomy, it will disappoint everyone who believed the pitch.
Tags
Taresh Sharan