· Platform AX · about 9 min read
What is an AI agent?
‘AI agent’ gets attached to everything. Chatbots are called agents, automation scripts are called agents, and systems that work alone for days are called agents too. The wider the word gets, the less clear it becomes what to build and what to buy. In this piece we define AI agents both by what the word means and by how they are built, and set out what to weigh when you bring one into your work.
A one-sentence definition
An AI agent is a system that, to reach a goal it has been delegated, perceives its environment, decides its next action itself, and changes the environment with tools, repeating this until the goal is reached.
In practice we say it more briefly.
Agent =
The keys to this definition are two words: "delegation" and "repetition". Let's take them one at a time.
What the word means: an agent acts on someone's behalf
Agent comes from the Latin agere, "to do". So its first meaning is one who acts. In law and economics, though, an agent is someone who acts on another person's behalf, carrying out their goals. Think of a real estate agent or a sports agent.
To understand AI agents for work, this second meaning matters more. An AI agent acts on a person's behalf, doing the work they have delegated to it.
The 'principal–agent problem' in economics deals with the classic difficulties of using a human agent. Those difficulties show up almost unchanged with AI agents. Below are the three parts of the agency problem, plus accountability, which needs particular attention with AI agents.
| Agency problem | Meaning | With AI agents | What it calls for |
|---|---|---|---|
| Information asymmetry | You don't know what the agent did. | You can't see which tools it called, or why. | Execution records and audit logs |
| Goal misalignment | The agent pursues a different goal. | It misreads instructions or falls for malicious input. | Guardrails and input validation |
| Monitoring cost | If you check everything, there was no point delegating. | If a person approves every action, it isn't automation. | Approval by risk level |
| Accountability (added) | The question of who answers for the result. | Accountability stays with the person and organization that delegated. | A delegation-of-authority model |
In the end, designing an agent is less about building a smart AI than about designing how work is handed over and how it is controlled.
How academia has defined agents
The agent is a much older idea than generative AI.
- Russell & Norvig (Artificial Intelligence: A Modern Approach): anything that perceives its environment through sensors and acts on it through actuators. The definition is so broad that even a thermostat can count as an agent.
- Franklin & Graesser (1996): an autonomous system that, within an environment, pursues its own goals over time and acts so as to affect what it will perceive next. Time and a feedback loop are added.
- Wooldridge & Jennings (1995): proposed four properties of an agent, which are still often cited.
Here are the four properties and how they show up in LLM agents.
| Property | Meaning | In LLM agents |
|---|---|---|
| Autonomy | Acts without a person stepping in every time. | The model chooses its next action itself. |
| Reactivity | Perceives changes in the environment and responds. | It reads tool results and revises its plan. |
| Pro-activeness | Moves toward its goal on its own initiative. | It breaks the goal into subtasks and carries them out. |
| Social ability | Communicates with people and other agents. | It asks the user questions and works with other agents. |
The generative AI definition: "who decides the flow?"
On the generative AI side, Anthropic's distinction between workflows and agents is widely used. The test is one question: who decides the flow of the work?
Workflow
A developer sets the path in code in advance, and the LLM handles only each step.
Agent
While it runs, the LLM decides for itself which tools to use and what to do next.
Even with the same LLM, this one difference changes the nature of the system completely.
Not 'is or isn't' but 'how much'
Rather than asking "is this an agent?", it is more accurate to ask "how agentic is it?"
In this piece we split it into six levels by who decides the flow. This is not a recognized classification but a distinction we use for explanation.
| Level | Form | Who decides the flow | Example |
|---|---|---|---|
| L0 | A single LLM call | Developer | Summarizing, translating |
| L1 | Augmented LLM (one search or tool call) | Developer | Q&A over company documents |
| L2 | Workflow | Developer (fixed path) | Sort mail → draft a reply → review |
| L3 | Tool-using agent | Model | "Fix this error" → explore, edit, test, repeat |
| L4 | Multi-agent | Model (including splitting and delegating the work) | A lead agent divides the work among sub-agents |
| L5 | Long-running autonomous agent | Model (including part of the goal) | An operations agent that runs for days |
A higher level is not always better. Much business automation is fine at L2 workflows, and those are cheaper, more predictable and easier to fix. Agents (L3 and above) are for work where you can't know the number of steps or the path in advance.
When you first check whether a workflow can solve the problem, five common patterns are worth considering.
- Chaining: connect steps in order, with checks in between.
- Routing: classify the input and send it to the right handler.
- Parallelization: split the work and run it at once, or run it several times and vote.
- Orchestrator–workers: a central LLM divides the work and hands it out.
- Evaluator–optimizer: build, evaluate, fix, and repeat.
How it's built: what an agent is made of
The skeleton every agent shares: the loop
Even agent products that look elaborate run the same loop inside. Starting from a conversation that holds the instructions and the user's goal, they repeat the following.
- Think and decide: the LLM looks at the conversation so far and the tools it can use, and decides what to do next.
- Decide whether to stop: if the response is complete, it returns the result and ends.
- Wait for a person's approval if one is needed: this is a guardrail.
- Act: it runs the tool call the model chose.
- Add the observation to memory: it appends the result to the conversation and goes back to 1.
- Stop if the budget is exceeded: this is a safety measure.
- ThinkDecides what to do next
- ActRuns the tool call
- ObserveAdds the result to the conversation
Think → act → observe → think again. This pattern is called ReAct (Reason + Act), and it is often cited as the prototype of modern agents. What differs between products is not the loop itself but what sits around it: which tools it is given, what it is shown, and what it is blocked from doing.
Seven components
What each component does, and what to look at when designing it.
| Component | What it does | What to look at in design |
|---|---|---|
| Model | Handles reasoning, planning and decisions. | Use different models for tasks of different difficulty. |
| Instructions | Set the role, rules and procedures. | Keep them short and clear; load long procedures only when needed. |
| Tools | Act on the environment through APIs, databases, files and browsers. | The tool descriptions are the agent's user interface. |
| Memory | Keeps state (short-term in the conversation context, long-term in files or a database). | You have to decide what to remember and what to drop. |
| Execution environment | Where the tools actually run. | Look at isolation (sandboxing) and rollback. |
| Guardrails | Limit permissions, approvals and budget. | Vary the level of approval by risk. |
| Observation and evaluation | Measure execution traces, cost and quality. | Evaluate the process, not just the result. |
Four ideas you need to know
① Context engineering. Agent performance depends heavily on what you show the model. The amount a model can see at once (its context window) is finite, and the model's focus drops as the context gets longer. So you summarize older conversation, write important things down in files, and have it look up information when it needs it instead of loading everything up front.
② Tool design. Just as good screens matter for people, a tool's name, description, input format and error messages are the screen for an agent. A few well-designed tools beat dozens of rough ones.
③ Standard protocols: MCP and A2A. The two connect different things.
| Protocol | What it connects | Analogy |
|---|---|---|
| MCP (Model Context Protocol) | Connects agents to tools and data. | USB-C for AI |
| A2A (Agent2Agent) | Connects agents to agents. | A phone network between agents |
In companies, wrapping internal systems (ERP, groupware, databases) in MCP to connect them to agents is becoming more common.
④ Multi-agent. A hierarchical structure, where a lead agent divides the work and hands it to sub-agents, is common. It can split context across agents and work in parallel, but cost multiplies and information can be lost in the handovers. Most work is fine with a single agent and good tools.
How it differs from similar things
Side by side by who decides, input, path, and what failure looks like:
| Type | Who decides | Input | Path | When it fails |
|---|---|---|---|---|
| RPA | Rules written by people | Structured | Fixed | It stops, so you notice. |
| Workflow automation | Rules | Structured | Fixed | Predictable. |
| Chatbot | LLM | Unstructured | One conversation | It gives a wrong answer. |
| Copilot | Person (final decision) | Unstructured | Led by a person | A person catches it. |
| AI agent | LLM | Unstructured | Dynamic | It is plausibly wrong. |
An agent's strength is that it handles unstructured input and gets through work whose path can't be known in advance. Its weakness is that its failures are quiet and plausible. When you bring one into your work, how you deal with this weakness is the heart of it.
What to weigh before bringing it into your work
Errors multiply
If an agent succeeds at each step 95% of the time and does a 20-step task, its overall success rate is 0.95²⁰, about 36%. Even at 99% per step, 20 steps give about 82%.
about 82%99% per step
about 36%95% per step
So an agent for work needs fewer steps, intermediate results that can be checked, and the ability to detect failure and roll back.
Seven layers an agent for work needs
- Connection: connectors to internal systems, and authentication that inherits the user's own permissions
- Execution: the agent loop, an isolated execution environment, and pausing and resuming long-running tasks
- Knowledge: search over company documents, the organization's working memory, and work procedures
- Control: least privilege, approval by risk level (lookups automatic; sending, payment and deletion need approval), and audit logs
- Security: defense against malicious input (prompt injection). In particular, keep three things from coming together in one agent: access to sensitive data, untrusted input from outside, and a way to send things out (the combination Simon Willison called the ‘lethal trifecta’ in 2025).
- Observation and evaluation: execution traces, cost and speed measurement, regression tests, and human feedback
- User experience: seeing progress, stepping in midway, and reviewing results
Five common misconceptions
- "If the model is smart, everything works." Success is decided less by the model than by tools, context and evaluation.
- "Multi-agent is better." It costs several times more and is several times more complex. If one agent can do it, use one.
- "Full autonomy is the goal." In work, the goal is the ‘right’ amount of autonomy. Build trust in order: suggest → act after approval → act automatically.
- "Pick a framework first." At the start, it's better to learn the principles by writing the API calls and the loop yourself.
- "If the demo works, the product works." There is a gap between a success rate good enough for a demo and one good enough to put to work. Closing that gap often takes a good share of the development time, and it can't be closed without an evaluation system.
To close: three lines
- By meaning, an AI agent acts on a person's behalf to carry out a goal they have handed over. So designing delegation, control and accountability is the essence.
- By technology, an AI agent is a system in which an LLM repeatedly runs tools and decides the flow of work itself. Performance is set by the model, the tools and context management together.
- By work, the value comes not from one smart agent but from a foundation where agents are safely connected, controlled and measured.
Takeaway
In the age of agents, the edge will come less from ‘which AI you use’ than from ‘how you hand work to AI’.