Your UX Skills Were Built for One Kind of Intelligence.

We spent 20 years designing things users control. The next 20 will be about designing things that act on our behalf.

We spent two decades mastering interfaces. We learned how to map workflows, how to communicate intent, how to shape interactions through layout and information hierarchy. The UI really was the ground truth of user experience and I have loved this space. Now, AI changes all of that. We're moving into a reality where software has agency.

An AI agent isn't a feature; it's an intelligence negotiating on our behalf, interpreting goals, making trade-offs, taking initiative, and occasionally surprising us. That is a profound shift, because once products possess agency, the interface stops being the primary surface. The behaviour becomes the interface (that's not to say all UI disappears either).

This means our job as designers changes. We used to design what users click, and now we design how they delegate. We used to define flows, and now we define boundaries. We used to specify screens, and now we specify how a system interprets intent, resolves ambiguity, asks for clarification, and recovers from mistakes.

Why This Is Happening Now

We're at an inflection point where LLMs finally have enough reasoning ability to make agentic behaviour genuinely useful, and not just a party trick. The orchestration tooling around them is maturing. Interfaces are increasingly being auto-generated at runtime. Users are getting more comfortable collaborating with systems rather than commanding them and the tasks we're asking of software are getting more open-ended, more ambiguous, more like the kind of thing you'd hand to a team mate and trust them to come back with something half decent.

The frontier of design has slipped underneath the surface, into the intelligence layer, where the thinking happens.

The Interface Stops Being the Center

For 20 years, UX Design revolved around what users see and now it revolves around what systems understand and attempt to do.

Designing for agents means rethinking a handful of questions we thought we had already nailed down. How does this system explain itself when I ask? When should I intervene, and when should it ask permission before it moves? How much initiative is appropriate here, and how should it tell me it's uncertain without burying me in hedging or sycophancy?

The goal has shifted. Intelligibility matters more than ease now, along with alignment, and the trust both of those things earn over time.

Traditional UX assumed the world was deterministic. It assumed that states were predictable, manipulation was direct, and control was visible. You could map a flow because the flow didn't keep changing on you.

Agents exist on another plane entirely. They live in uncertainty, in autonomy, in decision-making and improvisation and negotiation. We also don't control them, they have a degree of …well "agency". This changes the dynamic Culkin described when he said "We shape our tools, and thereafter our tools shape us." - now they shape themselves too.

The foundational mental model of "user operates tool" collapses. We now have something closer to "user collaborates with intelligence." Our concerns as designers shift from affordance and hierarchy to trust, transparency, oversight, safety, and shared control.

Delegation Becomes a First-Class Interaction Pattern

Most UI lets users command and be in charge. Agents need patterns that let users delegate. "Solve this, not that." "Optimise for X." "Avoid Y." "Notify me only if…" The interface is no longer a set of buttons. It's a way of handing over a goal and trusting the right thing will happen.

Oversight becomes a primary UX surface, and not just a secondary settings panel tucked three clicks deep. We'll increasingly design interaction rules instead of interface layouts.

Behaviour Is the Material

Behaviours are grown and evolved over time.

We shape agentic behaviour the way a gardener shapes a climbing plant. Through context, with goals, with the prompts that tell it what to do and how to do those things well, with constraints that tell it where the walls are. With feedback loops, and a sense of personality, and a working memory of what it has done before. None of these are interface decisions but all of them are design decisions.

The design surface moves from pixels in space to behaviour in time.

"Alignment" is the word AI researchers use for the problem of making sure a system does what you actually want it to do, not just what you literally told it to do. It's the gap between the instruction given and the intent you meant when you wrote it. It's what happens when a system takes initiative and you have to decide whether it took the right one. It's what keeps a capable intelligence from being a dangerous one.

The Real Work Is Interaction Choreography

We'll design when the agent takes initiative and when it holds back. How it resolves conflict between what you asked for and what it sees. How it recovers from its own mistakes, and how it tells you it made one. How it expresses uncertainty without either over-claiming or drowning you in qualifications. How it negotiates shared intent when your goals and its goals don't quite line up. How it handles the edge cases none of us saw coming.

Instead of mapping flows, we architect protocols. Instead of wireframing screens, we scaffold reasoning. Instead of specifying output, we shape process.

The Agent-Oriented Design Loop

Most teams don't know how to start, so they keep doing screen-first design and bolting AI on top. It doesn't work. Agent design needs a different loop. Here's what it looks like:

observe → interpret → decide → act → reflect → adapt

This loop runs inside the system and inside the design process. It's iterative, exploratory, and behaviour-first. You prototype the thinking, and not the interface. Here's a quick example:

• Observe — The agent scans your calendar and notices you have back-to-back meetings for six hours with no break. What should it pay attention to? What should it ignore? These are design decisions.

• Interpret — It infers you're overbooked, but is that a problem or a preference? Maybe you like dense days. Maybe this week is an anomaly. How the agent interprets context and not just data is where alignment lives.

• Decide — It considers moving your 2pm, declining the optional standup, or just flagging the situation. Who taught it which option to prefer? You did, through the delegation model you designed.

• Act — It reschedules your 2pm and blocks 30 minutes for lunch. But it doesn't touch the client call, because it learned that external meetings are higher stakes. That is a design choice.

• Reflect — You override it. You wanted that 2pm where it was. The agent registers the correction. How does it store that feedback? Does it learn from one correction or need a pattern? That's a design question about learning rate and confidence.

• Adapt — Next week, it handles a similar situation differently. It asks instead of acting. The relationship between the agent and the user has evolved and that evolution is the UX.

The practical questions change shape. How does it decide? How does it ask for help? What does it ignore? When does it try something new, and when does it stop? Good agent UX depends less on clarity of UI and more on clarity of intent and alignment.

When you're designing for an agent, ask: How does it decide what to pay attention to? How does it know when to act versus when to ask? How does it recover when it gets it wrong? How does it earn trust over time? How does the user reshape its behaviour without micromanaging it?

We design the conditions that make that use-agent coordination feel effortless.

So What Does This Mean for Designers?

It means the craft expands. Behavioural design becomes something you really craft and is a meaningful part of your everyday job. You start working on delegation models, on agent architecture, on how reasoning itself can be a UX surface. Safety shows up on your work in a way it never used to, this is not just the policy team's responsibility anymore. Intent modelling, interaction choreography, alignment work… These will all be landing on your desk pretty soon if they haven't already.

It means that we need to be researching interpretability alongside usability. Understanding systems that think, and not just designing flows that users follow.

We're entering the most exciting period of design in decades. Screens will keep getting easier to generate and behaviour will keep getting harder to design well. The designers I can't wait to talk to are the ones who learn to shape living, adaptive systems that feel trustworthy, expressive, and deeply human.

I want to stress that this isn't speculative either, teams are already doing it. We need frameworks for it, and language, and methods, and critique that allow us to really craft great work in this space.