Execution got cheap. Trust didn't.

In the same week of July 2026, two of the most-read publications in design landed on what looks like the same anxiety from opposite directions. Jakob Nielsen's July 13 UX Roundup argued, with fresh data behind it, that agentic AI makes expertise more valuable, not less — and that the products which win will be the ones giving human judgment the greatest leverage over machine execution. The UX Collective's edition, published the same day, led with a quieter and more unsettling question: wait, who made this? — the observation that as anything can be generated, audiences are redefining what they value and trust about creative work.

One is about control while the work happens. The other is about trust after the artifact exists. Neither is a mood. Both are downstream of a single structural change that three studies, all published in June 2026, now let us name precisely.

Cheap execution doesn't remove the human. It relocates the human — from doing to directing, and from trusting output to verifying provenance.

The interfaces we're shipping haven't caught up with either move.

What changed

Execution got cheap. Delegation didn't.

The clearest evidence comes from a working paper by Jeremy Yang of Harvard Business School with researchers at Perplexity ("How AI Agents Reshape Knowledge Work," arXiv:2606.07489, June 2026). Comparing behavior across Perplexity's conversational Search and its autonomous Computer agent, they found the agent performs roughly 26 minutes of autonomous work per session, against about 33 seconds of equivalent effort in a search interaction. On matched real-world tasks, completion time fell from 269 minutes to 36 — an 87% reduction, with costs down 94% against search-equipped humans.

The headline numbers are not the interesting part. The interesting part is what users did with the surplus. They didn't bank the savings. They spent them — on bigger tasks, on composite work bundling interdependent subtasks, and on requests that crossed occupational boundaries into domains they don't professionally inhabit.

The paper's economic framing explains why. An agent carries a higher fixed cost per delegation — you have to articulate the task, the context, the constraints — but a near-zero marginal cost per additional step of execution. Once you've paid the delegation cost, the rational move is to delegate more: bigger scopes, longer chains, less familiar territory.

Which produces the consequence nobody puts on the launch slide: the tasks now being delegated are precisely the ones the delegator is least qualified to check. A marketer commissioning working code. A founder commissioning a legal-adjacent analysis. An analyst commissioning design. The economics push everyone one domain past their own verification competence — and the interface is what has to absorb that gap.

The expertise multiplier

Does agentic AI de-skill the workforce? The data says the opposite.

Anthropic analyzed roughly 400,000 Claude Code sessions from about 235,000 users between October 2025 and April 2026 ("Agentic coding and persistent returns to expertise"). The division of labor was consistent — and the returns to expertise didn't shrink as the agent got more capable. They compounded: the more domain expertise a person brought, the more work the agent completed per instruction.

This is the empirical floor under an argument Geoffrey Litt made the same month in an essay the UX Collective picked up: as agents get more capable, the temptation is to assume humans matter less in the details — and that assumption is wrong, because understanding becomes the bottleneck. The person who can specify precisely, decompose correctly, and evaluate ruthlessly extracts multiples of what a novice gets from an identical tool.

"Execution is becoming a commodity, making direction the differentiator."

But here is the reframe that matters for anyone shipping agentic products: if expertise is the multiplier, then any interface that hides what the agent did is destroying the multiplier. Expertise pays through the ability to inspect, catch, and correct. An agent that runs opaque for 26 minutes and returns a polished artifact has converted your expert into a novice for the duration — they can only judge the surface, exactly like everyone else. Legibility isn't a courtesy feature — it's Heuristic 01 for a reason. It is the mechanism by which expertise earns its 70% of the planning decisions.

The control gap

Why can't we just add a control slider?

The intuitive fix is more user control: sliders, dials, complexity settings. Nielsen's roundup covers why that intuition currently fails, and the primary source deserves to be read closely. Researchers at the University of Illinois Urbana-Champaign ("Explain Like I'm 5 or Whatever I Choose," Panigrahi & August, arXiv:2606.06788, June 2026) first confirmed the demand: in their formative study, users preferred direct manipulation controls for response complexity over endlessly re-prompting. Then they tested whether frontier models can actually honor such controls, across five complexity levels and 98 expert-written scientific queries.

The best-performing model moved technical jargon in the requested direction only 46% of the time. When they required all three measured dimensions — length, jargon, and information content — to move correctly together, success dropped to roughly 14% on the hardest range. Length obeyed reliably. Substance frequently went the wrong way, and got worse at the higher complexity levels, where accuracy approached chance.

Sit with what that means. Users are asking for granular control over agentic systems, and the models cannot yet reliably deliver it through instructions alone. The demanded control exceeds the model-deliverable control.

The design conclusion follows directly: control has to be structural, not prompted. A permission that depends on the model interpreting an instruction correctly is not a permission — it's a hope with a 46% hit rate. If you want an agent that never executes payments above a threshold, never publishes without review, never touches production data, those constraints have to live in the architecture around the model: in scoped credentials, in gated action tiers, in interfaces that physically separate proposing from executing. The prompt is where you express intent. The structure is where you enforce it. It's the same lesson a bank's own defaults taught us: text-only governance is insufficient — trust has to be made mechanical.

The seam

Trust has to be built into the interface, not requested from the model.

This is the seam where the two publications meet — and where our work at auxfirst sits. Nielsen's roundup distills the design task for agentic products into four imperatives: help users articulate intent before execution, constrain the agent without handcuffing legitimate variation, reveal changes and uncertainty during execution, and make verification and recovery fast afterward. Each of those four now has a named, measured failure mode from the June studies. And each maps onto a component of the AUX framework we've been building client systems around.

Intent, before execution: the Agentic Trust Canvas

The HBS/Perplexity data shows users delegating work outside their own domains — which means they're scoping tasks they can't fully specify. Intent articulation can't stay a blank prompt box. The Agentic Trust Canvas treats intent capture as a design artifact: what the agent is for, what "done" looks like, what it must never do, and what it should ask before doing. The deliverable is closer to a behavioral contract than a flow — the shift Nielsen predicted in his January 2026 outlook, when he wrote that designers would increasingly specify constraints and behaviors rather than draw screens. The June data is why that prediction stopped being optional.

Constraint, without handcuffs: the Action Heat Ladder

The Illinois results are the argument for the Action Heat Ladder in one number. Prompted constraints hold roughly half the time; structural constraints hold every time. The Ladder classifies every agent action by its heat — reversibility, blast radius, visibility to third parties — and assigns each tier a different execution mode: autonomous, notify-after, confirm-before, human-only. Low-heat actions run free, so legitimate variation isn't handcuffed. High-heat actions physically cannot execute without escalation, regardless of what the model believed the instruction meant. Governance becomes orchestration — the exact phrase the UX Collective's DesignOps pick used for where operations teams are heading — but orchestration needs rungs to orchestrate on.

Legibility, during execution: Trust Architecture

Twenty-six minutes of autonomous work is twenty-six minutes of dark unless the interface is designed otherwise. Trust Architecture treats the running agent as a surface, not a spinner: what changed, what's uncertain, what the agent chose not to do and why. This is where the expertise multiplier gets protected — an expert watching a legible run can intervene at minute four; an expert handed an opaque artifact at minute twenty-six can only accept or reject it. The Anthropic data says humans still own the planning decisions. Legibility during execution is what lets them keep owning them mid-flight.

Verification and provenance, after execution: Agent Identity Cards and the Authorship Layer

And then the question Nielsen's roundup doesn't reach, and the UX Collective's lead essay is entirely about: who made this? Once the artifact leaves the loop — the report gets forwarded, the code gets merged, the campaign ships — trust stops being about the run and becomes about the record. Agent Identity Cards answer the operational half: which agent acted, under whose authority, with what permissions, on which date. The Authorship Layer answers the human half: making the division of contribution — who directed, who executed, who verified — a durable, inspectable property of the artifact itself rather than a claim in a caption.

This is the seam between the two publications. Nielsen covers the loop while it runs. The UX Collective covers the artifact after it ships. Between them sits an unnamed gap — and that gap is where the governance failures of the next two years will actually occur: not in agents misbehaving mid-run, but in organizations unable to reconstruct, after the fact, what was made, by what, under whose judgment. It's the 40th principle again, from another angle: make conformance verifiable.

For teams shipping in 2026

Three moves, each cheap relative to the failure it prevents.

---