Progressive Disclosure in Agent Interactions: Showing the Right Information at the Right Time

The Problem of Information Overload

AI agents have access to vast amounts of information. The temptation is to dump everything relevant into a single response. This is the fastest way to lose a user's attention.

Progressive disclosure is the UX principle of revealing information in layers — showing the essential first, then offering deeper detail on demand. In conversational interfaces, this means structuring responses so users get what they need immediately and can drill down when they want more.

The Three-Layer Response Model

Structure every agent response in three layers: the summary, the detail, and the deep dive:

flowchart LR
    INPUT(["User intent"])
    PARSE["Parse plus<br/>classify"]
    PLAN["Plan and tool<br/>selection"]
    AGENT["Agent loop<br/>LLM plus tools"]
    GUARD{"Guardrails<br/>and policy"}
    EXEC["Execute and<br/>verify result"]
    OBS[("Trace and metrics")]
    OUT(["Outcome plus<br/>next action"])
    INPUT --> PARSE --> PLAN --> AGENT --> GUARD
    GUARD -->|Pass| EXEC --> OUT
    GUARD -->|Fail| AGENT
    AGENT --> OBS
    style AGENT fill:#4f46e5,stroke:#4338ca,color:#fff
    style GUARD fill:#f59e0b,stroke:#d97706,color:#1f2937
    style OBS fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b
    style OUT fill:#059669,stroke:#047857,color:#fff

from dataclasses import dataclass

@dataclass
class LayeredResponse:
    summary: str          # 1-2 sentences — the direct answer
    detail: str           # A paragraph with supporting context
    deep_dive: str        # Full explanation with examples and edge cases
    follow_up_prompts: list[str]  # Suggestions to drill deeper

def format_layered_response(response: LayeredResponse) -> str:
    """Format a response showing the summary with drill-down options."""
    output = response.summary

    # Always show the detail layer inline — it provides enough context
    # without overwhelming
    output += f"\n\n{response.detail}"

    # Offer the deep dive as an explicit option
    if response.deep_dive:
        output += "\n\n*Want more detail? Ask me to elaborate.*"

    # Suggest natural follow-up questions
    if response.follow_up_prompts:
        output += "\n\nYou might also want to know:"
        for prompt in response.follow_up_prompts:
            output += f"\n  - {prompt}"

    return output

# Example usage
order_response = LayeredResponse(
    summary="Your order ORD-7821 shipped yesterday and should arrive by Thursday.",
    detail=(
        "It's being delivered via FedEx Ground, tracking number "
        "9261290100130612345. The package left our Denver warehouse "
        "on March 16 and is currently in transit through Kansas City."
    ),
    deep_dive=(
        "Full tracking timeline: Picked March 15 2:30 PM, "
        "Packed March 15 4:00 PM, Label created March 16 8:00 AM, "
        "Picked up by carrier March 16 11:30 AM, In transit Kansas City "
        "March 16 9:00 PM. Estimated delivery March 19 by end of day. "
        "FedEx Ground typically delivers between 9 AM and 7 PM."
    ),
    follow_up_prompts=[
        "Can I change the delivery address?",
        "What if the package is delayed?",
        "Show me the full tracking timeline",
    ],
)

The user gets the answer in the first sentence. Everything else is optional context they can engage with — or ignore.

Context-Aware Detail Levels

The right amount of detail depends on who is asking and what they have already discussed:

from enum import Enum

class UserExpertise(Enum):
    BEGINNER = "beginner"
    INTERMEDIATE = "intermediate"
    EXPERT = "expert"

class DetailLevel(Enum):
    BRIEF = "brief"
    STANDARD = "standard"
    DETAILED = "detailed"

def determine_detail_level(
    expertise: UserExpertise,
    topic_familiarity: float,   # 0.0 to 1.0 based on prior questions
    explicitly_requested: DetailLevel | None,
) -> DetailLevel:
    """Determine appropriate detail level from context."""

    # User explicitly asked for more or less detail
    if explicitly_requested:
        return explicitly_requested

    # Experts on familiar topics get brief answers
    if expertise == UserExpertise.EXPERT and topic_familiarity > 0.7:
        return DetailLevel.BRIEF

    # Beginners on unfamiliar topics get detailed answers
    if expertise == UserExpertise.BEGINNER and topic_familiarity < 0.3:
        return DetailLevel.DETAILED

    return DetailLevel.STANDARD

DETAIL_TEMPLATES = {
    DetailLevel.BRIEF: {
        "max_sentences": 2,
        "include_examples": False,
        "include_caveats": False,
        "follow_up_count": 1,
    },
    DetailLevel.STANDARD: {
        "max_sentences": 5,
        "include_examples": True,
        "include_caveats": True,
        "follow_up_count": 3,
    },
    DetailLevel.DETAILED: {
        "max_sentences": 10,
        "include_examples": True,
        "include_caveats": True,
        "follow_up_count": 5,
    },
}

Follow-Up Prompt Design

Follow-up prompts are the conversational equivalent of hyperlinks. They guide users to the next logical step without requiring them to know what to ask:

def generate_follow_up_prompts(
    topic: str,
    user_action: str,
    remaining_info: list[str],
) -> list[str]:
    """Generate contextual follow-up prompts based on the current exchange."""

    prompts = []

    # Action-oriented follow-ups
    ACTION_FOLLOW_UPS = {
        "order_status_checked": [
            "Can I change the delivery address?",
            "Set up delivery notifications",
            "What's your return policy?",
        ],
        "return_initiated": [
            "When will I get my refund?",
            "Can I exchange instead of returning?",
            "Print my return label",
        ],
        "product_info_viewed": [
            "Compare this with similar products",
            "Check if it's in stock near me",
            "See customer reviews",
        ],
    }

    if user_action in ACTION_FOLLOW_UPS:
        prompts.extend(ACTION_FOLLOW_UPS[user_action][:3])

    # Information-gap follow-ups: suggest topics the user has not asked about
    for info_item in remaining_info[:2]:
        prompts.append(f"Tell me about {info_item}")

    return prompts[:4]  # Never overwhelm — cap at 4 suggestions

Implementing Expand/Collapse in Chat UIs

For rich chat interfaces, you can implement visual progressive disclosure with expandable sections:

interface CollapsibleSection {
  id: string;
  label: string;
  preview: string;       // Shown when collapsed
  fullContent: string;   // Shown when expanded
  defaultExpanded: boolean;
}

interface AgentMessage {
  mainContent: string;
  sections: CollapsibleSection[];
  followUpChips: string[];
}

// Example structured response
const orderStatusMessage: AgentMessage = {
  mainContent: "Your order ORD-7821 shipped yesterday. Delivery expected Thursday.",
  sections: [
    {
      id: "tracking",
      label: "Tracking Details",
      preview: "FedEx Ground - In transit, Kansas City",
      fullContent: "Tracking #9261290100130612345. Left Denver warehouse March 16...",
      defaultExpanded: false,
    },
    {
      id: "items",
      label: "Order Items (3)",
      preview: "Wireless Mouse, USB-C Hub, Laptop Stand",
      fullContent: "1x Wireless Mouse ($29.99)\n1x USB-C Hub ($49.99)\n1x Laptop Stand ($39.99)",
      defaultExpanded: false,
    },
  ],
  followUpChips: [
    "Change delivery address",
    "Full tracking timeline",
    "Start a return",
  ],
};

The main content answers the question. Collapsible sections let curious users explore. Follow-up chips make the next action effortless.

Measuring Disclosure Effectiveness

Track whether your progressive disclosure is working by measuring engagement depth:

DISCLOSURE_METRICS = {
    "expand_rate": "% of users who expand detail sections",
    "follow_up_click_rate": "% of users who click follow-up prompts",
    "elaborate_request_rate": "% of users who ask for more detail unprompted",
    "avg_turns_to_resolution": "Average conversation turns to task completion",
}

A high "elaborate request rate" means your default responses are too brief. A low "expand rate" means users are getting what they need from the summary — that is a good sign.

FAQ

How do I decide what goes in the summary vs. the detail layer?

The summary should directly answer the user's question in one to two sentences. The detail layer adds the context needed to act on that answer — dates, names, next steps. The deep dive contains everything else: history, edge cases, caveats. A useful test: if the user read only the summary and walked away, would they have the minimum viable answer? If yes, the summary is correct.

What if the user keeps asking for more detail endlessly?

Set a maximum depth and redirect: "I've shared everything I have on this topic. For more specialized information, I can connect you with a product specialist." This is both honest (the agent has limits) and helpful (it offers a path forward). In practice, very few users request more than two levels of elaboration.

Should follow-up prompts be static or dynamically generated?

Dynamic generation is better because it adapts to what the user already knows and what they have already asked. However, have a curated fallback set for each topic area. The hybrid approach — generate dynamically, then filter through a curated list of approved prompts — gives you relevance with quality control.

---

#ProgressiveDisclosure #InformationArchitecture #UX #AIAgents #ConversationDesign #AgenticAI #LearnAI #AIEngineering