What is an AI agent? Definition, examples and limits

#What is an AI agent?

The most useful definition fits in one sentence: an agent is a language model that uses tools in a loop. You give it a goal, such as “find out why this test fails and fix it.” It reads the code, runs the test, reads the error, modifies a file, reruns the test, and continues until the test passes or it gives up. No one wrote this sequence in advance: the model decides it step by step, based on what it observes.

The term is a victim of its own success. Many products marketed as “agents” are simply chatbots with a name, or conventional automations in which a model writes text at a fixed step in a script. The decisive question is: who decides what happens next? If it is a predefined program with a fixed sequence of calls, it is not an agent, even if a language model is involved somewhere in the chain.

#Chatbot, workflow, agent: the differences

This is the distinction Anthropic draws in its design guide: “workflows are systems where LLMs and tools are orchestrated through predefined code paths,” whereas “agents are systems where LLMs dynamically direct their own processes and tool use, retaining control over how tasks are accomplished.” The resulting advice applies to everyone: find the simplest solution possible, and increase complexity only when necessary. A well-designed workflow beats an agent for most business needs because it is predictable and inexpensive.

• “Building effective agents,” Anthropic's design guide

#The four parts of an agent

A model

The brain. It must reason through multiple steps and produce well-formed tool calls. It is the component that limits everything else.

Tools

Functions the model can call: read and write files, execute a command, search the web, query a database. The MCP protocol has become the standard way to connect them.

A loop

The program that chains everything together: send the context to the model, run the requested tool, add the result to the context, and repeat. It also sets the guardrails: maximum number of steps, confirmations, and budget.

One memory

In the short term, the context window, which fills up at every step and eventually saturates on a long task. In the long term, note files, a compressed summary of past steps, or a database that the agent rereads from one session to the next, so it does not have to start from scratch with every new conversation.

• MCP: the protocol that connects tools to models

#The mechanism behind the loop: ReAct

Most production agents follow, without naming it, the pattern described in 2022 by researchers from Google and Princeton under the name ReAct (“Reasoning and Acting”). At each turn, the model produces explicit reasoning (Thought), chooses an action, usually a tool call (Action), and then receives the result (Observation) before starting over. Making the reasoning explicit before the action makes the agent easier to debug: you can see why it chose a given tool, not just what it did.

• Source: the research paper “ReAct: Synergizing Reasoning and Acting in Language Models”

#Examples that actually work

Code agents

The most advanced use case. Claude Code, Cline, OpenCode, or Aider read a repository, modify multiple files, run tests, and fix their errors. The domain is well suited to this: the result can be verified automatically by whether a test passes.

Research agents

They launch dozens of searches, read the pages, cross-check sources, and write a summary. Useful for monitoring or a state-of-the-art review, provided you verify the citations.

Operations agents

They monitor logs, diagnose incidents, and propose or apply fixes. In production, almost always with human validation before any action.

Desktop agents

They control a browser or computer with the mouse and keyboard. Impressive demonstrations, but reliability is still insufficient for unsupervised use.

What these successful cases have in common is an objective success criterion that is quick to verify. A test that passes or fails, a well-formed file, an incident resolved or not. Where success depends on vague human judgment, such as “write a convincing marketing strategy,” an agent loop adds little compared with a simple back-and-forth with the model, because there is nothing objective to observe between steps to guide the next one.

#Why agents fail

The first reason is arithmetic. In a loop, errors multiply instead of canceling out. A model that is 95% reliable at each individual step completes a ten-step task correctly in only 60% of cases, and a twenty-step task in barely 36% of cases, even though no individual step is outright bad.

That's why agents succeed where they can verify themselves, for example by rerunning a test, and disappoint elsewhere. The other limitations follow from this: cost, since a task consumes dozens of calls and an ever-growing context; security, since an agent that reads external content can be manipulated by that content; and drift, when the agent diligently pursues a poorly understood objective.

The METR evaluation lab measures this progress with a metric called the “time horizon”: the length of a human task that the best current model can complete with a 50% success rate. According to METR, this duration has followed an exponential trend with a doubling time of about seven months since 2019, and METR measured an acceleration to just over four months since 2023. In practical terms, an agent that failed a one-hour task a year ago has a good chance of succeeding today; the boundary moves, but it does not disappear.

• Source: METR, “Measuring AI Ability to Complete Long Tasks”

#A local AI agent: what you need

Nothing requires an agent to use the cloud. The loop and tools already run on your machine; you just need to run the model that controls them there as well. Three requirements are stricter than for a simple chat, where you can make do with a smaller, slower model.

In practice, a 16 GB card supports a useful agent for short tasks, while 24 GB provides plenty of headroom. Below that, the agent works as a demo and disappoints in daily use.

One often-overlooked point: the cost of a local agent is not limited to the model weights’ VRAM. Each connected tool adds its description to the prompt on every turn, and that description also consumes KV cache—and therefore VRAM—for the entire loop. With a 14-billion-parameter model and half a dozen well-described tools, expect a few hundred megabytes of KV cache just for the tool definitions, before accounting for the conversation context.

• Ranking: the best local LLMs for agents
• Create a local AI agent: recommended architecture and tools
• Tutorial: a local Python agent with LangChain and Ollama

#Where to start

1. 01
   Use an existing agent before building one

   A coding agent in your editor or terminal will teach you in one week what these systems can do and where they stumble.
2. 02
   Choose a verifiable task

   A task whose success can be measured without you: a test that passes, a file produced in the correct format, a total that comes out right.
3. 03
   Limit the tools

   Three well-described tools are better than thirty. Each tool you add increases the risk of poor choices and makes the context heavier.
4. 04
   Keep control over what is irreversible

   Read freely, write with confirmation. Email sending, file deletion, payments, publishing: always require explicit human approval before execution, regardless of the confidence displayed by the agent.

• OpenCode + Ollama: a coding agent in the terminal
• Cline + Ollama: a coding agent in VS Code
• The local Agents kit

#FAQ