Seeing Through Agent Washing: How to Screen Pseudo-Agent Projects

When "Agentic AI" becomes a catch-all prefix for fundraising and launch events, a more subtle problem surfaces: is what you're looking at really an agent that can make autonomous decisions and take actions, or just a chatbot in new packaging? The cross-fire debate between two guests on the Chain of Thought podcast happens to provide a set of coordinates for making that judgment.

One market, two narratives

On episode 15, Kelly Vaughn of Spot AI came right out and called agentic AI a bubble, questioning the me-too narrative of "agentic AI for X" — including the flood of near-identical AI meeting-notes tools. She argued that noise, thin differentiation, and an obsession with being "first" are mass-producing failed companies.

Six weeks later, on episode 21, Siva Surendira of Lyzr offered the opposite verdict: agent adoption is moving far faster than expected and has already gone mainstream, like cloud and databases. He admitted even he hadn't anticipated this round would explode so violently.

The two claims are not mutually exclusive. A tool category can be widely adopted while a large batch of projects flying the "agent" flag have no real agentic capability whatsoever. Broad adoption and overhyped proposals can both be true at the same time.

Agentic AI differs from ordinary generative AI in two key respects: autonomy and the ability to act. Generative AI is typically passive and reactive: the user enters a prompt, and the model returns text or images. Agentic AI, by contrast, is expected to break down goals, plan multi-step tasks, call external tools or APIs, adjust strategy based on intermediate results, and complete end-to-end processes with minimal human intervention. The industry usually distinguishes the two along several dimensions: whether it can decompose goals and plan, whether it can autonomously call tools to take actions, whether it maintains memory state across steps, and whether it retries or reroutes on its own when it hits an anomaly. It is precisely these capability thresholds that lead Gartner to conclude that of the thousands of vendors claiming to be agentic, only about 130 truly qualify — most products simply wrap a single model call and call it an "agent." Understanding this dividing line is the prerequisite for judging agent washing.

Cross-validating with external data

The views from two podcast episodes alone aren't enough to support a judgment; third-party data is needed for cross-validation.

According to a Gartner forecast from June 2025, more than 40% of agentic AI projects will be canceled by the end of 2027, with the reasons clustering around rising costs, unclear business value, and inadequate risk controls. Gartner estimates that of the thousands of vendors marketing agentic AI, only about 130 possess genuine agentic capability. It explicitly names the failure mode: relabeling existing assistants, RPA scripts, and chatbots without any substantive agentic capability — that is "agent washing."

Another set of data supports Surendira's adoption thesis. Microsoft and LinkedIn's 2024 Work Trend Index shows that 75% of knowledge workers already use generative AI at work. Heavy usage and a wave of failed projects coexist — and that is not a contradiction.

The right way to read these numbers is as a filter, not as a projection for a fundraising pitch. A cancellation rate above 40% means any proposal needs to show why it belongs to the surviving half — and "everyone is using AI" is not a reason.

Agent washing is a term coined by analogy with "greenwashing." It refers to vendors relabeling existing assistants, chatbots, or RPA (robotic process automation) scripts as "agents" without adding any substantive autonomous decision-making or action capability. Typical hallmarks include: interaction that is still one-question-one-answer, actions still executed by preset scripts, no goal-planning layer, and error handling that depends on humans. In its June 2025 forecast, Gartner cited this phenomenon as one of the reasons for the large-scale cancellation of agentic AI projects, because relabeled products cannot deliver on the promise of "autonomously completing work" in real business settings, and pilots quickly expose the value gap. A practical way to identify agent washing is to demand that the vendor demonstrate a decision or action the old process could not do — not a smoother conversation.

Four questions to screen a proposal

When you get an agent project proposal, run it through four questions first. The answers must be written in plain language — if the answer only holds up because of the word "agent," then the answer itself doesn't hold up.

First, strip off the label. Is this an assistant, chatbot, or RPA script under a new name, with no substantive agentic capability? If so, Gartner's term applies: either drop it or give it an honest new name.

Second, point to the agentic part. What decision did it make that the old process didn't, and what action did it take that the old process didn't? This is precisely the line Gartner uses to determine "genuine agentic capability." A wrapper that calls a model and sends text out doesn't meet that bar.

Third, map it against the three cancellation reasons. State the business value in one sentence; set the cost ceiling you're willing to bear; and explain what risk control will stop erroneous actions. Rising costs, unclear value, and insufficient risk control are exactly the three big reasons Gartner expects many projects to be cut.

Fourth, match the task to repetitive work people are already doing. Vaughn sees AI as a good augmentation tool that can boost efficiency when used correctly, but it won't replace teams or double their size. Surendira sees the opportunity in precisely those mundane, repetitive tasks. If a proposal claims it will double team productivity, fail it on the spot.

Surendira also mentions a real-world constraint: 95% of the AI work enterprises do today stays stuck at the proof-of-concept stage and never makes it into production. The reasons include fear of litigation, errors like approving a $100,000 refund when $10,000 was intended, and hallucinations, harmful content, and prompt injection. Two bottlenecks are equally clear: first, custom applications lacking documentation still need someone to define the actions an agent can execute; second, "tribal data" that is scattered and not ready.

Vaughn's version of the bar is the customer's problem itself. She argues for first asking what problem is being solved and whether AI actually helps. Many companies' problems don't need AI at all. She sees overpromising as the biggest trap and stresses that there will never be 100% accuracy. On safety-critical actions, a single missed detection (her example is failing to detect an intrusion) is enough to lose trust.

RPA (Robotic Process Automation) is a rules-based process automation technology that replaces repetitive manual labor by recording or orchestrating fixed operations such as clicks, form-filling, and copy-paste. Its core difference from agentic AI lies in determinism: RPA executes strictly along preset paths, fails when the interface changes or input is anomalous, and requires humans to maintain the rules; agentic AI is expected to autonomously judge the next action in an uncertain environment. This also explains why renaming an RPA script an "agent" is classic agent washing — it adds no decision-making capability. Conversely, RPA remains reliable and cost-controllable on high-frequency tasks with stable rules, so screening shouldn't reject it out of hand; instead, distinguish honestly: is this automation or an agent?

A screening sketch

The original article provided a Python sketch, intended only to illustrate the screening logic, not as a production-grade policy:

# Sketch, illustrative screening logic, not a production policy
def screen(p: dict) -> str:
    washed = p["rebranded_assistant_rpa_or_chatbot"]
    agentic = p["chooses_and_takes_a_real_action"]
    value = bool(p["business_value"].strip())
    cost_ok = p["cost_bound"] is not None
    risk_ok = bool(p["risk_control"].strip())
    repeated = p["replaces_a_repeated_human_task"]
    data_ok = p["needs_little_internal_data"] or p["data_and_actions_defined"]
    if washed or not agentic:
        return "drop"  # Per Gartner's June 2025 definition, this is agent washing
    if not (value and cost_ok and risk_ok and repeated and data_ok):
        return "narrow"  # Cost, value, or risk control — exactly the cancellation reasons
    return "worth a bounded experiment"

Even after passing screening, you shouldn't skip talking to users. Vaughn argues for talking to potential customers before building — including where the data lives and who can access it.

What to do after passing screening

Make the project narrower than the proposal. Vaughn joked about meeting-notes tools: a meeting with a dozen people and several different AI note-taking tools, and then someone wants to build "the AI note-taker for all AI note-takers." If your differentiation is just another agent in a crowded lane, then you have no differentiation.

If the project involves money, safety, or systems of record, risk control must be designed in before the demo — not patched in after the pilot hits trouble. Surendira notes that combining managed orchestration with DAG orchestration still can't solve critical use cases; what truly improves determinism is bringing in code, SQL, machine learning, and deep learning agents. You may not need his exact stack, but the rule is transferable: if you can't state what actions are permitted and what checks block erroneous actions, the project is still at the proposal stage.

Finally, a practical checklist:

• Describe the task in language without the agent label. If it's still an assistant, chatbot, or RPA, call it agent washing and stop.
• Demand a one-sentence business value, a cost ceiling, and a named risk control.
• Prioritize repetitive tasks people are already doing, and make calibratable augmentation claims — reject claims of doubling teams or eliminating them.
• If it relies on legacy internal applications or scattered data, define the actions and data first; otherwise switch to a task that needs almost no internal data.
• Treat "pass" as a bounded experiment plus a feedback loop — don't promise 100% accuracy, and don't use mainstream AI adoption rates as evidence that a project will survive.

DAG orchestration (directed acyclic graph orchestration) is an execution model commonly used by today's agent workflow platforms: break the task into nodes and use a directed acyclic graph to specify dependency order, where nodes can be model calls, tool calls, or code steps. Its strengths are predictability, auditability, and easy parallelism; its limitation is that the graph structure is predefined, so it lacks expressiveness for tasks requiring dynamic planning, looped retries, or open-ended exploration. This is exactly why Surendira points out that "combining managed orchestration with DAG orchestration still can't solve critical use cases" — the real way to improve determinism is to bring deterministic components like code, SQL, and machine learning into key nodes, letting the model handle judgment and the program handle execution. The takeaway for proposal screening: if you can't say which steps are decided by the model and which are backed by deterministic code, risk control is impossible to discuss.

One-line Summary

Use the four-question screening method to identify agent washing and shrink agentic AI proposals into bounded experiments.

Paragraph Summary

The article starts from the opposing views of two guests on the Chain of Thought podcast: Vaughn sees agentic AI as full of bubble, while Surendira sees adoption as already mainstream. The author points out that the two are not contradictory — broad adoption and overhype can coexist — and cross-validates with Gartner's forecast (over 40% of projects canceled by end of 2027, only about 130 vendors with genuine agentic capability) and Microsoft/LinkedIn data (75% of knowledge workers already use generative AI). On this basis, the author proposes a four-question screening method: strip off the label, point to the agentic part, map against the three cancellation reasons, and match to repetitive work tasks — plus an illustrative Python screening sketch. The article stresses that passing screening only means a bounded experiment is possible, that risk control must be designed in from the start, and that mainstream AI adoption rates should not be treated as evidence a project will survive.