For thirty years, product design has meant arranging affordances on a screen: buttons, fields, lists, states. Agentic software breaks that frame. When a user delegates a goal, “rebook my travel,” “triage my inbox,” “draft the quarterly narrative,” the unit of design is no longer the screen. It’s the behavior of the system over time.
From surfaces to relationships
A screen is stateless, and that matters: every visit, it presents the same affordances and waits. In contrast, an agent carries state forward. It remembers, anticipates, and acts between sessions. Users don’t evaluate it the way they evaluate a form. They evaluate it the way they evaluate a colleague:
Was it reliable?
Did it overstep?
Did it tell me what I needed to know, at the moment I needed to know it?
This means the designer’s raw material now includes timing, initiative, and restraint. Choosing when an agent should not act is as much a design decision as choosing the radius on a card.
Users don’t evaluate an agent the way they evaluate a form. They evaluate it the way they evaluate a colleague.
The rehire question
Benchmark culture has given us agents that score impressively on task suites and still feel terrible to work with. The gap is measurement: we’re grading agents like functions when users experience them like collaborators. If your eval ends at “task completed: yes/no,” you’re optimizing the wrong thing.
The single most predictive question I’ve found isn’t in a usability study. It’s: would you hand this agent the same task again next week?
“Rehire intent” bundles everything that task success misses — how much supervision it needed, how the failures felt, whether the user trusts it with variations of the task. Track it like you’d track NPS, but per capability rather than per product.
The supervision tax
Every agent interaction has a hidden denominator: the time the human spent prompting, monitoring, reviewing, and correcting. An agent that completes 95% of tasks but demands constant babysitting is a worse product than one that completes 85% autonomously and knows when to ask for help.
Instrument the whole loop, time-to-delegate, interventions per task, correction depth, not just the output. Calibrated deference is a feature; measure it like one.
Legibility is the new usability
Heuristics like “visibility of system status” were written for systems that wait. Agents need something stronger: legibility of intent. Before an agent acts, a user should be able to predict roughly what it will do. After it acts, they should be able to reconstruct what they did, and why.
- Show the plan before the action when stakes are high.
- Make every action reviewable after the fact, in plain language.
- Prefer narrow, named capabilities over a vague “do anything” YOLO.
None of this is novel. The design work is deciding the altitude: too much explanation and the agent feels like a liability waiver, too little and it feels like a slot machine.
Failure quality is product quality
Two agents fail the same task. One says “I couldn’t verify the flight change, so I haven’t booked anything — here’s where I got stuck.” The other books the wrong flight. Same task-success score, wildly different products. Evals need a failure-mode rubric: Was the failure announced? Contained? Recoverable? Did the agent’s confidence match its competence? In the long run, how a product fails determines whether it gets a second chance.
Trust is earned in increments
The teams that succeed treat autonomy like a permission system with a career ladder. New agents start in propose-only mode. As acceptance rates climb and corrections fall, scopes widen. The interface communicates this clearly, “I’ve done this 40 times for you; want me to stop asking?” — instead of defaulting to maximum autonomy and apologizing later.
What this means for design teams
Your design system needs behavioral components now, not just visual ones: confirmation patterns, undo windows, activity ledgers, escalation moments. Content design takes center stage when you craft your agentic disclosure strategy. Your critique vocabulary needs words for initiative and deference. And your researchers need to design diary-like longitudinal methods, because the agentic experience reveals its character over weeks, not in a single usability session.
Diary studies, cohort retention on delegated task types, and trust surveys at week one and week six tell you what the session can’t. It’s slower and more expensive, but it’s the only research that matches the shape of a relationship product. Rebuild your research practice around this.
Human-agent relationships are here to stay. But the screen isn’t going away.
It is becoming the place where a relationship is negotiated, not where the work happens.
Design accordingly.