Design for AI: AI Agents Explained
A simple guide to understanding and designing agentic experiences and AI Agents.
It's no news that we’re moving beyond traditional product design. We’re no longer just creating apps with fixed flows and predictable outcomes. We're building AI-powered systems, tools that learn, generate, adapt, and… surprise us.
And if that is not intimidating enough, here’s another layer: Tools can now act on your behalf. They plan, decide, take initiative, collaborate, and learn over time. I'm talking about agentic systems (or AI agents).
So how do you keep up?
Especially if you’re not actively working on these kinds of systems (yet).
Personally, I started by making sense of it - understanding what “agentic” means and what's different about how these systems behave.
Note: This article was not written by an engineer or from an engineering perspective.
What Does “Agentic” Even Mean?
In psychology the term agentic describes the human ability to act with intent: imagine futures, set goals, revise course, learn over time.
Now, the systems we’re building are starting to echo that behavior. We’ve given them memory, reasoning, autonomy, and the ability to use tools to get things done.
Agentic systems behave more like collaborators than interfaces.
This is different from most AI-powered products, where the system enhances a fixed experience (like search or autocomplete).
How the Major Players Define Agents
During my research, I came to the conclusion that there is no general definition of what an AI Agent is. Mostly because the big players are solving different problems with their agents and technology.
Agent definition from Anthropic:
“Agents are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.”
Agent definition from OpenAI:
“Agents are systems that independently accomplish tasks on your behalf.”
Agent definition from Google:
“AI agents are software systems that use AI to pursue goals and complete tasks on behalf of users. They show reasoning, planning, and memory and have a level of autonomy to make decisions, learn, and adapt.”
The takeaway is this: an agent is any system where the AI decides what to do next, not just responds to what you ask.
How Agents Actually Work
The real difference between a normal AI and an agent is autonomous action.
An agent is different because it has access live tools, like a web browser, your calendar, or an API. For example, when you ask an agent to plan that trip, it decides on its own what to do next: execute a search on a real travel site, read the live pricing, and draft a real email.
What an AI agent is not:
A chatbot that only responds when you type something
Autocomplete, recommendations, or “smart” suggestions
A rules-based automation that follows a script without adapting
The AI Agent Building Blocks
Agentic systems combine multiple capabilities to work and take initiative:
Objective
With most software, you have to be the manager. You give step-by-step instructions: click this, type that, save file. Agents work on objectives. You define the outcome, “Find a flight under $600”, and the system figures out the steps to get there.
Reasoning
Reasoning is how the agent decides what to do next. It’s the internal process that weighs options, checks constraints, and chooses a direction:
Should I search first, or ask a follow-up question?
Do I have enough information, or do I need more context?
Planning
Before running off to do tasks, the system pauses to create a sequence. It identifies dependencies: “I can’t book the hotel until I know the flight dates.” It’s not just making a list; it’s structuring the order of operations so it doesn’t get stuck halfway through.
Tool Use
This is the most critical part. Most AI models are trapped in a text box, they can only talk to you. Agents are given permission to “leave” the text box. We connect them to external software: web browsers, or APIs. When the agent realizes it needs live data (like today’s stock price), it triggers the tool to get the actual answer.
Memory
You can’t collaborate with someone if they forget everything you said two minutes ago. Agents maintain a running log of the project.
Short-term: It remembers the flight dates you just discussed so you don’t have to repeat them.
Long-term: Ideally, it recalls preferences from past sessions (like “No early morning flights”) so it stops making the same mistakes.
Examples of what agents can do today:
Plan your trip: You say, “Book a weekend in Paris under $2000.” The agent checks your calendar, finds flights, and gives you options to review and approve.
Fix bugs: You assign a bug. The agent reads the code, finds the issue, tests a fix, tries again if it fails, and pushes the result to GitHub.
Online Shopping: You say, “Find a new office chair under $400.” The agent searches multiple stores, compares options, filters by your preferences, and presents a short list with pros and cons for you to choose from.
Tools you can use to build or use AI agents:
ChatGPT Agent / Manus / Claude
Agent Orchestration
For complex tasks, it’s usually better to split the work across multiple agents, just like you would with a human team.
Instead of asking one model to be good at everything (planning, coding, and writing), we can assign specific roles to specialized agents. For example:
The Planner: Breaks down the user’s request into steps.
The Executor: Actually uses the tools (like running code or searching the web).
The Evaluator (or Critic): Reviews the work to make sure it matches the request.
The Retriever: Digs through files or memory to find the right context.
How They Work Together
Once you have these different roles, you need a way for them to collaborate. This is called orchestration, and it usually follows one of three standard patterns:
Sequential Chain (The Pipeline): A linear flow where for example, agent A researches, agent B writes, agent C edits. Best for predictable workflows.
Hierarchical (Hub-and-Spoke): A central “manager” agent assigns tasks to specialized “worker” agents. The workers report back to the manager, who acts as the gatekeeper.
Collaborative (Shared Workspace) Agents work in a shared space and contribute when their skill is relevant. No fixed order or leader.
All this collaboration creates a new challenge: How do these agents actually connect to your data without breaking things?
You might have heard about MCP (Model Context Protocol). Think of it like a universal USB port for AI agents. MCP is an open standard that lets agents connect any external collection of tools and resources.
Designing Agentic Experiences
When you design a standard app, you are designing screens.
For agentic experiences, you are designing behaviors.
You are no longer working with just pixels and interaction flows. You are designing with new materials: memory, planning, reflection, and autonomy.
This introduces a whole new set of challenges.
Here is how to tackle them.
Designing for Risk
This is the most important concept in agentic design.
If a standard chatbot hallucinates, you get a weird sentence. If an agent hallucinates, it might book the wrong flight or overwrite a database. We have to treat agents like unsupervised interns. And since you can’t “un-send” an email or “un-delete” a server, we have to move away from “undo” patterns (fixing it after it happens) and toward “preview” patterns (checking it before it happens).
Core question: How do we prevent irreversible harm when agents act?
3 UX Patterns to Manage Risk:
Human-in-the-Loop: The agent prepares actions but does not execute irreversible ones on its own. Drafts, previews, and confirmations keep the human in control.
Preview Before Action: Before touching real data or systems, the agent shows exactly what will happen. Users review the outcome before approving execution.
Permission-on-Demand: The agent asks for access only when it actually needs it. Permissions are scoped, explicit, and time-bound.e.
Designing for Trust
Agents are complex and often slow. If an agent just spins a loader for 30 seconds and then says “Done,” users won’t trust it. They need to know how it got there. To build trust, we have to make the invisible visible.
Core question: How does the user understand and supervise what the agent is doing?
3 UX Patterns to Build Trust:
Plan Visibility: The agent shows what it intends to do. A simple task roadmap helps users anticipate actions instead of being surprised by results.
Agent Transparency: Progress, retries, and failures are visible. Instead of silent loaders, users see effort and status as the agent works.
The Steering Wheel: Allow users to pause the agent mid-task. If you see the agent going down a wrong path in step 2, you should be able to stop it and correct the plan before it gets to step 3.
Designing Memory
An agent that forgets every time is annoying. Memory needs to be visible, adjustable, scoped, and resettable.
Core question: How does an ongoing relationship stay aligned over time?
3 UX Patterns for Memory:
Memory Control: Users can see, edit, and reset what the agent remembers. Memory becomes a shared workspace, not a black box.
Contextual Memory: What’s remembered is scoped to a task, project, or domain. Information from one context doesn’t leak into another.
Memory Awareness: When past information influences a decision, the agent signals it. Users understand why something happened.
… What’s Next?
Start by using AI agents. Notice how they behave, how they respond, what they get right (and wrong). Try building simple flows with tools like ChatGPT or Manus to get a feel for systems. Push buttons. That curiosity turns into intuition. Work with a mentor who’s actively building or designing AI agents. Follow the brilliant minds already sharing insights and building in the open.
📚 Dive Deeper:
Anthropic Engineering: Building Effective Agents
Google Cloud AI Glossary: Definition of AI Agents
UX patterns by Google: Google PAIR Guidebook
UX patterns by Microsoft: Microsoft HAX Toolkit
UX patterns by IBM: IBM Design for AI
👀 More UX + AI Reads:
Closing Thoughts 💭
We’re moving into a world shaped by autonomous technology. Full of new possibilities, but also new responsibilities. It’s still early, and a lot is evolving. But as designers and product people, we can’t just focus on what we’re building, we need to ask what this shift means for businesses and for real people.
Are we heading toward a UI-less future, where products aren’t interfaces but ingredients for agents to use? Maybe. That possibility forces us to rethink where value lives, what we’re actually designing, and who we’re designing it for.
Thanks for reading! 🫶
Let’s Collaborate 💫
Open to Substack collaborations (I’m one DM away!)
1:1 AI + Design deep dives for creatives, designers, and product people - Book here!
UX, AI Product Design, Building for entrepreneurs and teams - Free chat!
The most underestimated risk of agents isn’t autonomy.
It’s the speed of failure.
A bad interface fails locally.
A bad agent scales the mistake.
If limits aren’t designed first, you’re not building intelligence —
you’re accelerating impact.
Design implications are underrated - agentic systems need different UX patterns than chatbots. You're not designing conversations, you're designing supervision interfaces and escalation flows.
My agent's UI is mostly status dashboards and override controls, not chat interfaces. The mental model shift is hard: from "tool I use" to "teammate with specific capabilities." Most agent UX still looks like glorified chatbots because designers haven't internalized what autonomous operation actually means.