Human-centered design for agents

Designing a great agent experience goes beyond crafting the right prompt. It means building a complete interaction system where every surface, response, and failure state works together to support the user. This article introduces the design tools and principles that help you do that—from the Fluent UI components that provide visual consistency to the lifecycle design patterns that keep users confident from first interaction to error recovery.

Fluent UI

Banner representing the Fluent UI for agent design.

Fluent UI provides the visual and behavioral foundation for agents. Its components are reusable and accessible. When you design with Fluent UI, you're working within a system that's already aligned with Microsoft's visual language. That means less customization overhead and more consistency for users across the Microsoft 365 ecosystem.

  • Design for consistency and coherence. Use Fluent AI controls to maintain visual and behavioral alignment across Microsoft's agents and the broader Microsoft 365 Copilot ecosystem. When users move between agents, familiar components reduce cognitive load and build trust.

  • Design for accessibility and responsiveness. Adopt Fluent UI React v9 components. Version 9 delivers improved accessibility support, responsive behavior, and better performance compared to earlier versions. For a designer audience, this means your layouts adapt correctly across screen sizes and input modalities without requiring custom overrides.

  • Design for component selection and customization. The Fluent UI Web Components library is your source of truth for available patterns. It includes toggle buttons, compound buttons, dialogs, menus, tabs, and related primitives. Start from these patterns before introducing custom components.

  • Design for performance and optimization. Minimize bundle size through intentional component usage. Avoid unnecessary overrides. Rely on Fluent's theming and token system for visual customization instead of hardcoded styles—this keeps your agent consistent with future platform updates.

Important principles for agents

When designing agents, it's important for them to be trustworthy, honest about their nature, and designed with awareness of their broader impact. Three core principles can help guide your design decisions. Agents should be:

  1. Built for intent - Agents support the user, they don't replace judgment. It's important to clearly communicate capabilities and limitations, keep outputs editable and provide visible controls for refinement, and design interactions that reinforce user ownership. In practice, this principle means using language like "Summarize with Copilot" rather than "Copilot, summarize", keeping the user as the one initiating action.
  2. Differentiated from humans - Agents generate responses, they don't think or feel. Use neutral, technology-oriented language. Avoid emotional or human framing. Keep tone transparent and task-focused. Avoid words like "understand," "think," or "feel", use words like "process" or "analyze" instead.
  3. Bias resistant - Agent outputs might impact more than the primary user. Design with awareness of how content might be shared or reused. Anticipate risks and include mechanisms for review and correction. Ask your team: Who else might see or act on this output? What are the unintended consequences if the agent fails or is misused?

For additional guidance about responsible agent design, see the article When AI joins the team: Three principles for responsible agent design.

Designing across the lifecycle

Design agent experiences as complete interaction systems, not isolated prompts. Each agent should support the full user journey—from first exposure and expectation setting, through active collaboration, to correction and recovery when outputs are imperfect. Designing across these stages ensures clarity, trust, and sustained usability.

First run experience

The first interaction sets the tone for the entire agent relationship. When users access the agent for the first run:

  • Clearly communicate what it's designed to help with. Provide example prompts, common use cases, and visible entry points that guide users toward meaningful tasks.
  • Set expectations about output quality. Clarify that responses might vary and that outputs can require review or refinement. Avoid overstating capability.
  • Reduce ambiguity and encourage exploration. Early transparency builds trust, reduces misuse, and helps users form accurate mental models of how the system behaves.

During interaction

While users actively work with the agent:

  • Align with established application patterns. Controls, layout, and terminology should feel consistent with the surrounding product environment.
  • Support iterative refinement. Users should be able to adjust prompts, narrow scope, request clarifications, or edit generated content directly. The interaction should feel collaborative rather than transactional.
  • Surface content when it's relevant. If the agent relies on specific files, selections, or data sources, surface that information clearly. Maintaining responsiveness, accessibility, and predictable behavior is essential to sustaining user confidence.

When the system is wrong

Agent outputs are occasionally incomplete, inaccurate, or misaligned with intent:

  • Provide clear and efficient correction pathways. Users should be able to re-generate responses, revise prompts, or manually edit outputs without friction. Avoid forcing users to restart workflows.
  • Surface contextual signals. Where appropriate, surface referenced data or assumptions to help users understand why a response was generated. Transparency and recoverability reinforce user control and prevent frustration.

Related content

  • Last updated on