Applications
Agentic AI
AdvancedA chatbot answers a question. An agent pursues a goal - it plans, uses tools to act on the real world, observes what happened, and loops until it's done. This page builds from what 'agentic' actually means, through tools, memory, and orchestration, to why long-running agents are an infrastructure problem.
What makes a system “agentic”
The difference isn't the model - it's the autonomy. A single prompt is one input and one output. An agent is given a goal and the freedom to decide the steps: which tools to call, in what order, and when the job is finished. That loop is what turns a text generator into something that gets things done.
Single prompt (chatbot)
- One question in, one answer out.
- No actions - it can only produce text.
- Knows only what's in the prompt and its training.
- Stateless: forgets the moment the reply is done.
Agent
- A goal in, a completed task out.
- Calls tools to read and change the world.
- Gathers new information as it goes.
- Keeps state across many steps until the goal is met.
The core: the reason–act–observe loop
Almost every agent runs the same loop, often called ReAct (reason + act). The model reasons about what to do next, acts by calling a tool, observes the result, and feeds that back in to reason again - repeating until the goal is reached. Step through a real run below.
The agent loop - reason, act, observe, repeat
A single prompt answers once. An agent runs a loop: it reasons about the goal, calls a tool to act on the world, observes the result, and decides whether to keep going. Task: book a project kickoff.
Run transcript
Press Start to watch the agent work toward the goal one step at a time.
Tool use & function calling - how agents touch the world
On its own a model can only write text. Tools (also called function calling) give it hands: a tool is a function the model can request - search the web, run code, query a database, send an email. The model outputs a structured call, your system runs it, and the result comes back as the next observation.
MCP - the USB-C port for AI tools
Before, every agent needed custom glue for every tool - an N×M integration mess. The Model Context Protocol (MCP), open-sourced by Anthropic and now adopted by OpenAI, Google, Microsoft, and AWS, makes it N+M: each agent speaks MCP, each tool exposes an MCP server, and any agent can discover and use any tool with no new code. An agent asked to “organize the kickoff” can hit a calendar server, an email server, a room-booking server, and a tracker - all in one reasoning session.
MCP SDK downloads / mo
97M+
Public MCP servers
10,000+
Integration cost
N+M
Figures as of early 2026. The Nov-2025 spec added async operations, server identity, and audit trails - the governance pieces enterprises were waiting for.
Context & memory - what the agent carries
An agent needs to remember what it has already done, learned, and been told. That memory comes in layers - fast working memory in the context window, and durable long-term memory it can look up when needed.
Short-term (context window)
The working memory of the current run - the system prompt, tool definitions, and everything reasoned and observed so far. Fast, but finite and re-read every step.
Episodic memory
A log of past runs and their outcomes - 'last time this approach failed.' Lets an agent learn from its own history across sessions.
Semantic memory
Durable facts and domain knowledge the agent can look up - policies, product specs, user preferences - usually stored outside the model.
Vector memory
Long-term memory made searchable: embed past interactions and retrieve the most relevant ones by meaning. This is RAG, pointed at the agent's own history.
The catch: the context window only grows. Every step appends more reasoning and more tool output, and the model re-reads it all each time. That's the hidden cost driver - see it move below.
Why agents are expensive - context only grows
A chat answers one prompt. An agent appends its reasoning and every tool result back into the context, step after step. The window balloons, and the GPU bill scales with how many tokens it must re-read each step.
Context window after 8 steps
Context now
10.0K tok
Tokens processed
53.4K tok
vs. one-shot prompt
34×
With no caching, every step re-reads the entire growing context, so total work climbs quadratically. A long agent run can process tens of times the tokens of a single question - which is why fast inference, prefix caching, and high-bandwidth data infrastructure decide whether agents are affordable at scale.
Multi-agent orchestration
One agent is sequential and can drift on a big task. The fix is to coordinate several - splitting work, running threads in parallel, and gating risky actions behind a human. These are the common patterns.
Single agent (ReAct)
One model in a reason–act–observe loop. Simple and predictable; the baseline for almost every agent.
Orchestrator–worker
A lead agent decomposes the goal and spawns sub-agents to work threads in parallel. Anthropic's research system beat a single agent by ~90% on internal evals this way.
Planner / DAG executor
Plan the whole task as a dependency graph, then run independent steps at once. LangChain's LLMCompiler reports ~3.6× speedup over sequential ReAct.
Human-in-the-loop
Insert approval gates before risky actions (spend money, send email, ship code). The agent proposes; a person confirms.
Where agents are working today
Agentic systems are already in production wherever a task is multi-step and needs to touch real tools.
Coding agents
Cursor, Replit, and Claude Code read a repo, plan a change, edit files, run tests, and iterate on the errors - a loop, not a single completion.
Research agents
Decompose a question, search many sources in parallel, read and cross-check, and synthesize a cited report.
Operations & RPA
Triage a ticket, look up the customer, take the fix across several systems, and update the record - the kickoff-booking demo, generalized.
Data & analytics
Translate a business question into queries, run them, check the numbers, and explain the result in plain language.
Agents are an infrastructure problem
A single chat is one model call. An agent is dozens - each re-reading a growing context, waiting on tools, and often retrieving from memory. That makes inference speed, KV-cache reuse, and fast data access the difference between an agent that's magical and one that's too slow and too expensive to ship. And an agent's durable memory - its episodic, semantic, and vector stores - has to live somewhere persistent and instantly searchable: a data platform, not a transient context window.