What Is an AI Agent? Goals, Tools, and the Loop

An AI agent is an LLM-powered system that pursues a goal over multiple steps rather than answering once and stopping. You give it an objective, and it plans a sequence of actions, calls tools, observes what happened, and loops until the work is done — or until it decides it cannot proceed. The difference from a plain chatbot is that an agent acts, not just responds.

The agent loop

The core execution pattern is a tight cycle often described as perceive → plan → act → observe:

1. Perceive. The agent takes in its current context: the original goal, any conversation history, tool outputs from previous steps, and whatever memory it has access to.
2. Plan. The LLM reasons about what to do next — which tool to call, what arguments to pass, or whether it has enough information to produce a final answer.
3. Act. The agent executes the chosen tool call (or produces output if it’s done).
4. Observe. The result of the action — a function return value, a web page, a terminal output — is fed back into the context, and the loop restarts.

This cycle repeats until the agent reaches its stopping condition: the goal is met, it runs out of attempts, or a verification check is satisfied.

The components

A working agent is more than a model with a system prompt. Five pieces come together:

• The model (the reasoner). The LLM is the brain. It decides what the goal requires, interprets tool results, and generates the next action. Capable, instruction-following models with large context windows work best for long tasks. Something like Claude Fable 5 is designed specifically for this kind of sustained, autonomous reasoning.
• Tools. Functions the model can invoke: web search, code execution, file read/write, database queries, external APIs. The model never calls these directly — it outputs a structured tool call, and the runtime executes it. Model Context Protocol is emerging as a standard for connecting agents to tools and data sources without custom integration work, and a Big Tech coalition is pushing ARD to standardize the layer above — how agents discover which tools exist at all.
• Memory. Agents have several memory layers: the context window (short-term, wiped each session), a retrieved long-term store (a vector or key-value database the agent queries), and sometimes a persistent scratch pad it writes to mid-run.
• Orchestration loop. The harness that drives the perceive-plan-act-observe cycle, routes tool calls, enforces step limits, handles errors, and decides when to stop.
• Stopping and verification. Without an explicit stopping condition, an agent can loop indefinitely. Good designs include a maximum-step budget, a verification tool that checks whether the goal was actually satisfied, and a human-in-the-loop escape hatch for high-stakes decisions.

What agents are used for

Agents earn their complexity when a task is too long, too multi-step, or too dynamic for a single prompt to handle:

• Coding agents. Given a bug report or feature spec, they read the codebase, write a fix, run tests, and iterate — the backbone of the AI coding assistant generation we’re in now.
• Research agents. They search, read sources, extract facts, and synthesize a structured output — compressing hours of reading into minutes.
• Support agents. They look up account state, take actions in a ticketing system, and draft or send responses, escalating only when they hit a decision they cannot make.
• Multi-agent pipelines. Complex workflows sometimes use a coordinator agent that spawns specialist sub-agents. Platforms like Databricks Omnigent are built specifically to orchestrate these multi-agent architectures at scale.

Risks and real limits

The agent loop multiplies both capability and failure modes.

Error compounding. A small mistake early in a run can cascade — a wrong tool call changes state, which the agent then reasons from incorrectly, producing a chain of bad steps. The further an agent runs from its last verified checkpoint, the more consequential any prior mistake.

Cost and latency. Each loop iteration is an LLM call plus one or more tool calls. A twenty-step agent run can consume as many tokens as dozens of chat exchanges, and it takes time. Keeping steps minimal and tools fast matters.

Hallucinated tool use. The model might invent a tool argument or misread a tool’s output schema. Strict output parsing and schema validation at the harness level catch most of this before it causes damage.

Irreversible actions. Agents that can send emails, modify databases, or deploy code can cause real-world harm if they go wrong. Sandboxing, dry-run modes, and human approval gates for destructive operations are essential guardrails.

Understanding these risks starts with understanding what LLMs can and cannot do and how reasoning models are changing the planning step.

The takeaway

An AI agent wraps an LLM in a loop: perceive the situation, decide an action, call a tool, observe the result, repeat. The power comes from compounding many small capable steps into work that no single prompt could accomplish. The risk comes from the same compounding — errors grow with horizon length, and agents that act in the world need verification, guardrails, and clear stopping conditions to be safe and reliable.