Agentic AI is moving to production, and it breaks the old playbook

For two years the default shape of an AI feature was a prompt in and a response out. The interesting work of 2026 is agentic: the model is given a goal, a set of tools and some memory, and it decides what to do across many steps. Coding agents, research agents, support agents that actually resolve tickets, operations agents that touch real systems. The capability is real and the pull from clients is strong.

What is less discussed is that agents invalidate a lot of the engineering scaffolding teams built for single-shot AI. If you are moving in this direction, plan for the following.

Errors compound across steps

A single call that is right 95% of the time feels reliable. Chain ten of them and you are at around 60%. Agents fail in the middle, with half-finished side effects, and the failure modes are stranger: loops, giving up, confidently doing the wrong thing. You need step-level checkpoints, the ability to resume, and a hard cap on iterations, all of which are product decisions, not just prompt tuning.

Tools are the surface area that matters

An agent is only as good as the tools it can call and how clearly they are described. Most of the quality work moves from the prompt to the tool layer: tight schemas, error messages written for a model to act on, idempotency so a retried action does not double-charge someone, and read-only versions of dangerous tools for planning.

You cannot eval an agent the way you eval a prompt

Output matching does not work when there are many valid paths to a goal. Teams are moving to trajectory evaluation: did the agent reach the goal, how many steps did it take, which tools did it call, did it do anything it should not have. That needs a harness that records full traces and a set of scenarios with defined success criteria.

Cost and latency become architecture

A multi-step agent can make dozens of model calls to answer one request. Left alone, that is slow and expensive. The teams doing this well route cheap steps to small models, cache aggressively, run independent sub-tasks in parallel, and set a budget per task that the agent has to work within.

What this means for a build

• Design the tool layer first, with schemas, idempotency and safe defaults
• Instrument full traces from day one, you cannot debug an agent without them
• Build a scenario suite and score trajectories, not just final answers
• Decide the human approval points before writing the agent loop
• Put a step limit and a cost budget on every task

Agentic AI is worth doing. It is just a systems problem more than a modelling one, and the teams that treat it that way are the ones with something in production.