Agentic AI

What is agentic AI?

Agentic AI is a property of how a system is built, not a product category. A system is agentic to the degree that a language model, rather than your code, decides what happens next: which tool to call, whether the result is good enough, and when the job is done.

That last bit does most of the work in the definition. An agentic system runs a loop and keeps going until it judges the goal reached or a limit stops it. Ordinary software runs the steps you wrote, in the order you wrote them, and then stops.

Anthropic's engineering team split the category in two, and LangChain and Microsoft have since described it the same way. Workflows are systems where models and tools are orchestrated through predefined code paths. Agents are systems where models dynamically direct their own processes and tool usage.

Almost everything currently sold as agentic AI is the first kind. That is good news, because the first kind is easier to test, easier to price, and easier to explain to an auditor.

Workflow or agent?

One question separates them: who decides what happens next, the developer or the model?

In a workflow you draw the graph yourself. Read the mailbox, have an LLM pull the supplier and amounts off the invoice, look the supplier up in the ERP, write a draft booking, wait for a human to approve it. The model does the reading and the judgement in one or two named steps. The order never changes, and when something goes wrong you know which box it went wrong in.

In an agent you hand over the goal and the toolbox and let the model plan. Same invoice, but now the agent decides whether it needs to check the ERP at all, whether to email the supplier about a mismatch, and whether to try again after a failed lookup. Two runs of the same input can take different paths.

Microsoft's Agent Framework documentation frames this as a dial rather than a switch, running from a single agent with tools where the model picks every step, through a workflow whose graph controls the process while agents handle the reasoning-heavy steps, to a pipeline with no model in it at all. Most production systems sit in the middle. The useful decision is not "agent or not", it is how much of the control flow you are willing to hand to a model, step by step.

The workflow patterns most projects need

Anthropic's write-up names five composable patterns. Four of them are workflows, and between them they cover the large majority of business cases people describe as agentic.

1. Prompt chaining
   Split the task into fixed steps and feed each output into the next call, with normal code checks in between. Extract fields, then validate them, then write the summary.

2. Routing
   Classify the input first, then send it down a specialised path with its own prompt. Incoming support mail becomes a refund case, a technical case, or a sales lead, each handled differently.

3. Parallelisation
   Run independent subtasks at the same time, or run the same task several times and combine the answers. Useful when you want a second opinion on a classification.

4. Orchestrator-workers
   A central model breaks the task into subtasks at runtime and hands them to worker calls. This is where the model starts deciding structure, so it is the first pattern that stops being fully predictable.

5. Evaluator-optimiser
   One call produces a draft, a second call criticises it, and the loop repeats until the critic is satisfied. Worth it when you have a clear quality bar and revision genuinely improves the output.

Only the last item in Anthropic's list, the autonomous agent, gives the model the wheel. Everything above it is a workflow engine with model calls inside, and much of it is buildable in the automation tooling a company already owns.

When autonomy earns its cost

Anthropic's guidance is blunt about the price: agentic systems trade latency and cost for task performance, so decide when that trade makes sense. Every extra loop is another model call, another few seconds, and another chance to go off course.

Microsoft's Durable Task documentation gives a workable split. Use a deterministic workflow when the sequence of steps is known ahead of time, when you need explicit guardrails on behaviour, or when compliance and auditability require reviewable control flow. Use an agent loop when the task is open ended and the steps cannot be predicted, when you want the model to choose the tools, or when the approach has to adapt based on intermediate results.

OpenAI's guide to building agents makes the same point with a fraud example. A rules engine works like a checklist and flags transactions against preset criteria. An agent behaves more like an investigator, weighing context and spotting a suspicious pattern that breaks no explicit rule. If your problem genuinely looks like the investigator, autonomy pays. If it looks like the checklist, a checklist is cheaper, faster and defensible.

A practical test we use before quoting this kind of work: can you write down the steps? If you can list them on a whiteboard and they hold for nine cases out of ten, build the workflow and let a human handle the tenth. If nobody in the room can agree on the steps because they depend on what you find halfway through, that is where an AI agent starts to pay for itself.

What to watch out for with agentic AI

The label hides the architecture. Vendors apply "agentic" to anything containing a model. Ask which decisions the model makes at runtime. If the answer is none, you are buying a workflow, which may be exactly right, but should be priced as one.

Cost scales with the loop, not the task. A workflow with three model calls has a predictable bill. An agent that decides how many calls to make does not, until you cap iterations and spend.

Autonomy and auditability pull against each other. A dynamic path is harder to reproduce, and "the model chose differently that day" is a poor answer during an audit. Where an approval, a payment or a customer mail is involved, put a human-in-the-loop gate at the point of action rather than trusting the loop to stop itself.

More tools means more exposure. Each tool an agent can reach widens what a prompt injection in an incoming mail or document could trigger. The detailed failure modes, from runaway loops to wrong tool selection, are covered in the AI agent entry.