Your Employees Are Already There. Your Design Isn't.

The design primitives we urgently need for the age of autonomous AI

Somewhere in your organization right now, someone is running an AI agent to do work you haven’t sanctioned, through a workflow you didn’t design, with a level of trust you didn’t build.

They’re not doing it recklessly. They’re doing it because it works and because the official tools haven’t caught up with what they actually need.

This is the gap. Not between AI capability and human readiness. Between what people are already doing and what we’ve designed to support them.

The Handshake That Used to Hold

For a long time, talking to AI felt like using a very smart search engine. You asked, it answered. You stayed in control. That was Claude a couple of years ago. That was most of us, honestly, treating it like a faster way to draft an email or summarize a document.

Then something shifted. The same tools that answered your questions started booking your meetings, filing your tickets, browsing on your behalf, executing multi-step workflows while you were away from your desk. The industry called it “agentic AI” and shipped it fast. What nobody paused to ask was: what does UX actually look like when the work is happening without you?

The entire discipline of UX was built around feedback loops. Norman’s Gulf of Evaluation. Nielsen’s heuristics. Visibility of system status as principle number one. These weren’t aesthetic choices. They were the foundation of trust between a human and a machine. You needed to see the system’s state because you were responsible for its next action.

That model held for decades, even as interfaces became more sophisticated. The system suggested. You decided. The loop stayed intact.

Agentic AI broke the loop. When an agent browses, writes, executes, and summarizes on your behalf while you’re in a meeting, the feedback loop doesn’t just slow down. It disappears. The work happened. You weren’t there for it. And now you have to figure out whether to trust what you’re looking at.

This isn’t a feature gap. It’s a paradigm shift in the human-machine relationship, and the design language to support it doesn’t exist yet.

The Shadow Workforce Is Already Here

Here’s what makes this urgent: people aren’t waiting for us to figure it out.

Every Friday, I spend time talking to customers about moments when they don’t trust Guru’s AI. I started doing this to surface edge cases. What I keep surfacing instead is something more revealing: an entire layer of AI behavior that lives beneath the official story.

People are building their own systems. Custom GPTs for tasks their company hasn’t sanctioned. Autonomous workflows stitched together across tools their IT department doesn’t know about. Not because they’re reckless. Because the official tools aren’t keeping up with what they need to do.

One customer described using three separate AI tools in sequence to do something that should have been a single workflow in their enterprise platform. Each step required them to manually review and approve the output before feeding it to the next tool. They had, on their own, invented a verification layer that the products hadn’t given them.

Another described abandoning a newer, more technically accurate version of a tool in favor of an older one that felt like it gave them “more control” even though they couldn’t articulate exactly what that control was.

This is the shadow workforce problem. It’s not that individuals are adopting AI faster than organizations. It’s that individuals are filling a design vacuum. They’re creating their own trust rituals, their own checkpoints, their own workarounds. Because we handed them delegation without designing for it.

What Delegation Actually Requires

When you delegate to a person, you don’t just hand off a task. You build shared context. You establish checkpoints. You agree on what “done” looks like. You create a recovery path for when things go wrong. You calibrate how much autonomy to extend based on demonstrated competence over time.

We do none of this when we hand off to an AI agent.

The current generation of autonomous AI tools essentially says: here are your instructions, here is the output, good luck figuring out what happened in between. That works fine for low-stakes, easily reversible tasks. It fails everywhere else, sometimes quietly, sometimes catastrophically.

The customer who built their own three-step verification workflow wasn’t being inefficient. They were doing, manually, what the design should have done for them. They were building the trust scaffolding that was missing.

A Framework for Designing Delegation

The question isn’t whether AI agents are ready. Some are. The question is whether the design of these systems matches the stakes of what’s being delegated.

Here are the principles I’m starting to build from:

1. Stake-calibrated transparency Visibility requirements should scale with consequence. A low-stakes task (drafting a first pass, summarizing a document) doesn’t need the same audit trail as a high-stakes one (sending a communication, modifying a record, making a purchase). Design the level of transparency to the level of risk. Not uniformly high, not uniformly low.

2. Legible process, not just legible output Showing the user what the agent produced is necessary but not sufficient. They also need to understand, at the right level of abstraction, how it got there. Not 47 log entries, but a coherent narrative of decisions made. The goal is auditability without overwhelm.

3. Earned autonomy over time Delegation in human relationships is incremental. It’s built on observed competence. AI agent interfaces should support the same arc, starting with more checkpoints and requiring explicit approval, and progressively extending autonomy as the user develops confidence. This isn’t just about safety. It’s about building the kind of familiarity that lets people trust appropriately rather than blindly.

4. Graceful recovery paths Every trust system needs a mechanism for things going wrong that doesn’t destroy confidence in the whole system. The question for every autonomous feature isn’t just “what does success look like?” but “what does recovery look like when it fails?” If there’s no answer, the feature isn’t ready.

5. Explicit delegation moments The handoff from human control to agent action should be a designed moment, not an invisible transition. Users who feel they participated in the delegation trust the outcome more, even when the outcome is identical. The act of consciously extending trust is itself part of building it.

Who’s Actually Ready?

The honest answer is: individuals are often further along than the organizations deploying for them.

The shadow workforce isn’t a sign of dysfunction. It’s a leading indicator. The people building unofficial workflows are showing us what genuine delegation looks like when the design doesn’t get in the way. They’ve moved past the interface-to-delegate transition on their own terms.

The design challenge now is to catch up, to build tools that meet people where their trust actually lives, not where the product roadmap assumed it would be.

The contract between human and tool has changed. We broke it when we shipped delegation. The work now is to write a new one.

Johanna Evans is VP of Product Design at Guru, where she leads AI product development including Knowledge Agents, Chat, and Research. She talks to customers every Friday about moments when they don't trust AI systems, and designs from what she hears.