The phrase "agentic AI" suggests a more advanced kind of model. It usually is not. An agent is typically the same model behind an ordinary chat window, placed inside a loop, handed some tools, and given permission to act without asking first. That sounds like a small change. It is the difference between software that writes you a draft and software that sends it.

What gets added to a generative model

As our companion piece on how generative AI works sets out, a plain model produces output once and stops. An agent adds three things.

A loop. Instead of one response, the system runs repeatedly: decide what to do, do it, look at the result, decide again. It continues until the goal is met, it gives up, or it exhausts a budget you set.

Tools. The model can call functions that do real things — search the web, read and write files, query a database, call an API, run code. This is what lets it affect anything outside its own text output.

Memory. Some state that survives beyond a single turn, so step seven knows what steps one to six established.

That is the architecture. There is no fourth secret ingredient.

The loop, concretely

goal: "find last quarter's refund total and email it to finance"

1  think   → I need the refund data. I have a database tool.
2  act     → query_database("SELECT SUM(amount) FROM refunds WHERE ...")
3  observe → 412,330
4  think   → I have the figure. Now I need to send it.
5  act     → send_email(to="finance@...", body="Q3 refunds: 412,330")
6  observe → sent
7  think   → goal met. stop.

Note step 3. The model did not know the refund total and did not guess it. It called something that knew, and read the answer back. That is the capability jump: the agent can obtain facts it does not have, and verify results instead of predicting them.

Note also step 5. Nobody approved that email.

Tool calling, which is simpler than it sounds

The model does not execute anything. It emits a structured request — effectively "call this function with these arguments" — and your code decides whether and how to run it, then feeds the result back.

That matters for two reasons. The model is never executing code directly, so the trust boundary sits in your code, where it belongs. And every tool you expose is a capability you have granted: a file-writing tool is permission to write files, including ones you did not intend.

Memory, and why it is harder than it looks

The obvious approach — keep the whole history in the context window — breaks down quickly. Long runs overflow the window, cost rises with every step, and models reason less reliably over very long contexts.

Real systems therefore summarise older steps, store facts externally and retrieve them on demand, or keep a scratchpad of decisions rather than full transcripts. Each approach loses something. Memory design is where a lot of the actual engineering in agent systems goes.

The arithmetic that explains most failures

This is the part worth internalising, because it predicts agent behaviour better than any benchmark.

Suppose each step succeeds 95% of the time — which would be excellent.

  • 5 steps: 0.955 ≈ 77%
  • 10 steps: ≈ 60%
  • 20 steps: ≈ 36%

A system that is right 95% of the time at each step fails most long tasks. And errors do not merely accumulate — an agent that misreads step three builds steps four through ten on top of that mistake, often confidently.

This is why serious deployments keep tasks short, checkpoint between stages, and put a human at the points that matter. Not because the models are bad, but because chained reliability is brutal.

Multi-agent systems

One response is to split work between several narrower agents — a planner, a coder, a reviewer — each with a focused context.

It genuinely helps on complex tasks, because a smaller context tends to produce more reliable reasoning, and a reviewing agent catches some of what a writing agent misses. It also adds coordination overhead and more failure points. It is not automatically better than one well-scoped agent, and "multi-agent" in marketing material is not evidence of anything.

Where this is already real

Coding is the furthest along, because the feedback loop is immediate — code either compiles and passes tests or it does not, which gives an agent something objective to observe. That is why autonomous coding agents work better than agents in domains where success is ambiguous.

The security side has moved just as fast, and less happily. Google's threat team reports agents running multiple stages of real attacks, and banks have rewritten their terms so that losses caused by third-party AI agents fall on the customer. When an industry that prices risk for a living declines to carry this one, that is information.

The honest summary

Agentic AI is not a smarter kind of intelligence. It is the same intelligence, given a loop and permission to act.

That makes it enormously more useful and changes the failure mode completely: a generative model that gets something wrong wastes your time, while an agent that gets something wrong has already done it. Which is exactly what the comparison piece is about.

Written by the WritePures newsroom. Spotted something that needs updating? Tell our editors.