Take the usual agentic AI examples: a travel assistant that makes the booking as well as the plan, a coding agent that edits files across a repository, a research system that runs its own searches. They all share one structural feature. Each runs a language model inside a loop that lets it call tools, see the results and pick the next step, and it keeps going until a stop condition is met. Text generation on its own, however fluent, is not that. A large model used only for zero-shot text generation has no agency, while a smaller, older model placed in an iterative execution loop with database write access is highly agentic.
For the wider definitional debate, our comparison of agentic AI and generative AI covers architecture, autonomy and deployment side by side. The examples below show what each one asks of the engineering around the model.
The loop that turns a generator into an agent
The move from a standard LLM to an agentic system is made by wrapping the model in an iterative execution loop. That loop is a programmatic while loop: it prompts the model, parses the output as a function call, runs the function against an external API, feeds the result back into the context window, and repeats until a termination condition is met. Sapkota et al. put the contrast as a pipeline. Generative AI runs prompt, then LLM, then output. An AI agent runs prompt, tool call, LLM, output, folding the tool response back in partway through.
The model never runs anything on its own. Anthropic’s tool-use documentation describes the model emitting a structured request. Your code (or Anthropic’s servers) runs the operation, and the result goes back into the conversation. For client-executed tools the application drives the loop. It keys on stop_reason, keeps running tools while that value is tool_use, and exits on end_turn, max_tokens, stop_sequence or refusal. An orchestration framework such as LangChain or DSPy parses the model’s probabilistic token output into deterministic API calls.
Agency belongs to the configured system (model, harness, tool permissions and environment), not to the model alone. So the same open-weight model can be a text generator in one deployment and an agent in another. A deployer alters its agency by wrapping it in a LangChain loop and granting it API access to a live database. Open models such as the one discussed in our piece on the Vicuna paper and what it means for open LLM agents get their agency the same way: from the harness built around them. The parts of that harness (memory, tool schemas, planners, verifiers) are covered in how LLM agents are built. The generator side of the contrast is covered in what generative AI means.
Agentic AI examples, and what makes each one agentic
The table below pairs each agentic example with its nearest generative counterpart. The deciding column is the one that says what the system can change in the world.
| Example | Generative version | Agentic version | What makes it agentic |
|---|---|---|---|
| Travel planning | Drafts an itinerary but does not book anything | Builds the itinerary, makes the bookings and checks they do not clash with other schedules | Actions with side effects in booking systems |
| Coding | Produces code from a user prompt | Makes edits across many files from a task description | Ground truth from code execution at each step |
| Computer use | Describes how to complete a form | Operates a desktop or browser by moving the cursor, clicking, typing and reading the screen | A GUI action space; OpenAI’s Operator also targets GUI operation from screenshots and mouse and keyboard actions |
| Research | Summarises the documents it is given | A lead agent plans, saves the plan to memory and sends parallel subagents to search | Self-directed search loops and persistent memory |
| Knowledge compilation | Drafts a section of a review | Retrievers, summarisers, synthesisers and citation formatters work under an orchestrator, used for literature reviews, grant preparation and patent searches | Orchestrated roles with shared memory |
| Enterprise processes | Drafts an escalation email | Agents handle legal review or incident escalation, with a specialised module governing each step | Steps executed across business systems |
| Field robotics | Not applicable | Several robots harvest an apple orchard using shared spatial memory and separate agents for mapping, picking and transport | Coordinated physical actuation |
Summarisation, translation and general-knowledge questions stay on the generative side. They need no tool round trip, because the model can answer from its training alone. Our own split of business generative AI follows the same line. One pattern is the analytics co-pilot that summarises and structures text; the other is the workflow agent that executes steps. That contrast is worked through for one sector in agentic and generative AI in real estate. For what coding agents actually do inside engineering teams, see autonomous AI in software engineering.
Is ChatGPT agentic, or only when it is given tools?
Conversational AI used purely for text generation has no agency. A model’s agency comes from the loop, tools and permissions wrapped around it. OpenAI says ChatGPT agent plans dynamically, chooses its own tools and works on its own virtual computer, and it combines Operator’s website interaction with deep research’s synthesis. A model in chat with no tools attached does none of that. For Claude, too, the agentic part is the loop: Sapkota et al. describe its computer-use mode as an agent loop that receives a goal, picks an action, carries it out, observes the result and repeats. The scoping consequences of the ChatGPT question are covered in our piece on autonomous AI agents in software engineering.
When a single generative call is enough
Start with one call, and move to an agent only when the steps cannot be fixed in advance. Anthropic’s engineering guidance says that for many applications, optimising a single LLM call with retrieval and in-context examples is usually enough. It reserves agents for open-ended problems where the number of steps is hard or impossible to predict and no fixed path can be hardcoded.
The checks run in order:
- Can the model answer from text alone, with nothing to execute? Use one call. One-shot Q&A with no side effects gives a tool nothing to do.
- Does the task need side effects, fresh external data, a guaranteed output shape or a call into an existing system? Add tool use.
- Can the task be broken into fixed subtasks? Use a sequential workflow, which trades latency for accuracy by giving each call a narrower job. Workflows give predictability for well-defined tasks.
- Does the work exceed one call’s context window, reliability or tool permissions, on a path you cannot hardcode? Then an agent loop fits.
Over-building costs tokens. Multi-agent systems use roughly 10 to 15 times more tokens than single agents. Its research team also found early agents spawning 50 subagents for simple queries, and responded by writing scaling rules into the prompts: simple fact-finding gets one agent with 3 to 10 tool calls. Sapkota et al. name the two-sided risk: under-engineering scenarios that really need coordination, and over-engineering applications that one agent could handle. Read together, this guidance treats “agentic” as a cost taken on once fixed-path options have run out, not a capability tier to aim for.
What an agent needs that a single call does not
A single generative call keeps no persistent state between prompts. An agent, by contrast, carries state across many tool calls. Anthropic says plainly that agents are stateful, that errors compound, and that long runs require durable execution with error handling along the way. When Anthropic deploys updates, agents might be anywhere in their process.
| Concern | What it means in practice |
|---|---|
| State persistence | LangGraph’s checkpointer saves a snapshot of graph state at every super-step. That enables human-in-the-loop approval, time-travel debugging and fault-tolerant execution |
| Recovery | Writes are also kept per node, so if one node in a super-step fails, the nodes that succeeded do not run again on resume |
| Loop bounds | Set turn or step limits, cap and time out retry paths, and limit message history size; do not count on the model to stop calling tools |
| Budgets | Budgets and termination criteria stop endless tool chains and self-critique loops |
| Observability | Debugging means seeing prompt chains, decision paths, retrieval contexts and token use, because a stack trace is not enough for a non-deterministic system |
| Audit | Enterprise frameworks stress trace logs, data governance and failure recovery |
| Runtime control | Observability tooling looks back after the fact; changing a run while it is in progress needs a separate execution-time layer |
A visible exit does not necessarily stop the loop. One study of infinite agentic loops lists maximum turns, timeouts, retry limits, budgets and recursion limits as execution bounds. Without one that covers the feedback path, the loop can become an infinite agentic loop. In one case the authors examined, the loop exited only when the model stopped producing tool calls. That is an exit controlled by model output, not a deterministic bound, and meanwhile the message history kept growing along with latency and API cost. Anthropic’s own guidance includes stopping conditions such as a maximum iteration count.
Choosing a platform that provides checkpoints, trace logs and budget limits is the subject of choosing an MLOps platform for agentic and generative workloads. Each planning or tool-calling cycle may take several LLM calls, which adds run-time latency. Measuring that end-to-end time on a device is covered in what MLPerf Client measures and how to read it.
Failure modes that only appear once the model can act
Once a model can act, its mistakes can become concrete failures rather than incorrect text:
- Infinite loops. A feedback path keeps triggering costly or state-growing calls with no effective bound. Agents also get stuck retrying a failed action without changing strategy.
- Hallucinated actions. Once a model can modify files, run code or drive a desktop, a hallucination becomes a concrete failure rather than incorrect text.
- Compounding errors. In ReAct-style loops, one early mistake carries downstream into cascading failures. Autonomy raises both cost and the potential for compounding errors.
- Prompt injection. A web page, document or tool output can contain text that redirects the model. With credentials in play, the result can be data disclosure or an unauthorised state change.
Prompt-only defences are brittle. Robust agent security is a systems problem: constrained tool permissions, sandboxes, user confirmation for sensitive actions, and independent audit components that validate plans before they run. Natural language is underspecified as an access policy. “Handle my travel” sets no spending ceiling and does not say whether a non-refundable purchase is allowed.
Where predictive and physical AI sit next to an agent
In one reliability-focused architecture for agentic AI, the generative model supplies the policy (how to reason and propose actions). The agentic architecture supplies the machinery that validates, carries out, bounds and records those proposals. That spine includes a goal manager, planner, tool router, sandboxed executor, memory, verifiers, a safety monitor and telemetry.
A predictive model, such as a sentiment classifier or a risk score, fits in as one of the agent’s tools: a function the router can call.
Physical AI is what lets autonomous machines such as factory robots and robotaxis perceive, understand and act in the physical world. One physical AI agent architecture sets out perception, cognitive and actuation blocks. A vision-language-action policy can produce competent motor actions without owning the high-level objective. The orchestration layer that picks tasks, interprets safety constraints and checks outcomes may sit separately. Embodied and web agents call for stricter runtime assurance and sandboxing than purely analytical ones.
TechnoLynx generative and agentic AI R&D can scope a use case by deciding which layer each part needs: a generation, a prediction, a physical action, or a loop that chains them. That choice sets the infrastructure, monitoring and failure handling the build needs.
FAQ
Is agentic AI built on generative AI?
Usually, yes. Sapkota et al. treat generative AI as the precursor and foundation, with agents built on it through tool integration and reasoning enhancements. The generative model often acts as the reasoning substrate inside the agent.
Does agentic AI really exist today?
Systems that browse the web, run code, query databases and send emails without a human confirming each step are already deployed commercially. Their autonomy is partial, though. They still depend on human-defined prompts, planning heuristics and feedback loops.
What is the difference between an agent and a plain LLM?
A plain LLM functions primarily as a reactive prompt follower. An agent works within a defined scope with bounded autonomy and a persistent task orientation, producing actionable outputs.
