Originally published at heycc.cn. This is a mirrored copy — the canonical version is kept up to date at the source.

What Are AI Agents in 2026? Agent vs Chatbot vs Workflow, Explained for Developers

By 2026 the word "agent" has been stretched until it means almost nothing. A landing page calls its FAQ bot an agent. A vendor rebrands a fixed RPA script as "agentic." Gartner has a name for this — agent washing — and estimates that of the thousands of vendors marketing agentic AI, only about 130 are building anything that genuinely qualifies. So if you are a developer trying to decide what to build, the marketing definition is useless. You need a precise one, and you need to know exactly where the line sits between an agent, a plain chatbot, and a hardcoded workflow.

Say you are scoping a feature that "uses an agent to handle support tickets." Before you commit headcount to it, you need to know whether the thing you are describing is an agent at all, or a workflow that will be cheaper, faster, and more reliable without the autonomy. The line below is drawn from the published engineering definitions of Anthropic, OpenAI, and IBM, plus the research the patterns descend from — not from anyone's marketing.

The one-sentence definition

An AI agent is an LLM that decides its own next action in a loop — choosing which tools to call and when to stop — to accomplish a goal you did not script step by step.

No clause in that sentence is decorative. "Decides its own next action" rules out hardcoded pipelines. "In a loop" rules out single-shot question answering. "Choosing which tools to call" is the mechanism that lets it act on the world instead of just talking. "A goal you did not script step by step" is the dividing line from a workflow.

IBM frames it the same way: an AI agent is "a system that autonomously performs tasks by designing workflows with available tools," running a continuous loop in which it perceives its context, reasons about the goal, acts through a tool, and observes the result before looping again. A chatbot, by contrast, responds turn by turn without independently pursuing a multi-step goal. The chatbot waits for you; the agent keeps going until the goal is met or a stop condition fires.

The three shapes, side by side

Most people collapse a spectrum into one word. There are really three distinct shapes, and Anthropic groups the latter two under the umbrella term agentic systems:

• Chatbot — a single LLM call (often with retrieval) that answers and stops. No autonomous loop.
• Workflow — "systems where LLMs and tools are orchestrated through predefined code paths." You wrote the control flow; the model fills in steps.
• Agent — "systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks." The model decides the control flow at runtime.

Here is the same distinction as a table you can apply to any system someone calls an "agent":

Dimension	Chatbot	Workflow	Agent
Who decides the next step	The user, each turn	Your code, fixed in advance	The model, at runtime
Control flow	None — single response	Predefined code paths	Dynamic, model-directed
Tool use	Optional, usually none	Tools at fixed points	Model chooses tools and timing
Number of steps	One	Known and fixed	Unknown until it runs
Predictability	High	High	Lower (the point is flexibility)
Cost per task	Lowest	Low–medium	Highest (loops, retries, tokens)
Best for	FAQ, summarize, classify	Well-defined, repeatable pipelines	Open-ended problems, no fixed path
Main risk	Wrong answer	Brittle when inputs vary	Compounding errors, runaway cost

The practical test: if you can draw the flowchart in advance, it is a workflow. If the number and order of steps depend on what the model discovers along the way, only then do you have an agent. A long, clever prompt is still a chatbot. A fixed "read form → validate → create ticket" pipeline is a workflow no matter how good the model inside it is.

What turns an LLM into an agent

Two ingredients do the real work.

1. The augmented LLM. Anthropic calls this "the basic building block of agentic systems" — an LLM "enhanced with augmentations such as retrieval, tools, and memory." Modern models can "actively use these capabilities — generating their own search queries, selecting appropriate tools, and determining what information to retain." That is your model + tools + memory foundation. Without augmentation you have a text generator; with it you have something that can gather information and act.

2. Tool / function calling — the mechanism that lets it act. This is the single most misunderstood part of agents, so be precise about it. OpenAI describes function calling as the way a model can "interface with external systems and access data outside their training data." The flow is:

1. The model returns a structured JSON call with a function name and arguments.
2. Your application executes that function (hits the API, queries the DB, writes the file).
3. You feed the result back into the model.

Critically: the model does not execute anything itself. It only decides when and how to call. Your code is always the thing that touches the real world. That is good news for safety — every action passes through a layer you control, which is exactly where you put permission checks and human approval. The craft of making this loop reliable — good tool descriptions, strict schemas, error recovery — is its own discipline, covered in the companion guide on AI agent tool-calling patterns. If you are building this layer end to end, the AI support bot guide walks through wiring tools to a real product surface.

The loop: ReAct, the canonical agent pattern

The reason an agent feels different from a workflow is the loop, and the canonical version is ReAct (Yao et al., ICLR 2023). ReAct prompts the model to generate "both reasoning traces and task-specific actions in an interleaved manner." The reasoning traces help "induce, track, and update action plans"; the actions interface with external tools to gather new information, which feeds the next round of reasoning.

One iteration looks like this:

Thought:  I need the customer's order status before I can answer.
Action:   get_order(order_id="A-4471")
Observation: {"status": "shipped", "carrier": "DHL", "eta": "2026-07-02"}
Thought:  It shipped; I can now answer and offer tracking.
Action:   final_answer("Your order shipped via DHL, ETA July 2.")

The loop repeats — think, act, observe — until the model decides it is done. This interleaving is why ReAct beat imitation-learning and reinforcement-learning baselines on the ALFWorld and WebShop benchmarks by 34% and 10% absolute success rate respectively. It is also why agents are unpredictable: nobody wrote how many times that loop runs.

When you actually need one

Anthropic's central design guidance is the most important sentence in this entire space: "find the simplest solution possible, and only increase complexity when needed." Agentic systems "often trade latency and cost for better task performance," so you add complexity "only when it demonstrably improves outcomes."

Concretely:

• Workflows "offer predictability and consistency for well-defined tasks."
• Agents are "the better option when flexibility and model-driven decision-making are needed at scale" — they fit "open-ended problems where it's difficult or impossible to predict the required number of steps, and where you can't hardcode a fixed path."

Run your task through these questions before you reach for an agent:

Question about your task	If yes →	If no →
Can you list the exact steps in advance?	Workflow (or chatbot)	Possibly an agent
Does the step count vary with the input?	Lean toward agent	Workflow
Does it need to choose among many tools dynamically?	Agent	Workflow with fixed tool calls
Are mistakes cheap and reversible?	Agent is viable	Add human-in-the-loop or stay workflow
Does a simpler version already solve 80%?	Ship that first	Justify the extra cost

If you answered "list the steps in advance: yes," stop. Build the workflow. Most automation that gets pitched as agentic is a workflow wearing a costume — and the workflow is easier to test, cheaper to run, and far easier to debug.

The two reasons agents fail in production

If agents were strictly better, everyone would use them. They are not, and the reasons are concrete rather than vibes.

Reason 1: the reliability math compounds. This is arithmetic, not anecdote. A multi-step agent multiplies its per-step accuracy across every step:

Per-step accuracy	10 steps	20 steps
95%	~60% success	~36% success
90%	~35% success	~12% success

A three-agent chain where each link is 70% reliable succeeds end to end just ~34% of the time. The mitigations are unglamorous: keep chains short, verify between steps, put a human in the loop for risky actions, and cap per-session token and iteration budgets. Plug your own per-step accuracy and step count into the Agent Reliability Calculator to see where your specific agent lands on this curve — and work backward from a target success rate to the per-step reliability it actually demands.

Reason 2: the cost and coordination tax. Anthropic's own measurement is stark — "agents typically use about 4x more tokens than chat interactions, and multi-agent systems use about 15x more tokens than chats." Multi-agent is not free leverage either: "most coding tasks involve fewer truly parallelizable tasks than research, and LLM agents are not yet great at coordinating and delegating to other agents in real time."

When the work does parallelize, the upside is real: Anthropic's multi-agent research system (a Claude Opus 4 lead agent orchestrating Claude Sonnet 4 subagents) "outperformed single-agent Claude Opus 4 by 90.2%" on internal breadth-first research evaluations. Worth flagging plainly: the 4x, 15x, and 90.2% figures are Anthropic's own self-reported internal benchmark, run on their own evaluation set — there is no independently replicated version of this number to cross-check against, so treat it as a directional signal from the vendor best positioned to know, not a peer-reviewed result. That is a research task — many independent lookups that fan out cleanly. Most business tasks are tightly coupled, and there the 15x token bill buys you coordination overhead instead of speed.

Guardrails, because the autonomy cuts both ways

The same autonomy that makes an agent useful is what makes it dangerous. Anthropic is blunt: "the autonomous nature of agents means higher costs, and the potential for compounding errors." Their recommendation is "extensive testing in sandboxed environments, along with the appropriate guardrails," and it is "common to include stopping conditions (such as a maximum number of iterations) to maintain control."

Minimum guardrails for any agent that touches a real system:

• A hard iteration cap so the loop cannot run forever.
• A token/cost budget per session that aborts when exceeded.
• Human approval in front of irreversible actions (sending money, deleting data, emailing customers).
• Sandboxed execution for anything that runs code or hits production.
• Logging of every tool call so you can reconstruct what happened after a failure.

This is also Gartner's diagnosis of why "over 40% of agentic AI projects will be canceled by the end of 2027" — escalating costs, unclear business value, and inadequate risk controls. The projects that survive are the ones that picked the right shape and wrapped the autonomy in controls from day one. For the full four-layer version of this list — tiered permissions, sandboxing, human approval, and tamper-evident audit logs — see AI agent safety guardrails.

Where the line leaves you

An AI agent in 2026 is not "an AI that's really smart." It is a specific architecture: an LLM in a perceive-reason-act-observe loop, choosing tools through structured function calls, pursuing a goal whose steps were never scripted. A chatbot answers and stops. A workflow runs the path you drew. An agent draws its own path at runtime — and pays for that flexibility in cost, latency, and reliability risk.

The discipline that separates working systems from canceled ones is the one Anthropic states plainly: start with the simplest thing, and add agentic complexity only when it demonstrably earns its keep. For most problems, a chatbot or a workflow is the correct answer, and shipping it is not a compromise. Reach for an agent when — and only when — the problem is genuinely open-ended and you have the guardrails to keep its autonomy in check.

For a deeper, build-oriented split on the chatbot-vs-agent boundary, see the companion piece on building AI workflows with n8n, which shows what the workflow shape looks like in practice before you graduate to anything autonomous.

Where each claim comes from

Every quoted definition here is traceable to one of the sources listed below. The workflow/agent distinction, the augmented-LLM building block, the "simplest solution possible" line, and the stopping-condition advice all come from Anthropic's Building Effective Agents. The 4x and 15x token multipliers and the 90.2% multi-agent figure are from Anthropic's Multi-Agent Research System write-up. The three-step function-calling flow follows OpenAI's function-calling guide; the perceive-reason-act-observe framing follows IBM. Gartner supplies the 40%-cancellation forecast, the "agent washing" coinage, and the ~130-genuine-vendors count from its June 25, 2025 release — one caveat worth flagging, since that page returned a 403 to automated fetching, those three figures were taken from the release text and corroborating coverage rather than a live read. The ReAct success-rate gains (34% and 10% absolute) are from the ICLR 2023 paper. The compounding-reliability percentages are nothing more than per-step accuracy raised to the step count — arithmetic you can redo yourself, not a sourced claim.

Sources

• Anthropic — Building Effective Agents
• Anthropic — How We Built Our Multi-Agent Research System
• OpenAI — Function Calling Guide
• IBM — What Are AI Agents?
• Gartner — Over 40% of Agentic AI Projects Will Be Canceled by End of 2027
• Yao et al. — ReAct: Synergizing Reasoning and Acting in Language Models (ICLR 2023)
• The Math Behind Why Multi-Step AI Agents Fail in Production