AI agents aren’t just a feature—they’re changing how we design. Unlike static sites that wait for clicks, agents can plan and act across systems. It’s time to rethink Design Thinking for this new era—where intent, autonomy, and trust shape every solution.
Evolving the Double Diamond
Design remains an iterative process—but AI changes the speed and depth of each stage. With tools like M365 Copilot Researcher, research can go beyond surface-level searches, grounded on your user research to create rich, evidence-based personas. These personas humanize data and foster empathy across teams.
Not every problem needs an AI solution, but when it does, Microsoft’s AI Discovery Cards help stakeholders pinpoint where AI can deliver real impact. From there, the Microsoft AI Envisioning Framework prioritizes ideas through a human-centered lens—balancing desirability, viability, and feasibility.
Finally, with agentic coding assistants like GitHub Copilot and GitHub Spark, building a high-fidelity prototype can take as little time as sketching on paper—bringing faster feedback from real users and accelerating design iterations.
Microsoft Principles of Agentic Experiences
As agentic systems become central to digital experiences, Microsoft’s design principles provide a foundation for building agents that are trustworthy, adaptive, and human-centred. These principles—Agent Core, Time, and Space—help ensure every agent is not just functional, but also contextually aware and aligned with user needs.
Agent Core
Agent Core defines the agent’s identity, purpose, and boundaries.
- What it means: Every agent should have a clear sense of self—what it can do, what it stands for, and what its limits are. This includes its name, role, capabilities, and the policies or values it upholds.
- Why it matters: A well-defined core builds user trust and sets expectations. Users should always know who (or what) they are interacting with, and what the agent is empowered to do on their behalf.
- In practice:
- The agent introduces itself and its purpose clearly.
- It is transparent about its capabilities and limitations.
- It consistently reflects its core values and policies in every interaction.
Agent Time
Time is about the agent’s awareness of temporal context—past, present, and future.
- What it means: Agents should remember relevant history, understand the current moment, and anticipate what comes next. This includes tracking conversations, and ongoing tasks.
- Why it matters: Time-awareness enables continuity, learning, and proactive support. It helps agents provide contextually relevant responses, follow up on previous actions, and plan ahead.
- In practice:
- The agent recalls past interactions and uses them to personalize responses.
- It manages and reminds users of upcoming events, deadlines, or tasks.
- It adapts its behaviour based on the timing and sequence of user actions.
Agent Space
Space refers to the agent’s understanding of context—user, device, environment, and modality.
- What it means: Agents should be aware of where and how they are being used, adapting to different devices, channels, and user environments. This includes recognizing the user’s current context, preferences, and accessibility needs.
- Why it matters: Space-awareness ensures experiences are relevant, accessible, and seamless across platforms and situations.
- In practice:
- The agent adapts its interface and responses for mobile, desktop, or voice.
- It respects user preferences for language, accessibility, and privacy.
- It provides contextually appropriate information and actions based on the user’s environment.
Together, Agent Core, Time, and Space form the foundation for designing agentic experiences that are not only intelligent and capable, but also transparent, adaptive, and deeply human-centered. Every pattern and architecture in this book builds on these principles—ensuring your agents are trusted collaborators, not just tools.
Is SaaS Dead?
SaaS isn’t dying—it’s evolving. The future of cloud design is not about abandoning SaaS but about recognizing how the UI is transforming: from static screens to intelligent agents, from app destinations to outcome-driven orchestration. The “app” dissolves into APIs and policies, and value shifts from time spent in screens to measurable business results. The winners in this new era will treat agents as first-class clients—endowed with identity, guardrails, and metrics—not as chatbots pasted on top of legacy products.
From Apps as Destinations to Agents as the UI. For two decades, we trained users to “go to the app.” The workflow was rigid: navigate, click, export, re-import, repeat. This model made users responsible for carrying context and stitching together fragmented experiences.
Agentic UX flips this script. Now, users’ express intent, “file this expense,” “reconcile these invoices,” “summarize last quarter’s feedback”, and a trusted agent plans, acts, and reports, traversing products and data without forcing the human to manage context. The agent becomes the interface, orchestrating outcomes across boundaries.
What fundamentally changes:
- Surface: We move from pages and menus to prompts, forms, and flows that capture intent directly.
- Control: Instead of users driving every click, agents operate with bounded autonomy—subject to confirmations, thresholds, and policy.
- Feedback: Silent systems are replaced by agents that explain their actions with provenance: “Here’s what I did, and why.”
- Distribution: Instead of URLs and app stores, agents meet users where they already work—chat, voice, email, IDE, or shell.
If chat was Web 1.0 for agents, intent orchestration is Web 2.0: user goals are compiled into tool calls, with identity, policy, and telemetry wired in from the start.
The Coexistence Curve
This evolution is not a cliff, but a curve with three overlapping stages:
Stage 1: SaaS
In the Software-as-a-Service (SaaS) model, users interact primarily through dedicated application UIs. These are the familiar screens, menus, and dashboards where every action requires manual navigation and clicks. Behind the scenes, teams build CRUD operations and workflow logic that power these interfaces. Success in this stage is measured by engagement metrics such as Monthly Active Users (MAU), the number of seats sold, and feature usage. The focus is on adoption and time spent in the app.
Stage 2: SaaS + Agents
The next evolution introduces agent entry points inside or alongside the app. Users can now interact through conversational or intent-driven interfaces embedded within existing SaaS products. On the backend, teams build orchestrators that leverage existing APIs, integrate Retrieval-Augmented Generation (RAG) for contextual answers, and implement approval workflows for safe automation. Value shifts from raw usage to task-centric metrics—how many tasks are completed, how quickly they’re resolved (Time to Resolution), and the coverage of safe autonomous actions.
Stage 3: Agent Native
Signals you’re crossing the curve:
- “Page view” metrics become less relevant than “workflow closed.”
- Product notes list tools the agent can use, not just screens.
- Policies (what the agent may do) are published alongside APIs (how it does it).
- KPIs include groundedness, escalation, and auditability.
The Agent Adoption Framework
To future-proof your portfolio, use this four-path framework:
- Wrap (fastest): Place an agent in front of existing SaaS. When APIs are solid and you need value this quarter, add an agent layer that plans tasks, calls APIs, and surfaces progress/explanations. Guardrails: identity OBO, allowlisted actions, thresholds for auto vs. ask.
- Embed: Ship agent entry points inside the app, as part of the user workflow. Add explainability panels and human in the loop approvals. Include library for response confirmations, activity feeds, and evaluation hooks to log telemetry.
- Decompose: Turn features into intent-centric services. Expose verbs as capabilities (“Generate Proposal,” “Reconcile Expense”) with policy and identity built in. Your Apps and Platforms become a toolbox for agents; easily discoverable and supports internal reuse.
- Replace (bold): Go agent-native for a workflow or product. Design the intent model, guardrails, and SLAs first; build minimal UIs for explainability, approvals, and restore.
Agentic Experiences
From a user experience perspective, instruments of trust should be surfaced through clear explanations of why and how decisions were made, and what happens next. This can be achieved by displaying source chips, policy badges, and providing users with a copyable trace link for every significant action.
Here’s an illustration for an Agentic Banking solution. Would you be able to identify the principles of Agentic Experiences and its application? Are the UI elements sufficient to earn trust?
What’s Next?
Agentic experiences begin with a shift in mindset. The decades of apps and services we know won’t vanish overnight—but the way we think about them must. To truly empower users, we need to move beyond screens and clicks toward goal-oriented, agent-native solutions that deliver outcomes, not just interfaces.
This is the frontier of design and technology—where autonomy, trust, and human-centered principles converge. The next era isn’t about building more apps. It’s about building agents that work for people. Let’s design that future—together.
Read more about the transformations from my upcoming book, Architecting Impact: Agentic UX and the Future of Cloud Design…
Thoughts 