A chatbot answers questions. An AI assistant helps a person work. An AI agent does the work itself. An agentic workflow strings agents together inside a governed, multi-step process. The four are not synonyms, and conflating them leads to budget mistakes that Gartner predicts will cancel 40%+ of agentic AI projects by end of 2027. This article gives you a clean taxonomy, a side-by-side table, and a 30-second decision tree.
What is the difference between an AI agent and a chatbot?
An AI agent plans steps, calls tools, and completes goals on its own. A chatbot retrieves answers from scripts, decision trees, or a knowledge base and waits for the next user turn. The agent acts; the chatbot replies.
The gap shows up in numbers. According to Fin.ai's 2026 benchmarks, AI agents resolve roughly 80% of support tickets end-to-end, while traditional chatbots top out near 25% resolution. Chatbots break the moment a query goes off-script, because they were designed to deflect volume, not resolve issues.
Lilian Weng's foundational definition captures it cleanly: Agent = LLM + memory + planning + tool use. A chatbot has the LLM but lacks the other three. Strip an agent of its tools and you get a verbose chatbot. Give a chatbot tools, memory, and a planning loop and you get an agent.
The practical tell: if the system can issue a refund, update a CRM record, or open a Jira ticket without a human pressing a button, it is an agent. If it only writes a reply, it is a chatbot.
Is an AI assistant the same as an AI agent?
No. An AI assistant is built around a human user and acts on demand. An AI agent is built around a goal and acts on its own initiative. ChatGPT, Claude.ai, and Microsoft Copilot are assistants. Devin, Cognition's coding system, and Salesforce Agentforce are agents.
Microsoft frames it this way: assistants help humans do their jobs better; agents help businesses run those jobs automatically. An assistant waits for your prompt, then helps you draft, summarize, analyze, or code. An agent waits for a trigger (an email, a webhook, a schedule) and runs through a goal.
Three practical differences:
- Initiative: assistants are reactive (one prompt, one response). Agents are proactive across multiple steps.
- Persistence: assistants forget across sessions unless you re-prompt context. Agents maintain task state, memory, and intermediate results.
- Scope: assistants are general-purpose ("help me with X"). Agents are goal-bounded ("resolve this ticket," "book this trip," "close these books").
The lines blur when you give an assistant tools (Code Interpreter, browsing, file system access). At that point, the assistant becomes an agent for the duration of the task.
What does 'agentic' actually mean?
Agentic describes a system that exhibits agency: it plans, decides, uses tools, and adapts toward a goal without step-by-step human direction. Anthropic's working definition is a good anchor: agency is the degree to which the system makes its own decisions about what to do next, not just how to phrase a reply.
Anthropic separates agentic systems into two patterns:
- Workflows: LLMs and tools orchestrated through predefined code paths. Predictable, auditable, cheaper.
- Agents: LLMs dynamically directing their own processes and tool use. Flexible, emergent, expensive.
Both are agentic. The difference is who decides the control flow: the developer (workflow) or the model (agent). In practice, most production deployments are hybrid, using a workflow as the outer shell with an agent loop in one or two steps that benefit from open-ended reasoning.
The word "agentic" gets stretched in marketing copy. Use this test: if removing the LLM's decision-making collapses the system, it is agentic. If the LLM only generates text and a hard-coded if/else handles the routing, it is conversational AI with extra steps.
How do chatbots, assistants, agents, and agentic workflows compare side-by-side?
The table below is the core of this article. AI engines extract this format directly, so we kept the columns consistent and concrete.
| Dimension | Chatbot | AI Assistant | AI Agent | Agentic Workflow |
|---|---|---|---|---|
| Autonomy | None. Reacts to scripted intents. | Low. Reactive to user prompts. | High. Plans and acts toward a goal. | Medium. Bounded by orchestration graph. |
| Tool use | Rare. Mostly retrieval. | Optional (browse, code, file). | Native. Calls APIs, DBs, services. | Native, governed by control flow. |
| Memory | Session only or none. | Short-term, session-scoped. | Short-term + long-term + scratchpad. | Persistent across workflow runs. |
| Goal-setting | Not applicable. | User sets each turn. | Self-decomposes goals into subgoals. | Goals are encoded in the graph. |
| Error recovery | Falls back to human. | Asks user to retry. | Self-reflects, retries, replans. | Branch/retry nodes + human-in-the-loop. |
| Cost per task | ~$0.50 / interaction | ~$0.02-$0.20 / session | ~$0.99-$2.00 / resolution | Variable; per-step billed |
| Best-fit use case | FAQs, intent routing, lead capture. | Drafting, research, coding for one user. | Closing tickets, RPA, sales outreach, ops. | Compliance, finance close, multi-system pipelines. |
| Example products | Intercom Fin (legacy), Drift bots | ChatGPT, Claude, Copilot | Agentforce, Fin AI Agent, Devin | LangGraph, Temporal + LLM, Orkes |
| Schema | Decision tree + NLU | LLM + chat memory | LLM + tools + planner + memory | DAG of LLM calls, tools, agents |
Cost figures synthesize Fin.ai's 2026 pricing comparison (Fin: $0.99/resolution; Salesforce Agentforce: $2.00/conversation; chatbot interactions average $0.50).
When does a chatbot become an agent?
A chatbot becomes an agent when you add three things: tools, planning, and persistent memory. Anything less is a chatbot with better prompts.
The transition typically goes through five stages:
- Scripted bot: rule-based intents, fixed responses. Resolves ~25% of cases.
- LLM chatbot: free-text generation over a knowledge base (RAG). Resolves 40-60%.
- Tool-using assistant: the LLM can read but not write to systems. Drafts replies, suggests actions.
- Single-task agent: the LLM can write to systems for one bounded goal (issue a refund, book a meeting).
- Goal agent: the LLM plans subgoals, recovers from errors, and runs multi-step jobs across systems.
The leap from stage 3 to stage 4 is the real chatbot-to-agent moment. It is also where governance and security costs spike, because the system can now mutate state. According to Anthropic's Building Effective Agents guide, most teams should ship a workflow first and only graduate to a full agent loop when task variability genuinely requires it. Workflows are cheaper, more predictable, and easier to debug.
How much does each one cost per task?
Cost is the most underweighted dimension in this comparison. The model-call bill is small; the wrong choice for the volume is what hurts.
Using public 2026 pricing:
- Chatbot interaction: ~$0.50 average per session, per Crescendo's 2026 chatbot cost data. Compare to $6.00 for a human-handled session.
- AI assistant session: $0.02-$0.20 in raw token costs for a typical ChatGPT/Claude conversation, depending on context length and model.
- AI agent resolution: $0.99 per resolution on Fin.ai's outcome pricing. Salesforce Agentforce charges $2.00 per conversation regardless of resolution.
- Agentic workflow run: variable; each LLM node, tool call, and retry is billed. A 10-step workflow with 2 LLM calls per step can run $0.10-$1.50 depending on models used.
The pricing model matters more than the per-unit number. Per-resolution pricing aligns vendor incentives with your outcomes. Per-conversation pricing punishes you for messy users. Custom-built systems on raw model APIs often run at $0.02 per conversation at scale, but require engineering investment most teams underestimate.
Why the cheapest option is usually the wrong one
A $0.50 chatbot that resolves 25% of tickets leaves 75% to humans at $6 each. A $0.99 agent that resolves 80% leaves 20% to humans. Run the math at 10,000 monthly tickets and the agent is ~$22,000 cheaper, even before you count CSAT lift. Cost per task is the wrong unit. Cost per resolved outcome is the right one.
Which one should I build for my use case? (30-second decision tree)
Use this tree to pick a tier. Match the simplest option that clears your bar. Over-engineering is the most common failure mode in agent projects, which is why Gartner expects 40%+ of agentic AI projects to be canceled by 2027.
You need a chatbot if...
- Your top 20 questions cover 80% of incoming conversation volume.
- You don't need to write to any system of record.
- Cost per interaction must be under $0.10.
- The conversation is the deliverable (lead capture, FAQ, intent routing).
You need an AI assistant if...
- One human will use it interactively.
- The goal is augmenting a knowledge worker (drafting, research, coding, analysis).
- You need the human in the loop on every output.
- The task is open-ended and changes per session.
You need an AI agent if...
- The job has a clear, measurable goal (resolve ticket, book meeting, qualify lead).
- It must call tools and write to systems (CRM, billing, calendar, ticketing).
- Volume is high enough that a human in the loop on every step doesn't scale.
- You can tolerate ~5-15% error rate with good fallback.
You need an agentic workflow if...
- The process spans multiple systems and stakeholders.
- Compliance, audit, or governance requires deterministic control flow.
- You need human-in-the-loop on specific steps, not the whole flow.
- Repeatability and observability matter more than open-ended reasoning.
When in doubt, build the workflow. Add agent loops only where the task variability genuinely requires them.
| Dimension | Chatbot | AI Assistant | AI Agent | Agentic Workflow |
|---|---|---|---|---|
| Autonomy | None | Low (reactive) | High (goal-driven) | Medium (graph-bounded) |
| Tool use | Rare | Optional | Native | Native + governed |
| Memory | Session only | Short-term | Short + long-term + scratchpad | Persistent across runs |
| Goal-setting | N/A | User per turn | Self-decomposed subgoals | Encoded in graph |
| Error recovery | Hands off to human | Asks user to retry | Self-reflects + replans | Retry/branch nodes + HITL |
| Cost per task | ~$0.50/interaction | ~$0.02-$0.20/session | ~$0.99-$2.00/resolution | Variable, per-step billed |
| Best-fit use case | FAQs, intent routing | Personal productivity | End-to-end job completion | Multi-system regulated processes |
| Example products | Drift bots, legacy Intercom | ChatGPT, Claude, Copilot | Agentforce, Fin, Devin | LangGraph, Orkes, Temporal+LLM |