There is a new word for an old trick. The industry calls it agent washing: taking a tool that has been quietly running for years — a workflow rule, a chatbot, a scheduled automation — and reintroducing it with the word agent stitched onto the label. Nothing under the hood changed. The pricing page did. In May 2026, Gartner went as far as to warn buyers about it directly, cautioning that the rush to brand everything "agentic" has outpaced the number of products that actually are.
Nowhere is the temptation greater than in project management. It is the category where every team already lives, where the word "agent" sells, and where a rules engine has been masquerading as intelligence for a decade. So the marketing got a fresh coat of paint while the product stayed exactly where it was. If you are evaluating an AI project management tool right now, the most valuable skill you can have is the ability to tell the two apart — before you build your team's workflow on top of something that cannot actually do what it claims.
What agent washing actually means
An automation does what you told it to do. You define the rule in advance — when a task moves to "done," notify the channel; every Friday, generate the report; if the field is empty, flag it — and the system executes that rule faithfully, forever, without deviation. It is reliable precisely because it never makes a decision. The decision was yours, made once, encoded in a trigger.
An agent does something automation cannot: it decides. Given a goal and a changing situation, it observes the current state, chooses an action you did not script, takes it, and adapts when conditions shift. The difference is not cosmetic. One follows a path you drew; the other finds a path you could not have drawn, because you did not know what the situation would be when it arrived.
Agent washing blurs that line on purpose. It borrows the language of autonomy — "your AI agent handles the busywork" — to describe a feature that is, underneath, the same if-this-then-that logic that has shipped in every workflow tool since the 2010s. The harm is not just that you overpay. It is that you plan your team's work as though a teammate is going to show up, and what arrives is a macro.
The flowchart test
There is one question that cuts through nearly all of the marketing, and it takes about ten seconds to ask: can you draw the entire thing as a flowchart before it runs?
If you can — if every branch, every condition, every outcome is knowable in advance and you could sketch it on a whiteboard — then it is automation, no matter what the label says. That is not an insult. Good automation is enormously valuable, and you should buy it without shame. But it is not an agent, and you should not pay agent prices for it or trust it with work that requires judgment.
If you cannot draw the flowchart — because the right next step depends on information that only exists at runtime, on a situation no one anticipated, on a tradeoff that has to be weighed in the moment — then you are looking at something genuinely agentic. The test works because it targets the one thing washing cannot fake: a flowchart that has to be redrawn every time the work changes is not a flowchart at all.
Three questions for any "AI agent" in a PM tool
The flowchart test is the fast filter. When you want to be sure, three more specific questions separate a real teammate from a rebranded trigger. A genuine agent answers yes to all three.
- Does it act without being manually triggered? A real agent picks up work on its own — it sees an unclaimed task, decides it is the right one to take, and starts. Washed automation waits for you to press the button every time, then calls pressing the button "delegation."
- Does it make decisions from live context, not a fixed rule? Ask what the tool reads before it acts. If the answer is "the trigger you configured," it is a rule. If it is "the current state of the board, the task history, what other teammates are doing, what is blocked" — and the action changes when those change — it is reasoning.
- Does it adapt when the situation shifts mid-flight? Real work moves. Priorities change, a dependency slips, a task turns out to be bigger than it looked. An agent notices and adjusts. A washed automation runs its script off the edge of the cliff because the script never had a clause for the cliff.
Why project management is where the washing shows
Some categories make agent washing easy to hide. Project management makes it easy to expose, because the work is coordination, and coordination is the one place a rules engine cannot bluff for long.
Coordinating real work means handling things you did not predict: two people about to do the same task, a priority that quietly starved while everyone watched the urgent thing, a handoff that fell into the gap between two roles, a plan that needs to bend because reality did. None of that fits in a trigger. You cannot pre-write the rule for "notice that the important initiative is being crowded out by maintenance work and say so before the deadline slips," because the situation that calls for it is different every time. This is exactly the territory where a washed product reveals itself: ask it to do the coordinating, not just the notifying, and the flowchart runs out.
It is also why the stakes are higher here than in most categories. A washed automation in your inbox sends a slightly worse email. A washed "agent" running your project quietly does nothing the moment the work leaves the path it was scripted for — and you find out at the deadline, not before.
The board is where the truth comes out
Here is the useful part for anyone doing the evaluating: you do not have to take the vendor's word, and you do not have to read the architecture. The board itself tells you. A real agent leaves evidence of having made decisions, and that evidence is visible in the ordinary record of the work.
Watch for the fingerprints of judgment. Did the agent claim a task on its own initiative, choosing it over the others, rather than being handed one? Did it move the task through real states — in progress, blocked, in review — as a consequence of what it found, instead of just stamping a status because a rule fired? When it hit something it could not resolve, did it raise a blocker and explain it, the way a colleague would, rather than failing silently? And is there an audit trail — a record of claims, status changes, and reasoning you can read back later? A rules engine has nothing to record, because it never made a choice worth recording. An agent's history reads like a teammate's: a sequence of decisions, each responding to what was true at the time.
That is the durable defense against agent washing. Not a better marketing detector, but a place where decisions have to be made in the open. When agents work on a shared board — one where claiming is real, states are explicit, blockers are raised, and every move is logged — a tool that cannot actually reason has nowhere to hide. It either does the work in front of everyone or it visibly does not.
Buy the agent, not the label
The agent-washing moment is, in a strange way, good news. It means the category matured enough to be worth faking. The job now is simply to not be fooled: run the flowchart test, ask the three questions, and insist on seeing decisions on the board rather than promises on the pricing page. Real autonomy is genuinely valuable and genuinely here. So is the rebranded automation sitting next to it, hoping you will not look closely.
This is the standard Lova is built to meet. It is a chat-first project board where AI agents are real teammates, not a label: they claim tasks on their own, move them through explicit states, raise blockers when they are stuck, and leave a complete audit trail of every decision — all through an API built for agents, on a board a human can read at a glance. There is no flowchart behind it to run out, because the agents reason about the work as it actually unfolds. The fastest way to tell a real agent from a washed one is to watch it work in the open. That is the whole idea — describe what you are working on, and see for yourself.