You are evaluating a media tool for an AI agent to use, and the demo looks great. A prompt goes in, an image comes out cropped and captioned, and the page says "AI-powered." So you wire it into your product, hand the controls to your agent, and within a day someone is back to clicking through the UI to fix what the agent could not finish on its own.
Here is what most teams run into. An "AI" label on a media tool tells you almost nothing about whether an agent can actually drive it. Some tools are genuinely built for an agent to operate unattended. Many are a human tool with an AI sticker on the box, and the gap only shows up after you have built on top of it. The good news is you do not have to guess. There is a short self-test you can run yourself, on any tool, before you commit. Full disclosure before we start: Layermetry is one of these agent-drivable media layers, so we have a stake in the answer. We will still lay out the test plainly and let you score it yourself, including against us.
Agentwashing is a real and named problem now
The reason you need a test is that the market got loud. In 2025 a major industry analyst firm gave this pattern a name: "agentwashing," the rebranding of existing assistants, chatbots, and automation as "agentic AI" without the substance behind it. The same firm estimated that of the thousands of vendors claiming to offer agentic AI, only about 130 were actually delivering it, and predicted that more than 40% of agentic AI projects would be canceled by the end of 2027, as teams ran into rising costs, unclear business value, and inadequate risk controls. That is a survey-backed prediction about the market, not a law of nature, but it is the reason "AI-powered" on a label is no longer something you can take at face value.
The label is not the capability
The word "agent" now stretches from a chatbot that fires one API call all the way to a system that plans, retrieves, uses tools, and takes action across your stack. A legal analysis of the trend put it plainly: companies misrepresent conventional automation as "agentic," or exaggerate the autonomy of a real agent while hiding the risks. For media tooling specifically, the tell is simple to state and easy to miss in a demo. A tool that needs a human hand on the mouse for the routine path is a human tool, no matter what the marketing says. A tool an agent can run on its own, check its own work, and repeat safely is the real thing.
The five signals that separate the real thing from a wrapper
A genuine agent does a few things a wrapper cannot. It operates without constant prompting, it reasons over state and feedback, and it takes action and adapts, per a widely used working definition. Translate that into questions you can ask of a media tool and you get five signals. None of them require you to trust a sales deck. You can test each one with the tool in front of you.
Real vs agentwashed, at a glance
| Signal | Agent-drivable | Agentwashed |
|---|---|---|
| Operations | Typed, named, composable calls | One vague "do the thing" prompt box |
| Results | Machine-readable, agent can judge them | A picture a human has to eyeball |
| Retries | Safe to run twice, idempotent | Re-running double-charges or duplicates |
| Routine path | No human in the loop required | A person must click to finish |
| Observability | You can trace what the agent did | A black box you cannot inspect |
Signal one: the operations are typed and composable
Ask whether the tool exposes named operations with declared inputs and outputs, or just a single freeform prompt. Genuine agent tooling publishes a machine-readable description of each operation's inputs and outputs, so an agent can discover what is available, pick the right call, and chain calls in order. In media terms, that means distinct, nameable actions: crop, retouch, reframe, color, caption, export. Each is its own typed call the agent can combine. A wrapper gives you one box that takes a sentence and returns whatever it returns, with no contract you can hold it to. The test is concrete. Open the docs and look for a list of operations with schemas, not a single endpoint that takes a paragraph.
Signal two: results come back machine-readable
This is the signal most demos skip, and it is the one that matters most for autonomy. An agent needs to know whether the edit worked so it can decide what to do next, on its own, without a person looking at the screen. That means the result has to come back as data the agent can read, not only a picture a human has to eyeball. Did the crop hit the right aspect ratio? Did the caption land inside the safe area? A real tool returns answers to those questions in structured form. A wrapper returns an image and leaves the judging to you. Without machine-readable results, every step quietly needs a human, which is the whole thing you were trying to avoid.
Signal three: retries are safe and idempotent
Agents fail, time out, and retry. That is normal, not a defect. So the question is what happens when the same call runs twice. A tool built for agents is idempotent on the routine path, which means running an operation again does not create a duplicate or charge twice. The backend guarantees the reliability so the agent does not have to reason about failure recovery on its own. The test is blunt: run the same operation twice and see whether you get one clean result or two messes. If a retry corrupts state, the tool was built for a careful human who never double-clicks, not for an agent that will retry all night.
Signal four: the routine path needs no human in the loop
Human review is a feature for the rare, risky, irreversible action. It should never be the cost of getting routine work done. A real agent is defined by operating without constant human prompting. The 2026 best practice is to keep a human checkpoint for high-risk or irreversible steps and let the routine path run unattended. The agentwashed pattern inverts that. The routine path is full of "click to confirm," and the tool only feels autonomous in the slide deck. The test: can the agent complete the common case end to end with no human tap? If finishing a routine edit always needs a person, an agent is not driving the tool. A person is, with extra steps.
Signal five: you can see what the agent did
When an agent runs unattended, the only way you trust it is to be able to look back at what it did. Continuous transparency into an agent's actions, tool calls, and outcomes is now considered table stakes for production, not a nice-to-have. For a media tool that means a trace: which operations ran, on which asset, with what result, and where it went wrong. The test is whether you can answer "what did the agent do to this file last night" without guessing. A black box passes a demo and fails the first incident. And this one is not a one-time setup. Change one agent or one model and the whole flow can behave differently, so the observability to catch it is a standing cost, not a checkbox you tick once.
Scoring your candidate, including the build-it-yourself option
Run the five tests on whatever you are evaluating and you will land in one of three places, and each is a real choice with an honest cost.
Build the agent-drivable layer yourself
You can build all five properties into your own editing layer. You get total control and no dependency on anyone else, which is genuinely the right call for some teams. The cost is that typed operations, machine-readable results, idempotent retries, an unattended routine path, and standing observability are not a weekend project. They are infrastructure you build and then maintain forever, while the agent frameworks and models underneath you keep moving.
Adopt a tool that already passes
The other path is to buy a media layer that already passes the five tests, so your effort goes into your agentic operations and your own models rather than into rebuilding the editing surface. Layermetry is one such option, and it ships classic editing, generative, and agentic features behind typed operations with machine-readable results and tracing, plus the ability to ship your own tools alongside the native ones, so it stays extensible rather than a dead end. We would rather you run the test than take our word for it. Score us the same way you score anything else.
When a simpler tool is the honest answer
If your work is one-off and a human is happily in the loop, you may not need an agent-drivable tool at all, and a classic editor or a generative tool is the right and cheaper choice. The test only matters when you intend to hand routine, repeatable media work to an agent and walk away. If that is you, a tool that fails even one of the five signals tends to fail exactly where you stop watching it.
Frequently asked questions
What is agentwashing? Agentwashing is the practice of marketing an existing product as "agentic AI" when it lacks the underlying autonomy. A major industry analyst firm popularized the term for vendors rebranding assistants, chatbots, and automation as agents, and estimated that only about 130 of the thousands of vendors claiming agentic AI were actually delivering it.
How can I tell if a media tool is genuinely agent-drivable? Apply the five tests. The operations are typed and composable, results come back machine-readable so an agent can judge them, retries are safe and idempotent, the routine path needs no human in the loop, and you can observe and trace what the agent did. A tool that passes all five can be driven unattended. One that needs a person clicking through the UI cannot.
Does a media tool need to pass all five tests? For routine work an agent runs on its own, yes. The five signals reinforce each other. Typed operations only help if the agent can read the result, and machine-readable results only help if retries are safe and the work can be traced. A tool that passes most but fails one tends to break exactly where you stop watching.
Run the test before you build
The label on the box is marketing. The five signals are evidence. Before you wire any media tool into an agent, run the test yourself: typed operations, machine-readable results, safe retries, an unattended routine path, and observability you can trust. Whether you build that layer or adopt one, knowing where your candidate scores is the cheapest hour you will spend on the whole project.
If you want the longer version of each signal, with the operation schemas, the result formats, and the tracing model written out, our documentation walks through what an agent-drivable media layer looks like in practice, so you can hold it up against your own checklist.