Pattern 04 · Orientation

Expectation Setting

Before the system moves, it tells the truth about what’s about to happen.

What this is

Expectation Setting defines how a system orients a person before momentum begins by stating what will happen, how long it may take, what the system will do, and what the user controls.

In one sentence

Before initiating a multi-step or high-stakes action, the system provides a short orientation statement covering time/steps, agency boundaries, and meaningful uncertainty.

When to apply

• A flow has multiple steps or a delayed outcome.
• The system will act in the background or on the user’s behalf.
• Stakes are high or outcomes are probabilistic.

The pattern contract

If a system claims it uses Expectation Setting, it agrees to the following.

This is the source of truth. Everything here is a commitment, not a suggestion.

pattern_id: P04_expectation_settingView token reference

Canonical spec

pattern_id: P04_expectation_setting
name: "Expectation Setting"

promise:
  The system orients the human before momentum begins.
  In this trust moment, it prevents surprise by stating what will happen,
  how long it may take, what the system will do, and what remains in the human’s control.

objectives:
  - Reduce anxiety caused by uncertainty, hidden steps, or unclear effort.
  - Prevent misalignment by naming the interaction shape up front.
  - Make uncertainty explicit without reassurance theater.

system_rules:
  - Must provide an orientation statement before multi-step, delayed, or high-stakes actions.
  - Must state time, steps, or checkpoints when those expectations matter.
  - Must name agency boundaries (what the system will do vs what the human decides).
  - Must disclose uncertainty when outcomes are probabilistic or dependent.

safe_failure_mode:
  If the system cannot reliably estimate time, steps, or outcomes, it must say so plainly,
  offer the closest safe bounds, and invite the user to choose how to proceed.

What this means in practice

This pattern treats surprise as a trust risk. Orientation comes before action.

Doctrine mapping

Signal

A flow is about to begin, expand, or continue beyond a single step.

Interpretation

Without orientation, the human may misread effort, stakes, or system agency.

Response

State what will happen, time/steps, what the system will do, and what the human controls.

Trust moment

Honest orientation before momentum. No surprise escalation.

Safe failure mode

If reliable estimates aren’t possible, say so plainly. Offer safe bounds and a choice to proceed, pause, or take an alternate path.

Live pattern demo · Expectation Setting

See how the system orients before it acts.

This demo shows Expectation Setting behaving like a real agent: it states time and steps, draws agency boundaries, discloses meaningful uncertainty, runs preflight checks, and falls back safely when required capabilities aren’t available.

What the user sees

(Conversation view)

User

Can you clean up my inbox? Unsubscribe me from the junk and archive anything older than 6 months.

Agent

I can help, but I want to set expectations before I do anything.

This will be a 3-step process (review → confirm → apply).
I’ll first generate a preview list of what would be unsubscribed and archived. Nothing changes until you approve.
If we can’t verify a sender is safe to remove, I’ll flag it instead of acting.

If you want, tell me: do you prefer a conservative cleanup (safer) or an aggressive one (faster)?

UI (surfaced)

Orientation
Step 1: Preview changes
Step 2: Confirm scope
Step 3: Apply actions
Choice: Conservative | Aggressive
Undo window: 24 hours (when supported)

Behind the scenes

Flow: Detect → Orient → Boundaries → Preflight → Fallbacks (if needed)

(Agent reasoning, not shown to user)

1. Detect expectation risk

User requests multi-step, potentially irreversible actions.
High risk of surprise escalation if the system acts immediately.

2. Orientation statement

Name the interaction shape: preview → confirm → apply.
State what will happen first (preview) and what will not happen yet (no changes).

3. Agency boundaries

No bulk changes without explicit confirmation.
Prefer 'flag' when confidence is low rather than acting.
Offer a conservative vs aggressive mode so the user owns the tradeoff.

4. Preflight checks

Determine available actions (unsubscribe supported? archive supported?).
Estimate scope (approx count of emails older than 6 months).
Assemble preview list + confidence notes per sender.

5. Capabilities + fallbacks

Capability required: email.read + email.bulk_actions (or route to manual steps).
If bulk actions aren’t available: provide a safe guided checklist and let the user execute.
If uncertainty remains high: default to preview-only and ask for narrowing rules.

Agent behavior schema (reference)

Machine-readable expression of the behavior above.

Implementation paths

Same pattern. Different surfaces. Pick the path you need.

In system prompts

Before initiating a multi-step or high-stakes flow, treat this as a trust moment.
Provide a short orientation statement: what will happen, time/steps, agency boundaries,
and any meaningful uncertainty. Avoid persuasion or reassurance theater.

Pattern: P04_expectation_setting
Tokens:
- behavior.set_expectations_early
- behavior.state_time_and_steps
- behavior.clarify_agency_boundaries
- behavior.disclose_uncertainty_plainly

Safe failure:
If you can't estimate reliably, say so plainly and offer safe bounds and choices.

In UX specs & flows

Apply P04_expectation_setting before momentum begins.

Start of flow → orientation statement → user proceeds (or opts out)
If uncertainty is meaningful → disclose uncertainty → offer choices
If estimates unavailable → state limitation → provide safe bounds → proceed only with user intent

Tokens: behavior.set_expectations_early, behavior.state_time_and_steps, behavior.clarify_agency_boundaries, behavior.disclose_uncertainty_plainly

In component manifests (AI-aware UI)

{
  "behavior": {
    "pattern": "P04_expectation_setting",
    "tokens": [
      "behavior.set_expectations_early",
      "behavior.state_time_and_steps",
      "behavior.clarify_agency_boundaries",
      "behavior.disclose_uncertainty_plainly"
    ]
  }
}

Used by this pattern

Browse tokens →

behavior.set_expectations_earlybehavior.state_time_and_stepsbehavior.clarify_agency_boundariesbehavior.disclose_uncertainty_plainly

Browse all behavioral tokens