An AI agent is a system that uses a language model to pursue a goal over multiple steps, rather than answering a single question and stopping. Give a chatbot a prompt and it replies once. Give an agent a task — "research this topic and draft a report" or "find the bug causing this test failure" — and it plans a sequence of actions, calls tools, reads the results, adjusts its plan, and keeps going until the task is done or it gets stuck.
The difference is not the model. It is the loop around the model. A typical agent runs a cycle: reason about what to do next, take an action, observe the result, and repeat. The actions available to it are tools: web search, a code interpreter, file access, an API, a database query. The model decides which tool to call and what to do with the output, and the loop continues until the agent produces a final answer or hits a limit on steps, time, or cost.
This architecture is what makes agents feel different from ordinary chatbots. A chatbot's context is one conversation. An agent's context grows as it works: every tool result becomes part of the record it reasons about next. That accumulation is both the source of its power and the source of most of its failures.
The Tools: What an Agent Can Actually Do
A language model on its own can only produce text. Tools are what connect that text to the world. A web search tool lets the agent look up current information instead of relying on what it was trained on. A code execution tool lets it run a calculation or test a hypothesis rather than guessing the answer. A file tool lets it read and write documents, and an API tool lets it query a live system or trigger a real action, such as sending a message or creating a ticket.
The quality of an agent is largely determined by the quality of its tools. A tool that returns clean, structured results makes the agent's job easy; a tool that returns a wall of unstructured text forces the model to spend its attention parsing instead of reasoning. Good agent design therefore spends most of its effort on tool design: clear descriptions of what each tool does, strict limits on what it can touch, and results formatted so the model can use them without confusion.
There is also a cost dimension. Every tool call consumes tokens and time, and the model must re-read the growing transcript on each step. A task that takes twenty tool calls costs roughly twenty times the reasoning of a single reply, and the bill scales with the size of the accumulated context.
The Loop: Why Agents Get Stuck
The reasoning loop sounds simple, but it has several well-known failure modes. The first is the simplest: the agent repeats itself. It tries a tool call, gets an unhelpful result, and tries the same call again with slightly different wording, burning steps until it hits its limit. Without explicit memory of what has already failed, the model has no strong reason to change strategy.
The second failure mode is the opposite: the agent drifts. Each tool result adds new information, and after enough steps the original goal gets buried under intermediate detail. The agent starts solving a sub-problem that no longer serves the task, or misreads an early result and builds an entire plan on a wrong assumption. Long loops amplify small errors.
The third is the most dangerous: the agent takes a real-world action it should not have taken. A loop with write access to a database, a payment system, or a production server can do genuine damage from a single misread instruction. This is why serious agent deployments put hard boundaries around their tools — read-only by default, explicit approval for anything irreversible, and strict limits on how many steps an agent may run unsupervised.
Why it matters
AI agents are moving from demos to real workflows: customer support that can actually resolve tickets, coding assistants that can fix bugs end to end, research tools that can gather and synthesise sources. The promise is real, but so is the gap between a good demo and a reliable system. The demos usually show short, well-scaffolded tasks with clean tools. Production work is messier: ambiguous goals, unreliable tools, and long loops where errors compound.
If you are evaluating an agent — as a user, a buyer, or a builder — the questions that matter are practical, not philosophical. What tools does it have, and what can they actually change? What stops the loop when it goes wrong? Who approves the irreversible steps? The answers to those three questions tell you more about whether an agent will help or hurt than any benchmark score. Agents are not magic; they are language models with a loop and a set of tools. Understand the loop and the tools, and you understand the agent.
A VCTRIA evergreen guide.