AI, Actually

What an "AI Agent" Actually Is (And Why Most Things Called Agents Aren't)

Published November 05, 2026 — 4 min read

TL;DR: An agent is a model running in a loop, choosing its own tools and remembering what happened along the way. Most products sold as agents are a fixed script with a model inside, and knowing which one you have decides what you can safely hand it.

Key Insight

Strip the marketing off and an agent is three parts running in a cycle.

  1. Reasoning. The model looks at the goal and the current state and decides what to do next.
  2. Tool use. It acts on that decision by calling a search, an API, a database query, or a shell command.
  3. Memory. It reads the result, keeps what matters, and feeds it into the next decision.

It repeats until it decides the job is done or hits a limit. What makes it an agent is who picks the next step. Anthropic's engineering team draws the line in Building effective agents: workflows are systems where LLMs and tools are orchestrated through predefined code paths, while agents are systems where the LLM dynamically directs its own process and tool usage.

Under that definition, a pipeline that always runs "classify the email, look up the customer, draft a reply" is a workflow. It can be an excellent one. It is not an agent, because the model never decides what happens next. The code does.

Many things sold as agents should stay workflows, and they will be better for it. That's the contrarian part, and it's pro-AI.

Why Teams Miss This

The word got stretched because it sells. A chatbot with one tool call became an agent. A prompt chain became an agentic workflow. A nightly job that calls a model became an autonomous worker.

Teams then make one of two mistakes.

The first is buying an agent and expecting judgment. If the product is a fixed pipeline, it does exactly the steps it was given and fails quietly on anything outside them. That is fine for invoice routing. It is a nasty surprise when a team assumed it would handle exceptions the way a person would.

The second is the reverse. A team builds a true agent for a task with a known sequence, then spends months adding guardrails to stop it wandering. They paid for flexibility they never needed. Anthropic's own advice is to find the simplest solution possible and add complexity only when needed, because agentic systems often trade latency and cost for better task performance.

Picture two requests that both get called "agent projects." One is refund approvals: check the order, check the policy, approve or escalate. The steps never change, so a workflow with a model reading the messy customer message is the right build. The other is investigating why a nightly data job failed: the next step depends on what the last log line says. That one earns a loop.

How to Actually Do It

Run a three-question test on anything labeled an agent, whether you are buying it or building it.

  1. Who chooses the next step? If a developer's code path does, it is a workflow. If the model picks from available tools at runtime, it is an agent.
  2. Can it loop? Look for a stop condition and a step limit. If it runs once and returns, there is no loop.
  3. What does it remember between steps? A real agent carries tool results forward and acts on them. If every step starts cold, there is no memory in the sense that matters.

Here is the smallest honest agent. It is a loop, a tool list, and a message history.

def run_agent(goal, tools, llm, max_steps=8):
    history = [{"role": "user", "content": goal}]
    for _ in range(max_steps):
        reply = llm(history, tools=tools)
        history.append(reply.message)
        if not reply.tool_calls:
            return reply.text  # model decided it is done
        for call in reply.tool_calls:
            result = tools[call.name](**call.args)
            history.append({"role": "tool", "name": call.name, "content": result})
    return "Stopped: step limit reached"

Everything a framework adds sits on top of this. The max_steps line is the one people forget, and it is the cheapest safety control you have.

Then pick by task shape. Known steps, high volume, strict audit needs: build a workflow and let the model handle the fuzzy parts like extraction or drafting. Unknown steps, messy inputs, a path that depends on what you find along the way: that is where a real agent earns its cost.

What We've Learned

In enterprise deployments, the most reliable systems tend to be workflows with one or two agentic steps inside them. The loop gets a narrow job, a small tool set, a step cap, and a human checkpoint before anything irreversible.

Your next experiment is cheap. List every "agent" in production or on a vendor shortlist and ask the three questions of each. Relabel the ones that fail. Expect a lot of them to be workflows, which is good news, because workflows are easier to test, cheaper to run, and simpler to explain to a compliance team. Spend the agent budget where a model has to decide.

Sources

Have a specific workflow in mind?

Bring it to a Quick Scan — a live working session where we'll tell you honestly whether it should be an agent, a workflow, or left alone, before you spend a dollar building it. You get 3 prioritized recommendations on the call, a one-page summary after, and the $500 credited toward any engagement within 30 days.

Tell us what you'd hand off →

See AI Agent Consulting·Book an intro call

Get new posts + practical agent-ops notes

One email when something new goes up. No nurture sequence, no spam — unsubscribe whenever you want.

Thanks — you're on the list.