What Makes Something an Agent

Every leader has now seen generative AI answer a question, draft an email, or summarize a document. That is AI that talks. An agent is the next step: AI that does.

The distinction is simple and strategic. A generative-AI chat assistant responds to a single prompt and stops. An agent is given a goal — "resolve this customer's refund," "research these five suppliers and draft a comparison," "reconcile this batch of invoices" — and then, on its own, plans the steps, uses tools to act on real systems, observes what happened, and iterates until the job is done or it reaches a boundary you set.

An agent pursues a goal, not just a prompt. That is the entire leap from "AI that talks" to "AI that does."

Why this matters in the boardroom: the moment software starts taking actions in your systems — issuing a refund, updating a CRM record, sending an email to a customer — it stops being a productivity feature and becomes something you must govern, because it now has consequences. A chatbot that gives a wrong answer wastes a minute. An agent that takes a wrong action moves money, touches a customer, or changes a record. Same underlying model; a categorically different risk and value profile.

Keep the rest of this module's framing in view: this lesson defines what an agent is; the next lessons sharpen who is steering (chatbot vs. copilot vs. agent) and why agents are framed as the next value wave. Get the definition right first — most strategic mistakes here start with a fuzzy one.

You do not need to know how an agent is engineered. You do need a mental model clear enough to ask good questions. The most useful executive-friendly framing comes from Anthropic: an agent is built from four components, each of which is both a capability and an oversight point.

The power of this view is that it turns a vague "AI agent" into four concrete things you can interrogate. Notice that the Model is just one of the four — a common executive error is to obsess over which model a vendor uses, when the Tools (what it can do) and Planning (how it behaves when things go wrong) usually carry more of the real-world risk.

A subtle but important point: the generative-AI model is a component inside the agent, not the agent itself. The agent is the surrounding system — the loop that plans, calls tools, remembers, and iterates — and it uses a GenAI model as one of its tools (for example, to write the customer-facing text). This is why the nesting hierarchy puts agents as the action layer that sits on top of GenAI, not beside it.

The word "agent" is now a marketing magnet. Vendors are rebranding ordinary chatbots, scripted automation (RPA), and simple assistants as "agentic" to ride the wave — a practice analysts call "agent washing." As of 2025, Gartner estimated that of the thousands of vendors describing themselves as agentic, only about 130 were genuine, and predicted that more than 40% of agentic-AI projects would be canceled by the end of 2027 (citing cost, unclear value, and weak risk controls). Treat those figures as time-stamped — re-verify the live source before quoting them — but treat the pattern as durable.

Gartner's framing gives you a clean three-part test. A real agent has all three:

1. Autonomous reasoning — it decomposes a goal into steps and adapts when a step fails, rather than following a fixed script.
2. Tool orchestration — it calls APIs, databases, and other systems to actually do things, not just talk.
3. Persistent context — it remembers the ongoing project and relevant organizational knowledge across steps.

If a product can only respond to prompts with no ability to act, it is a chatbot. If it follows a rigid, pre-scripted sequence with no adaptation, it is automation (RPA) wearing a new label. If it lacks memory of the task, it is a stateless assistant. Real agency requires the combination.

If you remember a single idea from this lesson, make it this: autonomy is the strategic dial. Autonomy is how much the system decides and acts without a human in the loop — and that single setting determines the value it can create, the risk it carries, and the governance it requires. All three move together as you turn the dial up.

• Low autonomy — the system suggests; a human approves and executes every step. Lower value per task, but the human is a built-in safety check. (This is the copilot zone, covered in the next lesson.)
• High autonomy — the system plans and executes a whole workflow end-to-end, escalating to a human only at boundaries. Higher value (it does the whole job), but the blast radius of an error grows, and you need real guardrails.

This is why the same underlying technology can be a low-stakes convenience or a board-level risk depending purely on how much you let it act. The governance principle that follows is durable: automation for execution, humans for judgment.

A practical rule of thumb — the delegation test: delegate a decision to an agent only when (1) the data is clear, (2) the rules are well defined, and (3) the cost of waiting for a human exceeds the cost of a wrong autonomous action. Refund a £15 shipping fee on a clear-cut policy? Delegate it. Deny a large insurance claim, approve credit, or terminate an account? The cost of being wrong is high and the judgment is nuanced — keep a human on the loop.

The current reality (2025–2026) reinforces caution: production agents today "tend to be simple and human-supervised" (Anthropic), are reliable for narrow, well-structured, lower-stakes tasks, and do not learn on the job by default — errors can compound over long chains of action, which is exactly why responsible deployments keep scope tight and a human nearby.

Abstractions land when you trace one through a real task. Imagine a refund agent in a retail business. A customer messages: "My order arrived damaged — I'd like a refund." Here is the loop, mapped to the four building blocks:

1. Understand the goal (Planning). The agent's objective is resolve this refund within policy. It breaks that into sub-steps: verify the order, check eligibility, decide, execute, and communicate.
2. Gather the facts (Tools + Memory). It queries the order-management system for the purchase, checks the returns policy, and pulls the customer's history — remembering all of this as it works through the case.
3. Decide (Model). Using its reasoning engine, it determines the order qualifies under policy and the refund amount is within the threshold it's allowed to approve autonomously.
4. Act (Tools). It issues the refund through the payments system and updates the case record. These are real actions on real systems — the moment governance matters.
5. Communicate (Model as a tool). It calls a generative-AI model to write a warm, on-brand confirmation email — here the GenAI model is one tool the agent uses, not the agent itself.
6. Iterate or escalate (Planning). If the refund exceeds its approval limit, the policy is ambiguous, or a system call fails, it stops and escalates to a human rather than guessing.

Notice three things. First, the GenAI model appears inside the agent (steps 3 and 5) — confirming that an agent uses models, it is not merely a model. Second, the value is that the whole task gets done, not just drafted. Third, the governance lives at the action and escalation points: the approval threshold, the permission to touch the payments system, and the human-escalation boundary are exactly the dials you, as a leader, must set.

This is also a deliberately bounded, supervised, lower-stakes design — small refunds, clear policy, human escalation for edge cases — which is precisely the kind of agent that works reliably today.

You now have everything you need to interrogate any agentic proposal — from a vendor pitch or an internal team — without a single line of code. Run it through these questions, organized by the frameworks in this lesson.

Is it really an agent? (the anti-washing test)

• Can it reason and adapt when a step fails, or does it break off the happy path?
• Does it act on real systems (orchestrate tools), or only talk?
• Does it remember the task across steps?

What is it made of? (the four blocks)

• Which model, and where is it likely to be confidently wrong on our task?
• Which tools/permissions — what exactly can it touch, and what is the blast radius?
• What memory does it keep, where is it stored, and who can see it?
• How does its planning recover from failure, and where does it escalate?

How autonomous is it? (the strategic dial)

• What is the most consequential action it can take without a human?
• Does it pass the delegation test (clear data, defined rules, cost-of-waiting > cost-of-error)?
• Can we halt and roll back if it goes wrong, and who is the named owner?

If a proposal can't answer these crisply, that is your signal — not to say no automatically, but to slow down until the answers exist. Most failed agent projects failed because nobody asked these before the money was spent.