Start from the moment the user is in, not the component you want to build.

Working with an agent runs through nine moments, from not knowing what to ask, through handing over authority, to living with what the system remembers. Each one puts a specific problem in front of the user and a specific tradeoff in front of the designer.

A send button is not an agentic pattern. A send button that shows what the agent is about to send, who approved it, and how to stop it is three of them. The 73 patterns below are mapped to the moment they serve, and grouped again by what they are.

The nine moments

Follow a task from the first visit to months of use. Open a moment for its tradeoff and checklist, or jump straight to a pattern.

  1. Before the first ask

    The user has arrived but does not know what the system is for, what it can reach, or what it will do with what they give it.

    7 patterns
    Capability disclosure Starter prompt gallery Example gallery Contextual nudge AI identity: name and persona AI visual language Consent and data ownership
  2. Forming intent

    The user knows roughly what they want and has to turn it into something the system will act on correctly.

    9 patterns
    Prompt template / fill-in form Madlib prompt Multimodal drop zone Reference token layering Inline action menu Ghost completion Prompt enhancer Randomize Follow-up suggestions
  3. Shaping the work

    The request is understood; now the user needs to set the constraints — scope, tools, voice, effort — that decide whether the result is usable.

    8 patterns
    Parameter panel Style and voice presets Modes and personas Model and effort switch Connectors Scoped region edit Workspace scoping Context inventory
  4. Reviewing the plan

    The agent has decided what it intends to do, and the user has one chance to catch a wrong plan before it becomes wrong work.

    4 patterns
    Plan preview Dry run preview Draft mode Cost estimate
  5. Granting authority

    The user has to decide how much the agent may do on its own, and the system has to enforce that decision per action, not per session.

    4 patterns
    Autonomy level selector Action approval gate Scope and tool permissions Interrupt and kill switch
  6. While it runs

    Work is happening that the user is not doing, and they need to know it is progressing, what it is touching, and how to stop it.

    8 patterns
    Live step stream Token streaming Long-run progress Background run tray Scheduled agent runs Ambient triage Silent enrichment with reveal Progressive UI streaming
  7. Judging the output

    The result is in front of the user and they have to decide whether to rely on it — usually without the time or expertise to verify it fully.

    16 patterns
    Inline citations Confidence signalling Reasoning trace Source freshness and coverage Verification handoff Caveat Completion receipt AI-made label Content credentials panel Synthetic media disclosure Edit attribution history Agent identity chips Agent-selected components Inline generated form Composed dashboard Artifact canvas
  8. When it's wrong

    The output missed, or the run failed, and the user needs a path back that costs less than starting over.

    13 patterns
    Regenerate with instruction Approve with edits Branches Variations Result filter and facets Rated response with reason Report and escalate Quiet failure surfacing Escalation to human Mid-stream takeover Context packet transfer Shared review queue Return to agent
  9. Over time

    The same user comes back, and the system either accumulates useful understanding of them or makes them repeat themselves forever.

    4 patterns
    Memory manager Correction memory Forget and expire Recall attribution

What changed in 2026

The shifts that shaped which patterns made it into this guide.

Chat stopped being the product.

The interface moved to plan previews, run logs, and approval queues: surfaces for supervising work, not conversing.

Autonomy became a dial, not a switch.

Gating moved from per-agent to per-action, priced by reversibility and blast radius.

Generative UI arrived as a real pattern.

It comes in three shapes: the agent picks from a typed component library, fills a slot, or composes layout at runtime.

Provenance turned into compliance.

Content Credentials and watermark disclosure are now design surfaces with legal deadlines attached.

Trust research hardened the brief.

Observed accuracy beats stated confidence, and rubber-stamped approvals are worse than no gate at all.

Twelve element families

The same 73 patterns grouped by what they are rather than when they are used. Use these names in critique.

Wayfinders7

Give users clues about what to ask for and how to start, before they know the system's shape.
Inputs6

Turn vague intent into something a model can act on, without making the user write a specification.
Tuners7

Let people shape output after the first result, so a near-miss becomes usable without starting over.
Governors7

Decide what the agent may do alone, what needs a human, and how anyone stops it mid-flight.
Trust indicators7

Help users decide when to accept, when to verify, and when to escalate — without faking precision.
Dark matter5

The AI that runs while nobody watches — background work that must stay legible and interruptible.
Identifiers7

Say what was made or touched by a machine, by which machine, and on whose authority.
Feedback & correction7

Make being wrong cheap: let users fix output fast and let the fix inform the next run.
Agent status & progress5

Show what the agent is doing now, what it did already, and what it is about to do next.
Memory & context5

Make what the system remembers visible, scoped, correctable and forgettable.
Human handoff5

Move work between agent and human without dropping context or leaving the user stranded.
Generative UI5

Interface assembled at runtime by the agent — chosen, filled, or composed rather than pre-drawn.