Agent Architecture & Harnesses · 2025

AI Agents vs. Agentic AI - A Conceptual Taxonomy, Applications and Challenges

Agent Architecture & Harnesses AI Agents vs. Agentic AI - A Conceptual Taxonomy, Applications and Challenges 2025 · arXiv 2505.10468
Topic
Agent Architecture & Harnesses
Year
2025
Read
12 min
Source
arXiv:2505.10468

In one line

"Agentic AI" is not a smarter agent; it is a *team* of narrow agents plus an

The breakdown

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:

  1. 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.
  2. 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.
  3. 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).
  4. 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)

Three tiers: generative AI turns a prompt into content, an AI agent is one LLM with tools doing one task, agentic AI is many agents plus an orchestrator and shared memory working on one goal. The unit of decision moves from the output, to the tool call, to which agent does which part.

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

DimensionGenerative AIAI AgentAgentic AIGenerative Agent (inferred)
TriggerUser promptPrompt or goal, with tool useGoal or orchestrated taskSystem or parent agent
FlowPrompt → LLM → outputPrompt → tool call → LLM → outputGoal → orchestration → agents → outputInput from system → output
StructureOne modelLLM + toolsMany agents, often different LLMsOne sub-agent
MemoryNone / context windowShort-term, within taskPersistent, shared across stagesSubtask-local
Planning horizonNoneSingle-step to shortMulti-step, re-planningOne step in a workflow
CoordinationNoneNone (works alone)Hierarchical or decentralizedTakes orders
Evaluate byCoherence, diversityAccuracy, latencyEngagement, adaptability, end-to-end successFit to the parent task
Typical exampleChatbotSearch-and-summarize agentResearch or incident-response pipelineTitle/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 ideaWhat it gaveWhat this paper changes
Classical MAS, BDI agents, expert systems (Castelfranchi, Ferber, MYCIN)Autonomy, social action, goal delegation, rule-based reasoningRe-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 coreTreated as the baseline column in every comparison
ReAct, Chain-of-Thought, Tree of ThoughtsReason-act loops and multi-step reasoningPlaced 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 APIsDefines the “AI Agent” tier
AutoGPT, BabyAGISelf-prompting goal loopsPositioned as the bridge from agent to agentic
AutoGen, CrewAI, MetaGPT, ChatDev, CAMEL, LangGraphRole-based multi-agent orchestrationDefines the “Agentic AI” tier and supplies most examples
Reflexion, RAG, memory architecturesSelf-critique, grounding, persistenceRe-cast as cross-tier mitigations, with a multi-agent version of each
Google A2A protocol (2025)Agent-to-agent interop standardCited 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.

  1. 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.
  2. 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.
  3. Orchestrator. One LLM call that turns the goal into a JSON plan: subtasks, owner role, dependencies. Validate the JSON before running it; reject cycles.
  4. Specialists. Reuse the baseline loop with different system prompts and tool subsets per role.
  5. 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.
  6. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.