Agentic AI is what you get when you put a language model inside a loop. The model is still doing the same thing it always did (predicting text), but now that text can be a decision: call this tool, search for that, write to this file, ask the user. The output feeds back in as new context, the model looks at what happened, and it goes around again. Plan, act, observe, revise. That loop is the entire difference between a chatbot and an agent.
Concretely, an agentic system needs four things the model doesn't have on its own. Tools, so it can affect something outside the conversation. Memory, so step 40 knows what happened at step 3. A control loop, so something decides whether to continue or stop. And a goal, so there's a definition of done. Strip any one of those out and you have a fancier prompt, not an agent. The most common thing sold as "agentic" is a single model call with function calling attached, which is one step of the loop rather than the loop itself.
The reason this is hard has almost nothing to do with the model and almost everything to do with state. A long-running agent accumulates history fast: tool outputs, intermediate reasoning, failed attempts, retrieved documents. Dump all of it into every request and you hit the context window and pay for it repeatedly. Trim it naively and the agent forgets a constraint it was given twenty steps ago and cheerfully violates it. Most agent failures we see in production are not reasoning failures, they're context failures. The model would have made the right call if the right information had been in front of it.
Autonomy is a dial, not a switch, and the interesting engineering is in where you set it. A fully autonomous agent takes multiple consequential actions without human approval, which is exactly what makes it valuable and exactly what makes it a governance problem. Most teams that ship successfully run somewhere in the middle: the agent proposes, executes the reversible steps freely, and stops for approval on the irreversible ones. Deleting records, sending external email, moving money, and pushing to production are the usual checkpoints.
Evaluation is the other thing that separates demos from deployments. A generative model is easy to eval: one input, one output, judge it. An agent has a trajectory. It can reach the right answer by a lucky route, or fail on step 6 of 20 in a way that only shows up as a subtly wrong final number. You need to eval the path, not just the destination, which means logging every tool call and decision, and being able to replay them. Teams that skip this can't tell you why last Tuesday's run was wrong, and can't tell whether their prompt change made things better or worse.
The honest state of the field is that agentic AI works well when the task has a verifiable outcome and a bounded action space. Code that compiles and passes tests. A ticket that either got routed correctly or didn't. A dataset that either reconciles or doesn't. It works much less well on open-ended judgment work where nothing checks the answer, because the loop has no signal to correct against and errors compound silently across steps.
Why It Matters
Agentic AI is where the ROI arguments and the risk arguments both live. An agent that completes a multi-step workflow replaces process, not just typing, which is why the business case is much larger than for generative tools. It's also why the failure surface is larger: an agent acts before anyone reviews, so mistakes land in real systems. The organizations getting value from agents are the ones that invested in the unglamorous layer underneath (memory, permissions, audit trails, evals) rather than the ones that bought the most impressive demo.
Example
A support team deploys an agent to handle refund requests. Generative version: it drafts a reply, an agent-less human sends it. Agentic version: it reads the ticket, looks up the order in the commerce system, checks the refund policy against the purchase date, verifies the customer isn't flagged for abuse, issues refunds under $50 automatically, escalates anything above that with a written recommendation, and logs every step. It handles 70% of tickets end to end. It also needs the order-system credentials, an audit log, a hard cap on refund value, and a weekly eval run against known-tricky cases, none of which the generative version required.