Agent Washing: Why 95% of 'AI Agents' Are Just Expensive Chatbots

The Vendor's "Agent"

• Architecture: GPT-4 API call → pattern matching against decision tree → templated response
• Cost per query: $0.30 (token costs + platform markup)
• Latency: 45 seconds average
• Accuracy: ~60% (40% required human escalation)
• Monthly cost: ~$14,000 for 47,000 queries

Our Replacement

The vendor's "agent" never planned, never adapted, never pursued goals autonomously. It was a single LLM call wrapped in an orchestration layer. But by calling it an "agentic onboarding system," they justified a 300x price premium over what the actual task complexity required. This is the core damage of agent washing: it doesn't just waste money on overpriced chatbots—it poisons the well for genuine agentic AI by training organizations to expect disappointment. Teams that get burned by an agent-washed product become skeptical of all agent technology, including the real thing. For more on the common pitfalls that lead to this disillusionment, see our breakdown of the most common mistakes when building AI agents.

• Architecture: Fine-tuned Particula-Classify model → rule engine → direct response
• Cost per query: <$0.001
• Latency: 200ms
• Accuracy: 94% (6% escalation to humans)
• Monthly cost: ~$47 in compute

1. Goal Pursuit: Can It Pursue Multi-Step Objectives Autonomously?

A real agent takes a high-level goal ("resolve this customer dispute") and independently decomposes it into subtasks: check order history, verify policy terms, assess fraud probability, calculate refund amount, draft resolution, send to approval queue. It doesn't need re-prompting at each step. Red flag: The system requires a new human input or trigger for each step in the workflow.

2. Planning: Does It Plan Action Sequences Dynamically?

Genuine agents evaluate context and choose different execution paths based on conditions. A compliance agent facing a high-value dispute might pull additional transaction data before deciding, while routing a low-value case through an expedited path. Red flag: The system follows the same sequence regardless of input—that's a workflow, not an agent.

3. Tool Execution: Can It Use Diverse Tools Independently?

Real agents interact with external systems—calling APIs, querying databases, executing code, reading documents—based on what the task demands, not based on a pre-configured integration list. Red flag: The system only interacts with a fixed set of pre-configured integrations through predetermined actions.

4. Exception Handling: Does It Recover from Failures?

When a tool call fails, a real agent retries with different parameters, falls back to an alternative approach, or escalates with diagnostic context. Agent-washed products either crash, return an error, or silently ignore the failure. Red flag: Failures produce generic error messages or require human restart.

5. Operational Independence: Does It Work Without Constant Re-prompting?

Genuine agents maintain context across extended interactions and work continuously toward their goal. Chatbots reset with every message, treating each input as an isolated query. Red flag: The system has no memory of previous steps in the same task and treats every interaction as a fresh conversation.

The API Call Multiplier

A chatbot makes one LLM call per user request. A genuine agent makes 8-15 internal API calls to reason, plan, execute tools, evaluate results, and iterate. That 8-15x multiplier compounds through every layer of the stack:

• Token consumption: A 10-step agent with a 4,000-token system prompt and 500-token tool outputs consumes over 40,000 input tokens by the final step. The full conversation history gets sent with every iteration.
• Output token premium: Output tokens cost 3-8x more than input tokens across major providers. Agents generating verbose chain-of-thought reasoning pay this premium at every step.
• Context window growth: A 128,000-token context window costs 64x more than an 8,000-token window. Agents that accumulate context across steps hit this scaling wall fast.

Real Production Costs

Autonomous Decision-Making Under Uncertainty

Real agents make consequential decisions when the right answer isn't obvious. A compliance agent reviewing a flagged transaction doesn't just match it against rules—it weighs the customer's history, the transaction pattern, the regulatory context, and the risk tolerance of the organization, then chooses an action with probabilistic reasoning.

Multi-Step Planning with Self-Correction

Genuine agents create execution plans, monitor their own progress, and revise when things go wrong. When a tool call returns unexpected data, the agent doesn't just retry the same call—it reassesses whether the plan itself needs adjustment. We built a legal document processing agent for a client that had to analyze contracts, identify non-standard clauses, cross-reference them against precedent, and flag risks. When it encountered a clause type it hadn't seen before, it would expand its search parameters, check related regulatory documents, and explicitly mark the uncertainty level in its output—rather than confidently generating a wrong analysis.

Tool Orchestration Across Systems

The most capable agents connect to 5-10+ external systems and choose which tools to use based on the task at hand. They don't just call APIs—they reason about which information source is most relevant, what sequence of operations will be most efficient, and when to stop gathering data and start acting.

Production-Grade Observability

Real agent systems ship with built-in logging of every decision, every tool call, and every reasoning step. You can trace exactly why an agent chose a particular path, which matters for debugging, compliance, and continuous improvement. Agent-washed products are black boxes—you get input and output with nothing in between.

Start with Task Analysis, Not Technology

Before evaluating any agent product, map the actual decision complexity of your workflow. If every decision can be represented as a flowchart, you don't need an agent. If the workflow requires genuine judgment, contextual reasoning, and adaptation, agent technology may be justified.

Demand Live Demonstrations with Your Data

Agent-washed products look impressive on cherry-picked demos. Insist on running the product against your actual data, with your actual edge cases. Pay particular attention to how it handles exceptions, ambiguous inputs, and multi-step tasks that require plan revision.

Benchmark Against Simple Baselines

Before adopting any agent solution, build the simplest possible alternative: a classifier, a rule engine, a single LLM call with structured output. If the simple approach achieves 80%+ of the value at 1% of the cost, the "agent" isn't solving an agent-shaped problem.

Audit the Cost Structure

Ask vendors to break down cost per query into component parts: LLM API calls, tool executions, infrastructure. If they can't or won't, that's a signal. Legitimate agent providers understand their cost structure because it's an engineering constraint they've had to optimize around.

Build Incrementally

The most successful agent deployments we've seen start with narrow, high-value automation—one workflow, one decision type—and expand the agent's scope as it proves itself. Organizations that try to deploy "enterprise-wide agentic AI" end up in the 40% cancellation statistic.