Agent Washing (2026): How to Tell a Real AI Agent From a Rebranded Chatbot

TL;DR: Agent washing is the 2026 practice of slapping "agentic AI" onto products that are really chatbots, RPA scripts, or last year's assistants — a label change without an autonomy change. Gartner, which coined the term, estimates that of the thousands of vendors claiming agentic AI, only a small fraction ship anything genuinely agentic, and predicts over 40% of agentic AI projects will be canceled by the end of 2027 — largely because buyers bought the label, not the capability. The tell isn't in the demo; it's in the architecture. A real agent plans its own steps, chooses and calls tools, adapts when a step fails, and carries state across the task — under governed autonomy. A washed one follows a script you can draw as a flowchart. This guide gives you the six tells, a five-level autonomy rubric to score any product, and ten questions that separate an agent from a decision tree in a nicer coat.

What "agent washing" actually means

The pattern rhymes with greenwashing: take an existing thing, wrap it in the market's most-wanted label, sell it at the new label's premium. In 2025–2026 that label is agentic. Analysts at Gartner named the behavior agent washing — the rebranding of chatbots, robotic process automation, virtual assistants, and rules engines as "AI agents" without adding the capabilities the word implies.

It works because the word agent has no enforced definition. There's no certification body, no spec you must pass, no UL sticker. A vendor can call a FAQ bot an "autonomous support agent" and a scheduled Zapier flow an "agentic workflow," and nothing but a careful buyer stops them. The result is a market where the word appears on almost everything and means almost nothing — which is precisely why the buyer's job shifted from "does it do AI?" to "is there an agent in here at all?"

This matters commercially, not just semantically. Gartner's mid-2025 analysis put the number of vendors genuinely delivering agentic AI at roughly 130 out of thousands claiming it, and forecast that more than 40% of agentic AI projects will be scrapped by the end of 2027 on escalating costs, unclear value, and weak risk controls. A separate, widely-cited 2025 MIT study of enterprise GenAI found the overwhelming majority of pilots delivering no measurable P&L impact. Read those two findings together and the cause is visible: a lot of "agent" projects were never scoped around an actual agent. They were chatbots with a board-deck title, and they failed the way chatbots fail when you ask them to do an agent's job.

The cost of agent washing isn't embarrassment. It's a six-figure deployment that stalls in month three because the "agent" can't do the one thing you bought it for: finish a multi-step task without a human driving every step.

Why vendors do it (and why it's often not a lie, exactly)

Three forces push otherwise honest vendors toward the label:

1. The premium. "Agentic AI" commands budget that "chatbot" and "RPA" no longer do. The same product sold as an agent lands a bigger deal and a strategic buyer instead of a tooling buyer.
2. The roadmap defense. Many products are on a path toward autonomy — a copilot today, a semi-autonomous agent next year. Vendors describe the destination as if it's the current stop. It's not always deception; it's often a roadmap narrated in the present tense.
3. The definition vacuum. Because nobody agrees where "smart automation" ends and "agent" begins, every vendor draws the line just below their own product. A rules engine with an LLM writing the final message genuinely feels agentic to the team that built it.

None of this helps you. Whether the gap between the label and the capability is a lie or a hope, you are the one who deploys it, and you inherit the gap. So evaluate the artifact in front of you, not the story around it.

The spectrum: where the line actually sits

The useful mental model isn't "agent vs. not-agent" — it's a spectrum of autonomy, and agent washing is the act of claiming a higher rung than the product stands on. Four rungs, from least to most autonomous:

The load-bearing column is the third one: who decides the steps. In everything below "agent," a human decided the path ahead of time and the software walks it. In an agent, the software decides the path while running, in response to what it finds. That single property — runtime planning over a goal, not design-time scripting of a path — is the thing agent washing hides. Anthropic makes the same cut in its widely-referenced Building Effective Agents: workflows run LLMs through predefined code paths; agents dynamically direct their own process and tool use. Most "agents" on the market are workflows wearing the word.

None of the lower rungs are bad. A well-built chatbot or RPA flow is often the right tool — cheaper, more predictable, easier to govern. The problem is never that a product is a chatbot. The problem is a chatbot sold and scoped as an agent, priced like one, and expected to do an agent's job.

The six tells of a washed agent

You will not catch agent washing in a scripted demo — demos are the one path the vendor has rehearsed. You catch it by probing the architecture and the edges. Six reliable tells:

1. You can draw it as a flowchart

Ask the vendor to whiteboard how the "agent" handles a request. If the answer is a clean decision tree — if intent is X, do A; else do B — you're looking at a workflow, not an agent. A real agent's control flow can't be fully drawn in advance, because the model chooses the next step at runtime based on intermediate results. "We can't draw every path because it depends on what it finds" is the good answer here.

2. It breaks the moment you go off-script

Push one step past the happy path. Give it a request that needs two tools it wasn't demoed with, or an input the demo never showed. A washed agent stalls, loops, or hands off to a human instantly — because there was no plan underneath, only a script, and you just stepped off it. A real agent reasons about the novel case, even if imperfectly, and can explain what it tried.

3. It has no tools — or exactly one

Agency shows up as tool use: the software reaching out to CRMs, databases, browsers, APIs, and code execution to change the world, not just describe it. A "sales agent" that only drafts text and can't look anything up or take an action is a copywriter. Ask: what can it actually do besides talk? Count the tools. Zero or one is a chatbot tell.

4. It can't remember anything

Real multi-step work needs memory — state that persists across the steps of a task and, ideally, across sessions. If every interaction starts from zero and the "agent" can't say what it did five minutes ago or resume a task it paused, there's no continuous actor there, just stateless request-response with a friendly name.

5. There's no failure story

Ask: what happens when a step fails? The washed answer is silence or "it escalates to a human." The real answer describes error handling and retry logic — the agent notices the failure, tries an alternative, and only escalates when it's genuinely stuck. Autonomy is mostly about what happens on the unhappy path; scripts have no unhappy path, only a dead end.

6. The autonomy is all in the future tense

Listen to the verbs. "It will be able to," "on our roadmap," "in the next release" — the autonomy you're buying keeps sliding into the future while the price stays in the present. Buy the product that exists today. Roadmaps are not deliverables.

Any one tell can have an innocent explanation. Three or more, and you're almost certainly looking at a washed agent — reframe the deal (and the price) around what it actually is.

The levels-of-autonomy rubric: score it, don't vibe it

To make this repeatable across vendors, score every product on a five-level autonomy scale — the agent analog of SAE's self-driving levels. Ask which level the product operates at today, in production, for your use case — not in a demo, not on the roadmap.

Two rules make the rubric bite:

• The honest floor is L2. Below it — L0 and L1 — calling the product an "agent" is agent washing. A copilot is a fine thing to buy; it is not an agent, and it should not be priced or scoped as one.
• Most real production agents live at L2–L3, and that's correct. Beware the vendor claiming L4 for a high-stakes workflow. Full autonomy is appropriate for low-stakes, reversible tasks; for anything touching money, contracts, or customers, human-in-the-loop supervision at L2–L3 is the responsible design, not a limitation. A vendor promising unsupervised L4 for your accounts-payable run is either washing or reckless.

Write the claimed level in the contract's success criteria. "Operates at L3 for tier-1 support tickets, measured over a 30-day pilot" is testable. "Agentic" is not.

Ten questions that stop the bluffing

Bring these to the evaluation call. Vague or future-tense answers are the tell.

1. "Show me a task the agent completed end-to-end that you didn't script in advance." — Watch whether they can produce one that isn't the demo.
2. "Draw the control flow. Can you enumerate every path?" — If yes, it's a workflow.
3. "What tools can it call, and which ones take real actions vs. just read?" — Count them; separate read-only from write.
4. "What happens when a tool call fails mid-task?" — Listen for real recovery, not "it escalates."
5. "Does it keep state across steps and across sessions? Show me it resuming a paused task."
6. "What autonomy level does it run at in production today, for a use case like mine?" — Force an L0–L4 answer.
7. "Where's the human-in-the-loop checkpoint, and can I configure it per action type?"
8. "What did it get wrong in your other deployments, and how did you catch it?" — No failures cited = no real deployments, or no observability.
9. "Can I see a production trace — the actual reasoning, tool calls, and retries for one real task?"
10. "If I turn off the LLM, how much of this still works?" — If most of it does, you're buying RPA with an LLM garnish.

Question 10 is the quiet killer. A genuine agent collapses without the model, because the model is the planner. A washed one keeps running its script and only loses the wordsmithing.

When a "washed" product is actually the right buy

Flip the frame before you walk away. Agent washing is a labeling problem, not always a product problem. If a vendor sells you an L0 workflow but your task is genuinely deterministic — a fixed sequence with clear rules and no ambiguity — then the workflow is the correct, cheaper, more governable tool. The right call is to buy it as what it is, at a workflow price, with workflow expectations.

The failure mode isn't buying a chatbot. It's buying a chatbot's architecture to solve an agent's problem — a task with real ambiguity, changing conditions, and multi-step recovery — and then wondering why it stalls. Match the rung to the job:

• Deterministic, high-volume, rules are stable → workflow / RPA (L0). Don't overpay for autonomy you won't use.
• A human should stay in the driver's seat → copilot (L1). Great for drafting, diagnosis, and high-stakes judgment.
• Multi-step, ambiguous, needs runtime decisions and recovery → a real agent (L2–L3). This is the only case where the "agent" premium is justified.

So the due-diligence question isn't only "is this real?" It's "is the level of autonomy I'm paying for the level my task needs?" Both directions of mismatch cost money — overpaying for unusable L4, or buying L0 for an L3 problem and watching it fail.

The buyer's field guide, in one page

• Agent washing = the "agentic AI" label on a product that plans none of its own steps. It's the year's defining buyer risk, and the reason Gartner expects >40% of agentic projects to be canceled by 2027.
• The one property that defines an agent: it decides its steps at runtime over a goal, versus a script deciding them at design time. Everything else follows from that.
• The six tells: you can flowchart it; it breaks off-script; it has ~no tools; no memory; no failure story; the autonomy is all future-tense.
• Score, don't vibe: put every product on the L0–L4 autonomy rubric. The honest floor for "agent" is L2. Most real agents live at L2–L3 — and should.
• Ten questions turn a scripted demo into a real evaluation; question 10 ("turn off the LLM — what survives?") is the fastest tell.
• Match the rung to the job. A workflow bought as a workflow is a good deal. A workflow bought as an agent is a canceled project.

The label is free; the capability isn't. Evaluate the artifact, not the adjective — and you'll be in the minority of buyers whose agentic AI project is still running in 2027.

---

Related reading: AI Support Agent vs Chatbot · AI Agents vs Workflow Automation · AI Agent vs RPA: Key Differences · How to Choose an AI Agent Platform (2026) · How to Measure AI Agent ROI · Human-in-the-Loop AI Agents

Primary sources: Gartner, Over 40% of Agentic AI Projects Will Be Canceled by End of 2027 (press release, June 2025); Anthropic, Building Effective Agents (workflows vs. agents).