A clear definition for engineers

What is agentic AI? (And how it differs from generative AI)

A precise definition

Agentic AI is a system that pursues a goal by taking actions — calling tools, observing the results, and deciding the next step — in a loop, rather than producing a single output from a prompt. The model isn't just generating text; it is steering a process. It chooses what to do next based on what it just saw, and it keeps going until a stop condition is met.

Generative AI produces content — text, code, an image — from a prompt in one shot. You ask, it answers, and the interaction ends. There is no observe-and-decide loop, no tool calls, no state that carries forward. A chat model summarizing a document or drafting an email is generative: a single transformation from input to output.

The same underlying model can power both. What makes a system agentic isn't a different model — it's the harness around the model that lets it act, see the consequences, and decide again. Anthropic's Building Effective Agents draws this line between fixed workflows, where the path is predefined in code, and agents, where the model directs its own steps. Agency is the degree to which the model, not your code, decides what happens next.

The agentic loop

Strip away the framing and an agent is a single loop. Each turn does the same four things:

1. Send context to the model. The goal, the conversation so far, the tools available, and the results of any actions taken on previous turns.
2. The model decides. Either it answers directly, or it requests a tool call — a search, a database read, a file write, an API call.
3. Run the tool. Your harness executes the requested action in the real world and captures the result.
4. Feed the result back. The tool output is appended to the context, and the loop repeats from step one.

The loop stops on a done-condition — the model signals the goal is met — or on a budget: a cap on turns, tool calls, tokens, or wall-clock time. The budget is not optional. Without an explicit stop, a loop that fails to converge will keep spending until something else kills it.

Agentic vs generative AI

The clearest way to see the difference is to put the two side by side across the dimensions that actually drive a design decision:

Examples

A few concrete shapes make the loop tangible:

• Coding agents. Given a goal like "fix this failing test," the agent reads files, edits code, runs the test suite, reads the output, and iterates until the suite passes — each tool result shaping the next edit.
• Research agents. Given a question, the agent issues searches, reads what it finds, decides which threads are worth pulling, runs follow-up searches, and synthesizes an answer once it has enough to be confident.
• Customer-support resolution agents. Given a ticket, the agent looks up the account, checks order status, applies a refund or schedules a callback, and confirms the outcome — taking real actions across systems rather than just suggesting a reply.

In each case the model isn't producing one answer; it is running a loop of decisions, with tool results steering where it goes next.

How much agency do you actually need

The instinct after reading the above is to make everything an agent. Resist it. Agency is a spectrum, and the cheapest, most reliable system is the one with the least autonomy the task can tolerate.

If the path is known in advance, a fixed workflow — prompt, then a defined sequence of steps in your code — is more predictable, faster, and cheaper than handing control to the model. Building Effective Agents makes this its central recommendation: reach for the simplest pattern that works, and only add the open-ended loop when the task genuinely requires the model to decide its own steps. Every increment of autonomy you grant is an increment of cost, latency, and failure surface you take on.

The risk to design around

The headline risk of agentic systems is excessive agency: too much power, too little oversight. An agent that can take real actions can take the wrong ones — delete the wrong record, send the wrong message, spend without limit. The answer isn't to avoid agency but to bound it: scope the tools to least privilege, put a human in the loop on irreversible actions, and give the loop explicit budgets and a kill switch. Decide how much autonomy the task needs, then constrain the system to exactly that.