AI Agents for Beginners - 3. Agentic Design Patterns

A guide to Agentic Design Principles (Space, Time, Core) and three practical patterns — Clear Instructions, Structured Output, and Single Responsibility — for building effective AI agents.

June 8, 2026

ai ai-agents

AI Agents for Beginners - 3. Agentic Design Patterns

This article summarizes Lesson 03 of Microsoft's AI Agents for Beginners course.

Source: microsoft/ai-agents-for-beginners - 03-agentic-design-patterns

Agentic Design Principles

When building AI Agentic Systems, it can often feel overwhelming knowing where to start.
In Generative AI design, ambiguity is a feature, not a bug.
Microsoft provides a set of human-centered UX Design Principles to help developers build customer-centric agent systems.

Fundamentally, agents should strive to:

Amplify human potential (brainstorming, problem-solving, automation)
Fill knowledge gaps (domain learning, translation, etc.)
Support collaboration in each individual's preferred way
Help us become better versions of ourselves

The Design Principles consist of three dimensions (Space, Time, Core):


Agentic Design Principles
Mermaid
flowchart TD
    AP["Agentic Design Principles"]
    AP --> Space["Agent (Space)\nDesigning in physical and digital environments"]
    AP --> Time["Agent (Time)\nDesigning behaviors across the timeline"]
    AP --> Core["Agent (Core)\nCore agent elements"]

    Space --> S1["Connecting, not collapsing\nConnecting people, events, and knowledge"]
    Space --> S2["Accessible yet invisible\nNudging only when necessary"]

    Time --> T1["Past\nReflecting history and utilizing memory"]
    Time --> T2["Now\nNudging more than notifying"]
    Time --> T3["Future\nContinuously adapting and evolving"]

    Core --> C1["Embrace uncertainty\nUncertainty as a key design element"]
    Core --> C2["Establish trust\nEnsuring transparency and user control"]

Agent (Space)

These principles address the environment in which the agent operates. They define how agents interact with people across physical and digital spaces.

Connecting, not collapsing — Agents enable collaboration by connecting people to each other, to events, and to actionable knowledge.
Rather than replacing or ignoring humans, agents are designed to bring people closer together.

Easily accessible yet occasionally invisible — Agents operate primarily in the background, offering nudges only when relevant and timely.

Easily accessible to authorized users across any device or platform
Supports multimodal input and output, such as voice and text
Seamlessly transitions between foreground/background and proactive/reactive modes based on user needs
Background processing paths and collaborations with other agents are transparently visible and controllable by the user

Agent (Time)

These principles address how agents operate over time.

Dimension	Principle	Description
Past	Reflecting on history	Analyzes past events, states, and context to provide more relevant results. Actively leverages memory
Now	Nudging more than notifying	Goes beyond simple alerts when events occur to streamline workflows or draw user attention at the right moment
Future	Adapting and evolving	Adapts across diverse devices, platforms, and modalities. Continuously evolves based on user behavior and accessibility needs

Agent (Core)

The core elements of agent design.

Embrace uncertainty but establish trust — Uncertainty is an integral part of agent design, but trust and transparency must serve as its foundation.

Uncertainty in agents is to be expected and must be embraced in the design
Trust and transparency form the bedrock of agent design
Humans control when the agent is turned on or off, and status is always clearly indicated

Implementation Guidelines

Three guidelines to follow when putting Design Principles into practice:

Guideline	Description
Transparency	Informs users that AI is involved, how it operates (including past actions), and how to provide feedback
Control	Enables users to customize the system, specify preferences, and delete their data
Consistency	Delivers a consistent multimodal experience across devices and endpoints, minimizing cognitive load

Applying these to the design of a Travel Agent:

Transparency — Clearly identify itself as an AI Agent, document usage limits, and provide thumbs up/down feedback
Control — Make clear how to adjust system prompts and allow deletion of chat history and uploaded files
Consistency — Use standard UI elements, such as a paperclip icon for file uploads and an image icon for image uploads

Design Patterns in Practice

Building on these design principles, we implement a Travel Destination Recommender step by step.

Pattern 1: Clear Agent Instructions

The most effective and straightforward pattern. Provide the agent with clear and detailed instructions.

Good instructions define:

Who — Persona and tone of the agent
What — Step-by-step responsibilities
How — Constraints and style


pattern1_clear_instructions.py
python


Pattern 1: Clear Instructions Flow
Mermaid
zenuml
    title Pattern 1: Clear Instructions Flow
    User->TravelConcierge: great food and history trip, budget $2500
    TravelConcierge->LLM: process with persona and constraints
    LLM->TravelConcierge: understand preferences and plan response
    TravelConcierge->User: personalized suggestion with visa and best season

Clear instructions ensure that the agent behaves consistently and stays on-brand.

Pattern 2: Structured Output with Pydantic Models

While free-form text is great for conversation, downstream systems require structured data.
Combining Pydantic models with tool functions lets you define a response schema and validate it automatically.


pattern2_structured_output.py
python


Pattern 2: Structured Output Flow
Mermaid
flowchart TD
    User["User\n'3 culture destinations under $2500'"]
    --> Agent["StructuredTravelExpert\ntool: get_destination_details"]
    Agent --> LLM["LLM\nDetermine candidate destinations"]
    LLM --> T1["get_destination_details('Barcelona')"]
    LLM --> T2["get_destination_details('Tokyo')"]
    LLM --> T3["get_destination_details('Cape Town')"]
    T1 & T2 & T3 --> Validate["Pydantic validation\nDestinationRecommendation schema"]
    Validate --> Output["TravelRecommendations\n(Structured JSON response)"]

Pattern 3: Single Responsibility Agents

Complex tasks are far more effective when distributed among multiple single-responsibility agents.
This applies the software engineering principle of separation of concerns to agents.


pattern3_single_responsibility.py
python


Single Responsibility Agents Flow
Mermaid
zenuml
    title Single Responsibility Agents Flow
    User->DestinationExpert: culture and food trip under $2500
    DestinationExpert->Tool: get_destination_details(destination)
    Tool->DestinationExpert: destination info
    DestinationExpert->User: ranked destination list with pros/cons
    User->LogisticsPlanner: plan based on recommendations
    LogisticsPlanner->User: day-by-day itinerary and logistics

When each agent has a single, well-defined role, testing, maintenance, and composition become significantly easier.

Summary

Comparing the three Design Patterns:

Pattern	Key Idea	Benefit
Clear Instructions	Define persona, responsibilities, and constraints clearly upfront	Ensures consistent, on-brand agent behavior
Structured Output	Define response format using Pydantic models	Validated machine-readable output, easy system integration
Single Responsibility	Assign a single, focused role to each agent	Modular design that makes testing, maintenance, and composition easier


Lesson 03 Summary
Mermaid
flowchart LR
    Root["Agentic Design"]
    Root --> Principles["Design Principles"]
    Root --> Guidelines["Guidelines"]
    Root --> Patterns["Design Patterns"]
    Principles --> PR1["Space\nConnecting/Accessible"]
    Principles --> PR2["Time\nPast/Now/Future"]
    Principles --> PR3["Core\nTrust/Uncertainty"]
    Guidelines --> G1["Transparency"]
    Guidelines --> G2["Control"]
    Guidelines --> G3["Consistency"]
    Patterns --> P1["Clear Instructions"]
    Patterns --> P2["Structured Output"]
    Patterns --> P3["Single Responsibility"]

Agentic Design Principles outline the direction of agent design across three dimensions: Space, Time, and Core.
Build user trust through the guidelines of Transparency, Control, and Consistency.
Combine Clear Instructions → Structured Output → Single Responsibility patterns to build production-ready systems.

PreviousAI Agents for Beginners - 4. Tool Use Design Pattern

NextAI Agents for Beginners - 2. Explore Agentic Frameworks