Who’s Doing the Work?
A simple test for whether an AI product is actually agentic, or just an old workflow with AI in the margins.
Every AI product wants to call itself agentic now.
Most of them are not.
They are regular products with a chat box. Or regular products with autofill. Or regular products where the user still clicks through the same old sequence while an AI sits nearby narrating what is happening.
That can still be useful. I am not against assistance. Autofill is useful. Suggestions are useful. A good copilot can make a bad workflow less painful.
But that is not the same thing as an agent.
The Short Version
The test is simple:
Who is doing the work?
Walk through the flow step by step. At each moment, ask whether the human is operating the system or whether the system is doing the work and bringing the human back in for judgment.
- If the human is typing, comparing, hunting, choosing, uploading, confirming, and correcting while the AI makes suggestions in the margins, you have designed an assistive experience.
- If the AI has already done meaningful work before the human arrives, presents a prepared result, explains what matters, and asks the human to make a small number of real decisions, you are closer to an agentic one.
That distinction sounds obvious until you look at actual product work.
Most AI design still follows the same pattern:
1. Ask the user a bunch of questions.
2. Let AI parse or summarize some of the answers.
3. Show progress while the user keeps moving through the old flow.
4. Generate a recommendation.
5. Ask the user to approve it.
The screen changed.
The labor did not.
The person is still the operator. The AI is just riding along.
The Old Model: Human Works, AI Assists
The old model is familiar because almost every digital product has trained us into it.
The user starts. The user explains what they want. The user moves through the steps. The system may help, but the user remains responsible for driving.
In an AI-assisted version of that model, the product gets smarter around the edges.
In practice, that looks like:
- The form suggests answers.
- The chat interface explains the next step.
- The document parser extracts fields.
- The product says, “I found this for you.”
- Then it hands the person another task.
Better than nothing. Still not agentic.
The tell is task density.
If the product is handing the user a sequence of tasks, the user is still doing the work.
That task pile usually sounds reasonable one step at a time:
- Upload this.
- Review that.
- Compare these.
- Fix this field.
- Choose from this list.
- Read this explanation.
- Confirm this section.
- Move to the next step.
You can make that flow friendlier. You can make it faster. You can use AI to reduce the pain. But the underlying relationship has not changed.
The human is the worker.
The AI is the helper.
That is the model most teams are still designing, even when the roadmap says “agentic.”
If the user still has to drive every step, the product is assisting. It is not yet acting.
The New Model: AI Works, Human Judges
An agentic experience inverts the relationship.
The AI does the work. The human judges it.
That does not mean the AI acts without permission. It does not mean the human disappears. It means the human’s role changes from operator to reviewer, supervisor, approver, or editor.
The product should not open on an empty state asking, “How can I help?”
It should open with evidence that work has already happened.
- Here is the draft.
- Here is what I found.
- Here are the two things I need from you.
- Here is the decision that actually matters.
That is a different product posture.
An assistant gives you a to-do list. An agent brings you a decision.
That sentence is the whole thing.
If your product takes a complex job and turns it into seven slightly easier tasks, it is assisting.
If your product takes a complex job and turns it into one or two meaningful judgments, it is starting to act like an agent.
Bring Decisions, Not Tasks
Most product teams underestimate how much work they are still pushing onto the user because each individual step feels reasonable.
- One upload is reasonable.
- One confirmation is reasonable.
- One educational screen is reasonable.
- One checklist is reasonable.
Then you string them together and suddenly the product that was supposed to feel intelligent still feels like paperwork.
The user’s experience is not “AI helped me.”
It is “I did a lot of work while AI watched.”
The better version is decision-dense and task-sparse.
For example, imagine a financial product that helps someone complete a complicated annual obligation.
The assistive version:
- Asks questions.
- Collects documents.
- Explains progress.
- Fills fields.
- Shows a running estimate.
- Eventually asks the person to review the output.
Again: useful. Also familiar.
The agentic version starts somewhere else.
The agentic version:
- Opens with a prepared draft based on what the system already knows.
- Says what it could verify.
- Says what it could not verify.
- Names the assumptions it made.
- Collapses the settled parts.
- Brings forward the two decisions only the person can make.
Not “complete these seven sections.”
“I prepared this. These two choices change the outcome. Here is the tradeoff. Which one is true?”
That is the shift.
The product is no longer asking the person to assemble the answer. It is asking the person to judge the answer.
The Dangerous Part: Approval Is Not Oversight
This is where the argument gets less comfortable.
Moving work from the human to the AI is powerful. It is also risky.
Because if the human’s new job is approval, then the quality of that approval becomes the whole product.
A bad agentic experience is not one where the AI acts. It is one where the AI acts, the product shows a confident recommendation, and the human clicks approve because that is the easiest path.
That is not oversight.
That is a rubber stamp.
Designers love reducing friction. Usually, that instinct is right. Friction is often where products hide organizational complexity and call it user responsibility.
But in agent-led experiences, some friction is load-bearing.
Use friction by risk:
- Reversible action: let the agent move fast. Give the person a clean undo. Do not bury them in consent screens for low-risk work.
- Consequential action: ask for real judgment. Show what changed. Show what the system assumed. Make the person choose between meaningful options instead of tapping a glowing “looks good” button.
- Irreversible action: the consent gate has to be real.
Money moved. A legal filing submitted. A message sent to a third party. A credit pull. A public action. Anything where undo is a fantasy.
For those moments, speed is not the point.
The point is scoped authorization: this action, this amount, this account, this window, this consequence.
The trick is not to add more friction everywhere. That just trains people to click through it.
The trick is to spend friction precisely.
Trust Is Not the UI. Trust Is the Behavior.
A lot of “trust UI” is theater.
You have seen the pattern:
- Explainability panels.
- Consent stacks.
- Audit logs nobody opens.
- Little badges that say the system is responsible.
Some of those surfaces are necessary. Many are there because they make the team feel better, not because they help the user make a better decision.
Trust is not a screen.
Trust is a behavior.
The real questions are:
- Does the person rely on the system when it is right?
- Do they catch it when it is wrong?
That is the calibration problem.
The risk is not only that people will under-trust AI and abandon useful help. The risk is also that they will over-trust it, especially when the system sounds confident, gives a fluent explanation, and presents a clean next button.
In normal software, over-trust is bad.
In agentic software, over-trust is existential.
Because the human’s whole job has been compressed into judgment.
If judgment decays into reflex, the product has removed the human while pretending to keep them.
Chat Is Usually a Symptom
Chat has a place. It is useful when the user has a specific question, wants to explore a scenario, or needs to correct the system’s understanding.
But chat should not be the default interface for most agentic products.
A blank prompt box pushes initiation back onto the human. It asks the person to know what to ask, how to ask it, and what good output should look like.
That is the old model again.
The product is saying, “Tell me what to do.”
An agentic product should be more opinionated than that.
It should know enough to start.
It should prepare something.
It should bring back one of these:
- A result.
- A plan.
- A proposal.
- A draft.
- A comparison.
- A queue.
- A decision.
Then chat can be the escape hatch.
Not the front door.
The Practical Rubric
When I look at an AI product now, I start with this rubric:
1. Who is doing the work, the human or the AI?
2. Is the human being handed tasks or decisions?
3. Does the product open on a blank prompt or on prepared work?
4. What does the system know, and what is it pretending to know?
5. Where does the human’s judgment actually matter?
6. Could the human catch the AI if it were wrong?
7. Which actions are reversible, consequential, or irreversible?
8. Is consent scaled to the cost of being wrong?
9. Is chat the default because it is right, or because the product has not figured out the workflow?
10. If the agent fails, does the product degrade gracefully or dump the user into a mess?
The first question usually exposes the rest.
If the user is still doing the work, stop calling it agentic.
Call it assisted. Then make the assistance excellent.
If the agent is doing the work, the design problem changes. Now you are designing judgment, supervision, accountability, recovery, and proof.
That is harder than adding AI to a workflow.
It is also the actual work.
What Designers Should Be Doing Now
The next generation of AI product design will not be won by whoever adds the most chat surfaces.
It will be won by teams that can model work clearly.
That means asking sharper questions:
- What has to be done?
- What can the system do ahead of time?
- What should never be automated?
- Where does the human have unique judgment?
- Where is the human just being used as a liability sponge?
- What proof should the agent bring back?
- What should happen when it is wrong?
These are design questions. Not just technical ones.
The interface is the visible part, but the real design object is the relationship between work, judgment, and accountability.
That is why “who’s doing the work?” is such a useful question. It cuts through the demo polish. It gets underneath the chat box, the sparkle icon, the generated summary, the onboarding copy, and the hand-wavy roadmap language.
It tells you what kind of product you are actually making.
If the human is doing the work and AI is helping, design a great assistant.
If the AI is doing the work and the human is approving, design a real supervision system.
Do not confuse the two.
That confusion is where most agentic products will fail.
Not because the AI cannot do anything.
Because the product never decided what the human was still there to do.