Designing agentic systems requires a different mental model than designing screen-based products.
When an AI can interpret intent, maintain context, and take action on a user’s behalf, traditional assumptions about states, flows, and control start to break down. The challenge isn’t execution, it’s how we frame the problem.
Agents don’t live inside screens:
They don’t assume linear progression.
They don’t rely on predefined flows.
They don’t wait for explicit taps.
They can initiate actions.
They aren’t bound to a single modality.
Designing agents means designing when decisions are made, constrained, reviewed, or reversed, not just how options are displayed.
AI agents aren’t screens you design
Traditional interfaces rely on predefined states, even when users move non-linearly. Screens, URLs, and flows give the system a clear sense of where the user is.
Agentic systems don’t have that certainty. State has to be interpreted in real time from partial, ambiguous input. The agent responds, initiates, interprets, and adapts without a fully predefined path, often taking actions the designer didn’t explicitly author.
This changes the designer’s role. You’re no longer defining exact flows or journeys.
You’re designing the boundaries, behaviors, and guardrails that shape how the intelligence operates.
Linear flows break down the moment intelligence enters the system
In screen-based systems, designers work with explicit states and defined transitions. Even when users move non-linearly, the system always knows where the user is.
In agentic systems, interaction is driven by language, intent, and context. Users don’t follow flowcharts, they express their thinking.
They ask half-questions.
They back up.
They jump forward.
They contradict themselves.
They forget context.
They switch tasks mid-sentence.
They come in anxious, emotional, distracted, or overwhelmed.
The interface no longer dictates the sequence. The agent has to infer state, decide what matters, and respond appropriately.
This raises new design questions:
- How does the agent handle uncertainty?
- How does it acknowledge confusion?
- How does it signal when it needs more information?
- How does it gracefully exit a dead-end?
- How does it help users who don’t know what they need?
Instead of designing flows, you start designing states of understanding.
The new mental model: AI agent interactions as a lifecycle, not a flow.
After months of struggling with this non-linear reality, I switched my mental model to a framework that actually makes sense:
Intent → Discovery → Evaluation → Commit → Fulfilment → Support
Users don’t move linearly through these phases. They loop back. They jump forward. They start at Evaluation and circle back to Discovery. The agent has to handle these non-linear movements gracefully while maintaining context.
- Intent: The user has a goal (often unclear at first)
- Discovery: Exploring options, gathering information
- Evaluation: Comparing, considering, deciding
- Commit: The moment of action (high risk actions like booking, payments)
- Fulfilment: The agent executes what was committed to
- Support: Ongoing help, changes, follow-up
This is where traditional flow-based models struggle. They assume sequential movement. AI agents require circular thinking. Users don’t progress neatly. They spiral through these phases, doubling back when they need clarity, jumping ahead when they’re confident, pausing when overwhelmed.
Your job as the designer is to make sure the agent can meet them wherever they are in this lifecycle and guide them gracefully through the non-linear journey.
You can’t design an agent with only UI thinking
This is where many designers get stuck.
In a screen-first world, language is microcopy.
In an AI-first world, language is the interface.
Suddenly, clarity becomes a safety principle. Tone becomes part of the UX. Question structure becomes part of the flow. Cognitive accessibility becomes more important than visual hierarchy. You start designing for:
- people who ramble
- people who struggle to find words
- people who talk in fragments
- people who switch modalities (text → voice → image)
- people who need grounding
- people who need the agent to slow down
- people who need the agent to take over
You’re not designing a chatbot. You’re designing a conversational partner, one who must remain predictable, inclusive, supportive, respectful, and clear.
This requires more emotional intelligence than visual intelligence.
Multimodality means the agent has to understand the world as humans do: through multiple senses
Multimodality alone doesn’t make a system agentic, but in agentic systems modality choice becomes part of the intelligence.
In a multimodal agent, the inputs are layered:
- Text brings intent.
- Voice brings emotion and nuance.
- Images bring context.
- UI brings structure.
- Tools bring action.
- Memory brings continuity.
- Embeddings bring long-term understanding.
- Reasoning brings coherence.
The question becomes: “How does the agent decide which mode to use when supporting the user?”.
Sometimes text is enough. Sometimes voice is more humane. Sometimes a short UI card or button prevents cognitive overload. Sometimes the agent should remain silent and wait.
Designers who think only in “screens” get overwhelmed here.
But once you understand that multimodality is just multiple access points into a single intelligence, it becomes beautiful.
You start to think like a coordinator, orchestrating modalities.
Not like a designer arranging buttons.
In practice, this often means coordinating specialized roles: interpretation, retrieval, planning, and action, whether they live within a single agent or across multiple agents working together.
You’re not designing one AI. You’re designing how different intelligences coordinate to serve the user seamlessly.
Multi-agent systems force you to think in terms of roles, not features
This is where things get even more interesting.
When you design a multi-agent system like a planner agent, a memory agent, a safety agent, a task-specific expert, you no longer design one AI. You design a team. And teams require:
- role clarity
- handoffs
- escalation pathways
- shared context
- error recovery
- consensus or arbitration
You’re basically designing the choreography of invisible experts. And your job as the designer is to make the combined intelligence feel coherent, predictable and safe, inclusive, and aligned with the user’s intent.
This requires systems thinking, not interface-first thinking.
It feels closer to service design, except the participants are digital systems with different capabilities.
The hardest shift is accepting that you cannot predict your user’s path anymore
Agentic systems operate over open-ended, inferred states rather than predefined ones. And this require a new philosophy of design:
- Instead of designing every possible path, you design the agent’s ability to handle any path.
- Instead of designing specific UI screens, you design the rules of engagement for the AI.
- Instead of designing outcomes, you design alignment with the user’s intent.
You move from being a designer of shapes to being a designer of intelligence boundaries. This is a different kind of creativity. A deeper one. A more responsible one.
The Commit Phase: where everything changes
Here’s what most designers miss.
There’s a moment in every AI interaction where the agent transitions from exploration to action. I call this the commit phase.
Before commit: The agent is helping you discover, evaluate, think through options. Low risk. Forgiving. You can change your mind. Nothing permanent happens.
After commit: The agent books your appointment, processes your payment, deletes your file, sends your email, orders your prescription. High risk. Often irreversible.
This is where design becomes critical. This is where you must:
- Make the transition explicit (“I’m about to book this appointment”)
- Get clear confirmation (not just “OK” but “Confirm booking for Tuesday at 3pm”)
- Provide rollback options (“Cancel within 5 minutes, no penalty”)
- Show what’s about to happen (preview the action before executing)
- Give users control (pause, review, modify before finalizing)
Designing for the commit phase isn’t just interaction design. It’s safety, ethics, and user protection built into the system.
This is where mistakes have consequences. Where user trust is won or lost. Where accessibility becomes life-or-death (what if a screen reader user didn’t catch that the agent was about to delete all their files?).
Most AI designers obsess over the conversational experience. But the commit phase is where your design decisions matter most.
You design the personality, not the polish
When an AI agent becomes a partner in thought, work, or emotional processing, the experience itself matters more than the interface. Trust is built through behavior:
- patience
- clarity
- transparency
- ability to admit “I don’t know”
- ability to ask for clarification
- ability to empower rather than overwhelm
These qualities shape trust far more than any interface ever could. The agent’s “personality” becomes part of your design material, and that personality needs guardrails.
Not too formal, not too casual, not too anthropomorphic, not too clinical, not too excited, and never manipulative.
You’re designing the relationship, not the layout.
In AI design, your real job is to protect the user from the machine’s confidence
This is something we don’t talk about enough.
- LLMs can sound sure of themselves even when they’re wrong.
- Agentic systems can take actions users didn’t expect.
- AI Agents can take actions the user didn’t expect.
- Voice interfaces can overwhelm people with too much information.
- Multi-agent systems can perform steps too quickly or too silently.
These aren’t model problems alone, they’re design problems. As designers, you won’t touch the base model, but you will shape how its confidence reaches the user.
You become the buffer, the layer of safety between human vulnerability and machine capability.
You decide when the system must slow down, when it should ask for permission, when it needs to explain itself, when to surface uncertainty, when to hand control back to the human, and when to stop.
This is the mental model I want you to hold moving into AI work
Not because it’s trendy, technical, or exciting.
But because it’s fundamentally human.
Designing AI is not just designing software.
It’s designing relationships.
It’s designing human-AI collaboration.
It’s designing shared cognition.
It’s designing two-way understanding.
If you can make this shift, your work will feel different. More grounded, more ethical, more accessible, and more real.
