Agentic AI looks simple to ship. It isn't.

I spent time earlier this year writing a book about conversational AI.

The final chapters explore what happens when conversational systems stop answering questions and start taking actions. They introduce an agentic design framework, consequence classification and the shift from conversational to action-taking products.

Then I built one.

I built an agentic tool for my own website. Not a prototype. Something I intended real people to use.

A friend tested it.

They reached a point in the journey I hadn't fully mapped. The tool hit a dead end. Everything disappeared. No recovery. No memory. Just a hard stop.

I built the thing.

I'd already spent months thinking about these problems.

I still missed it.

That wasn't a bug in the interface.

It was a gap in my thinking.

I'd designed the interaction.

I hadn't designed what happened when reality stopped following the diagram.

That experience changed how I think about agentic AI.

It doesn't increase the complexity of the interface.

It increases the complexity of the experience.

I think many teams are about to discover the same thing.

Agentic AI looks deceptively simple to ship.

You define a goal.

Break it into steps.

Connect to a few APIs.

Give the model some tools.

Build a polished interface.

The demo works.

The scripted usability test works.

Then a real person arrives.

They hesitate.

They change their mind.

They get interrupted.

They refresh the page.

They lose their connection.

They ask something unexpected.

Suddenly the experience isn't linear anymore.

The gaps appear.

Traditional UX designs interactions.

Agentic UX designs systems that make decisions and take action.

That is a different job.

The difference between conversational AI and agentic AI is simple.

One informs.

The other acts.

When a conversational system gets something wrong, it usually creates friction.

When an agent gets something wrong, it creates consequences.

An email is sent.

A booking is cancelled.

A purchase is made.

A session disappears.

The design challenge is no longer helping people complete tasks.

It's making autonomous behaviour understandable, recoverable and trustworthy.

That is not an evolution of conversational design.

It is a different design problem.

Three principles I would build into every agentic product from day one.

1. Design the edges before the middle.

The happy path is rarely where products fail.

Map every interruption.

Every restart.

Every abandoned session.

Every point where someone changes direction.

The experience surface of an agentic product is far larger than the flow diagram suggests.

That was the mistake I made.

I designed a journey.

The real experience was a network.

2. Design for consequence, not completion.

Not every action deserves the same interface.

Low consequence actions should feel effortless.

High consequence actions should deliberately slow people down.

The interface should explain exactly what will happen, why it will happen and what cannot be undone.

A confirmation button at the end of a long workflow is not governance.

It is theatre.

3. Design recovery before autonomy.

Agentic systems will fail.

People will leave halfway through.

Models will misunderstand.

Browsers will refresh.

Recovery is not an edge case.

It is part of the core experience.

Memory.

Continuity.

Clear recovery paths.

These are not nice-to-have features.

They are fundamental parts of the experience.

I was fortunate.

A friend found the problem before users did.

Many teams will find theirs in production.

Engineering capability is moving faster than our design thinking.

The biggest challenge in agentic AI is not making systems more autonomous.

It is making them resilient when autonomy meets reality.

Agentic AI isn't creating another interaction pattern.

It's changing what UX designers are responsible for.

It's forcing UX to evolve beyond interaction design.

We should start designing like it.

These ideas build on the final chapters of my book, Designing Conversational AI, where I explore agentic design frameworks, consequence classification and the shift from conversational systems to action-taking AI products. Free to download