orchestrator, shared memory, and goal decomposition, and that structure buys you range at the price of a whole new class of failures.
TL;DR
People use “AI agent” and “agentic AI” as if they meant the same thing. This review draws a line. An AI Agent is one LLM wrapped in a tool-calling loop that does a narrow, well-defined job (triage an inbox, answer a support ticket, book a meeting). Agentic AI is a system of several specialized agents that split a high-level goal into subtasks, talk to each other, share persistent memory, and are coordinated by an orchestrator (a planner or “meta-agent”). The paper lines both up against plain generative AI across a stack of comparison tables, maps typical applications to each, catalogs the failures each one suffers (hallucination and shallow planning for agents; error cascades, coordination breakdowns, and emergent instability for agentic systems), and lists ten mitigation patterns (RAG, tool calling, ReAct loops, memory, orchestration, self-critique, programmatic prompts, causal modeling, audit logging, governance). There are no experiments. Its value to a builder is the vocabulary and the checklist, not new evidence.
Problem & Motivation
After ChatGPT, everything with a loop got called an agent. Then multi-agent frameworks (AutoGen, CrewAI, MetaGPT, ChatDev, LangGraph) arrived and the word “agentic” got stretched over all of it. The cost of that blur is concrete:
- Over-engineering. You stand up five agents, an orchestrator, and a message bus for a job that one tool-calling agent would have done more cheaply and more reliably.
- Under-engineering. You push a long, multi-stage, interdependent job into a single agent loop, and it loses the plot after step six because nothing holds state or checks work.
- Wrong evaluation. You measure a multi-agent pipeline the way you would measure a single chatbot (accuracy, latency) and miss the failures that only show up at handoffs between agents.
The authors’ pitch: a clean taxonomy lets you match the architecture to the shape of the problem and pick the right metrics and safeguards.
What’s New (Core Contribution)
This is a survey/position paper, so the novelty is organizational, not algorithmic. Honest accounting:
- A three-tier (really four-tier) spectrum. Before: “agent” meant anything from a chatbot to a swarm. Now: Generative AI (prompt in, content out) → AI Agent (LLM + tools, one task) → Agentic AI (many agents + orchestration + shared memory, one goal). They also add an inferred fourth type, Generative Agent: a sub-agent that does one generative subtask inside a bigger workflow (for example the “title generator” inside a YouTube-to-blog pipeline). This is the most useful idea in the paper and it is mostly a naming convention, not a discovery.
- Side-by-side comparison along five dimensions (Tables V-IX): core function, architectural components, operational mechanism, scope/complexity, and interaction/autonomy. Before: scattered blog definitions. Now: one grid you can use as a design-review checklist.
- Paired failure catalogs. Five limitations for single agents, eight for agentic systems, with the key claim that multi-agent setups do not just inherit single-agent problems; they amplify them (one agent’s hallucination becomes the next agent’s trusted input).
- A ten-item mitigation map that says, for each pattern, what it does for a single agent and what it does differently for a team of agents.
What is not new: the components (ReAct, CoT, Tree of Thoughts, RAG, episodic/semantic memory, orchestrators) all predate the paper, and the challenge list overlaps heavily with existing multi-agent and LLM-safety surveys. The figures were generated with ChatGPT-4o (the authors say so), and they are illustrations, not measured results.
How It Works (Technically)

There is no algorithm to trace, so this section replaces mechanism with the taxonomy itself, then gives a mini “how it works” for the three techniques that do most of the work.
The taxonomy in one table
| Dimension | Generative AI | AI Agent | Agentic AI | Generative Agent (inferred) |
|---|---|---|---|---|
| Trigger | User prompt | Prompt or goal, with tool use | Goal or orchestrated task | System or parent agent |
| Flow | Prompt → LLM → output | Prompt → tool call → LLM → output | Goal → orchestration → agents → output | Input from system → output |
| Structure | One model | LLM + tools | Many agents, often different LLMs | One sub-agent |
| Memory | None / context window | Short-term, within task | Persistent, shared across stages | Subtask-local |
| Planning horizon | None | Single-step to short | Multi-step, re-planning | One step in a workflow |
| Coordination | None | None (works alone) | Hierarchical or decentralized | Takes orders |
| Evaluate by | Coherence, diversity | Accuracy, latency | Engagement, adaptability, end-to-end success | Fit to the parent task |
| Typical example | Chatbot | Search-and-summarize agent | Research or incident-response pipeline | Title/summary generator |
The single line to remember: an AI Agent decides which tool to call; Agentic AI decides which agent does which part of the goal. The unit of decision moves up one level.
Architecture & data flow
The paper describes the single agent as a closed loop of four modules (perception, reasoning, action, basic learning). Agentic AI keeps those modules inside each agent and adds four things around them: specialized agents, advanced planning, persistent memory, and an orchestration layer.
flowchart LR
subgraph AIAgent[AI Agent - one loop]
P[Perception: prompt template, retrieval] --> R[Reasoning: LLM, CoT/ReAct]
R --> A[Action: tool call]
A -->|observation| R
A --> L[Basic learning: memory buffer]
end
subgraph Agentic[Agentic AI - added layers]
O[Orchestrator / meta-agent] -->|subtask| S1[Specialist agent 1]
O -->|subtask| S2[Specialist agent 2]
O -->|subtask| S3[Verifier agent]
S1 <--> M[(Persistent shared memory)]
S2 <--> M
S3 <--> M
S3 -->|accept / reject| O
end
G[High-level goal] --> O
O --> OUT[Integrated result]
And here is what happens to one request in each paradigm. In the agent case the LLM loops with tools. In the agentic case the orchestrator decomposes, dispatches, and reconciles.
sequenceDiagram participant U as User participant Orc as Orchestrator participant Ret as Retriever agent participant Syn as Synthesizer agent participant Ver as Verifier agent participant Mem as Shared memory U->>Orc: goal: draft a grant proposal section Orc->>Orc: decompose into subtasks + dependencies Orc->>Ret: find prior funded proposals + recent work Ret->>Mem: write sources + notes Orc->>Syn: draft section from memory Syn->>Mem: read sources, write draft v1 Orc->>Ver: check draft against sources + solicitation Ver-->>Orc: 2 claims unsupported Orc->>Syn: revise those claims Syn->>Mem: draft v2 Orc-->>U: integrated draft + open issues
Why multi-agent failures compound (the math worth knowing)
The paper’s sharpest claim is qualitative: errors cascade. You can make it quantitative with one line. If each agent in a chain of n handoffs gets its part right with probability p, and nothing checks the work, the chance the whole chain is right is:
P(success) = p^n
In plain English: reliability multiplies down. Five agents that are each 95% right give you 0.95^5 ≈ 77% end to end. Ten give you about 60%. That is the “amplified” in “amplified causality challenges”. A verifier at each handoff that catches a fraction c of errors (and lets the stage retry) lifts per-step reliability to roughly p + (1 - p)·c, which is why the paper’s mitigation list keeps coming back to self-critique and inter-agent review. (This formula is our illustration, not the paper’s; the paper gives no numbers.)
Schematic. Drag the sliders: per-agent accuracy, chain length, and verifier catch rate. The bars show each stage's chance of still being correct. Watch how fast an unchecked chain decays, and how much a verifier buys back.
Three techniques, mini how-it-works
- ReAct loop (agent level). The model alternates Thought → Action (tool call) → Observation, and the observation is pasted back into context before the next thought. It turns a single-pass guess into a feedback loop. Its weakness, which the paper names, is that it has no real model of time or state, so agents repeat tool calls or stall when a tool returns something ambiguous.
- Orchestrator / meta-agent (system level). One agent owns the plan: it splits the goal, assigns roles, tracks dependencies, and merges outputs (ChatDev’s “CEO” agent, MetaGPT’s company roles, AutoGen’s planner). It is the single most important part, and also the single point of failure.
- Tiered memory. Episodic (what happened in this task), semantic (stable facts), and vector (similarity retrieval for RAG). In agentic systems each agent has local memory plus access to a shared store, so they act on one version of the truth instead of divergent contexts.
Schematic 3D topology. Click the buttons to switch between Generative AI (one model), AI Agent (one model plus tools), and Agentic AI (orchestrator, specialist agents, shared memory). Drag to orbit.
The algorithm, simplified
The whole distinction fits in two functions: the agent loop, and the orchestrator that runs agent loops as workers.
# llm(prompt) -> str ; tools: dict[name -> callable] ; memory: shared dict-like store
def ai_agent(task, tools, max_steps=8):
"""AI Agent: one LLM, one narrow task, ReAct loop over tools."""
context = [task]
for _ in range(max_steps):
step = llm(f"Think, then pick a tool or FINISH.\n{context}")
if step.startswith("FINISH"):
return step
name, args = parse_tool_call(step)
context.append(tools[name](**args)) # observation goes back into context
return "gave up" # long-horizon limit the paper warns about
def agentic_system(goal, roles, memory, max_rounds=3):
"""Agentic AI: decompose the goal, dispatch to specialists, verify, re-plan."""
plan = llm(f"Split into subtasks with owner roles and dependencies:\n{goal}")
for sub in topo_sort(parse_plan(plan)): # respect dependencies
for _ in range(max_rounds):
ctx = memory.read(sub.depends_on) # shared memory = one version of truth
out = ai_agent(f"{sub.task}\nContext:{ctx}", roles[sub.role].tools)
verdict = ai_agent(f"Check this against sources:\n{out}",
roles["verifier"].tools)
if "PASS" in verdict: # stops a bad output from cascading
memory.write(sub.id, out)
break
sub.task += f"\nFix: {verdict}" # feedback becomes the next attempt
else:
return escalate_to_human(sub, out) # governance: bounded autonomy
return llm(f"Integrate:\n{memory.read_all()}")
The point of the code: Agentic AI is not a new kind of model call. It is ai_agent called in a
dependency-ordered loop, with a shared store, a verifier, and an escape hatch.
Built on Prior Work
The paper is a map of the field, so the lineage is the content.
| Prior idea | What it gave | What this paper changes |
|---|---|---|
| Classical MAS, BDI agents, expert systems (Castelfranchi, Ferber, MYCIN) | Autonomy, social action, goal delegation, rule-based reasoning | Re-grounds those concepts in LLM-based systems; argues today’s “agents” still fail the classic tests (proactivity, social ability) |
| Generative LLMs (GPT-4, PaLM, LLaMA) and LIMs (CLIP, BLIP-2) | The reasoning and perception core | Treated as the baseline column in every comparison |
| ReAct, Chain-of-Thought, Tree of Thoughts | Reason-act loops and multi-step reasoning | Placed as the single-agent reasoning layer; flagged as heuristic, not real planning |
| Tool-augmented LLMs, function calling (Toolformer-style, Gentopia, EasyTool) | Agents that act on APIs | Defines the “AI Agent” tier |
| AutoGPT, BabyAGI | Self-prompting goal loops | Positioned as the bridge from agent to agentic |
| AutoGen, CrewAI, MetaGPT, ChatDev, CAMEL, LangGraph | Role-based multi-agent orchestration | Defines the “Agentic AI” tier and supplies most examples |
| Reflexion, RAG, memory architectures | Self-critique, grounding, persistence | Re-cast as cross-tier mitigations, with a multi-agent version of each |
| Google A2A protocol (2025) | Agent-to-agent interop standard | Cited as early infrastructure for the agentic tier |
Results & Evidence
There are no experiments, benchmarks, or measurements. The evidence is a literature synthesis gathered from twelve sources, including AI search tools (ChatGPT, Perplexity, DeepSeek, Grok) alongside Scholar, IEEE, ACM, and arXiv.
What the paper does establish:
- A consistent, usable vocabulary and comparison grid.
- A reasonable inventory of failure modes and mitigations, each tied to prior work.
- Two tables of 2023-2025 systems (Deep Research, Operator, NotebookLM, Agentforce, Copilot on the agent side; AutoGPT, MetaGPT, Voyager, CAMEL, Copilot Studio on the agentic side) that show how vendors use the terms.
What it does not establish:
- That agentic systems outperform single agents on any task. Claims like “outperforming single-agent systems such as ChatGPT” and “early deployments … demonstrated increased diagnostic precision” come without numbers.
- That the tier boundaries are sharp. Several systems in Table X (Deep Research, Manus, Operator) do multi-step planning that the taxonomy assigns to Agentic AI, and Table XI includes GPT-4o + plugins. The classification of real products is loose.
- Anything about cost. More agents means more LLM calls, more latency, more tokens; the paper names this but never quantifies it.
Caveats worth knowing: the application walkthroughs (orchard robots, ICU sepsis agents, grant writing) are illustrative scenarios, not case studies; the figures are AI-generated; there are citation slips (AutoGPT is cited with AutoGen’s reference number in places); and the table numbering in the prose does not always match the tables. Read it as a well-organized position paper, not as evidence.
How You’d Use It
The taxonomy pays off as a design-review tool. Three lenses fit.
Your harness. Use the comparison grid as a checklist when you add a capability. Before adding a second agent, ask: does this task need goal decomposition, persistent cross-step state, or parallel specialists? If not, add a tool to the existing agent instead. Where you do go multi-agent, the challenge list tells you which harness features to build first: a structured message schema between agents (not free text), a shared memory store with clear write ownership, per-agent trace logging that you can replay, a verifier step at each handoff, and a hard ceiling on loop counts. Cost: a few days of plumbing. Payoff: the error-cascade math stops being invisible.
Your automations and business processes. Sort every automation you run or plan into one of the tiers. Most back-office work (classify an email, extract fields from an invoice, answer a policy question, schedule a meeting) is AI Agent work: one loop, a few tools, measured on accuracy and latency. Reserve agentic designs for jobs with real dependencies across stages (research to draft to review, incident triage that spans logs, policy, and remediation). What must be true for the agentic version to pay off: the stages are separable, each stage has a checkable output, and a human gets the exceptions. If you cannot write a pass/fail check for a stage, that stage is where your cascade starts.
Your workflows and methodologies. Bring the “Generative Agent” idea into how you design pipelines: many steps inside a big workflow are not agents at all, just one bounded generation (write the title, summarize this section). Treat those as plain function calls with a schema and a test, not as agents with tools and autonomy. You get cheaper, more predictable pipelines, and you keep “agent” for the steps that actually need to decide something.
Your applications. When you describe a product feature, the tier tells users and teammates what to expect. An “agent” that books meetings should be judged on accuracy and speed. A multi-agent research assistant should be judged on end-to-end task success and on how it surfaces uncertainty. Picking the right tier up front also tells you which evaluation set to build.
Build Your Own (Minimal Recipe)
The smallest build that captures the paper’s lesson is a two-mode harness you can flip between, so you can measure whether going agentic is worth it on your own task.
- Single-agent baseline. One ReAct-style loop with 3-5 tools, a step cap, and a full trace log (prompt, tool call, observation per step). Use any function-calling model; LangGraph or plain Python is enough.
- Shared memory store. A dict keyed by subtask id, persisted to SQLite or JSON. Each agent writes only its own keys. Add a vector index only when retrieval actually matters.
- Orchestrator. One LLM call that turns the goal into a JSON plan: subtasks, owner role, dependencies. Validate the JSON before running it; reject cycles.
- Specialists. Reuse the baseline loop with different system prompts and tool subsets per role.
- Verifier at each handoff. A separate call that checks the output against sources or a rubric and returns PASS or a fix instruction. Cap retries at two or three, then escalate to a human.
- Run both modes on the same 20-50 tasks. Record end-to-end success, tokens, wall-clock time, and where failures start. That table is the evidence the paper does not give you.
The hard parts: (a) writing verifiers that catch real errors without rejecting good work, and (b) keeping the orchestrator’s plan stable (re-planning on every hiccup creates the infinite planning loops the paper warns about). Reach for: a function-calling LLM, Pydantic for message schemas, LangGraph or AutoGen for wiring, OpenTelemetry-style tracing or a simple JSONL log for replay.
How to Improve It
- Add measurements. Run the same task suite in Generative AI, AI Agent, and Agentic AI modes and publish success, cost, and failure-location numbers. Without this the taxonomy cannot tell you when to move up a tier.
- Turn the tiers into a continuous scale. Real systems mix tiers (Deep Research plans like an agentic system but runs as one product). Score systems on separate axes (decomposition, memory persistence, number of decision-makers, autonomy level) instead of forcing one label.
- Model the cascade explicitly. Measure per-handoff error rates and verifier catch rates in a real pipeline, and use p^n-style reliability budgets to decide where verifiers go and how long a chain is allowed to be.
- Make “causal reasoning” testable. The paper leans on causal modeling as a cure-all but never says what it means in an LLM harness. A concrete version: PDDL-style preconditions and effects for each agent action, checked before execution, so an agent cannot act on a state another agent has not produced.
- Treat inter-agent messages as an attack surface. Prompt injection through a tool result or a peer agent’s output is the paper’s “single point of compromise”. Test it: inject a poisoned document at the retriever and measure how far it propagates with and without a verifier and role isolation.
Glossary
- AI Agent — one LLM in a loop with tools, built for a narrow, well-defined task.
- Agentic AI — a system of several specialized agents that decompose a goal, share memory, and are coordinated by an orchestrator.
- Generative AI — a model that produces content from a prompt and does nothing else; no tools, no goals, no state.
- Generative Agent (inferred) — a sub-agent that performs one generative subtask inside a larger workflow.
- LIM (Large Image Model) — a vision or vision-language model like CLIP or BLIP-2 that gives an agent perception.
- Orchestrator / meta-agent — the agent that plans, assigns subtasks, tracks dependencies, and merges results.
- Goal decomposition — splitting a high-level objective into smaller subtasks with an order and owners.
- ReAct — a loop of reasoning, tool action, and observation fed back into the model.
- Chain-of-Thought (CoT) — prompting the model to write intermediate reasoning steps before answering.
- Tree of Thoughts — exploring several reasoning branches and choosing among them.
- RAG (Retrieval-Augmented Generation) — fetching relevant documents and placing them in context so answers are grounded.
- Episodic memory — a record of what happened in past steps or sessions.
- Semantic memory — stable facts and structured knowledge the agent can look up.
- Error cascade — one agent’s mistake becoming another agent’s trusted input, so errors compound.
- Emergent behavior — system-level behavior no single agent was programmed to produce, good or bad.
- Non-compositionality — adding agents does not reliably add capability; it can add noise and overhead.
- Reflexion / self-critique — a second pass where the agent (or a peer) reviews output and feeds back fixes.
- PDDL / STRIPS — classic planning languages that describe actions by preconditions and effects.
- A2A protocol — Google’s 2025 proposed standard for agents from different frameworks to talk to each other.
- Absolute Zero (AZR) — a self-play training approach where models generate and verify their own tasks without external data.