Strategies

A strategy is a pure mapping from energy level to behavior configuration. The SDK doesn't dictate what happens at each level - it provides the state, and strategies decide what to do with it.

The model

interface AdaptationStrategy<TConfig> {
  name: string
  describe(level: EnergyLevel): string // human-readable summary
  resolve(level: EnergyLevel): TConfig // compute the config for a level
}

Strategies are pure functions with no side effects, so they're trivially composable - an app resolves several at once:

const ui = engine.resolve(uiVisibilityStrategy)
const notifications = engine.resolve(notificationStrategy)

In React, useStrategy(strategy) resolves against the current level and re-renders on change. To write your own, see Authoring strategies.

The built-ins

uiVisibilityStrategy

Progressively simplifies interface chrome as energy drops. Resolves to a UIVisibilityConfig:

At 0 the config also sets readOnlyCursor: true - rest mode is for consuming, not producing. The reference stylesheet implements this same table in CSS.

notificationStrategy

Reduces interruptions as energy drops. Resolves to a NotificationConfig:

This config is guidance on its own. The notification gate is the runtime that enforces it - including the guarantee that nothing below the threshold is dropped, only deferred.

taskComplexityStrategy

Caps the complexity of work worth surfacing, and suggests break cadence:

Rest gets no break suggestions on purpose: prompting someone at 0 to take a break from resting is noise.

interactionForgivenessStrategy

Lower energy means slower error detection, so forgiveness scales inversely with capacity - longer undo windows, confirmation on destructive actions, more frequent autosave:

deferralStrategy

Orders the "not now" presets by level so a one-tap defer matches capacity. Resolves to { orderedPresetIds, defaultPresetId }:

At low energy the default is "tomorrow morning", not "in 1 hour" - items should resurface when capacity has plausibly recovered.

autonomyStrategy

How much latitude automation has to act without asking. The mirror of interactionForgivenessStrategy: forgiveness protects against the user's mistakes at low energy, autonomy against the agent's. Resolves to an AutonomyConfig:

What narrows as energy falls is discretion, not action. At rest the automation may still take a single, certain, template-only step - the system acts on the user's behalf precisely when they are least able to supervise it, so the worst day is the wrong day for it to improvise.

demandAdmissionStrategy

Who gets through to the user, and what happens to everyone else. Resolves to a DemandAdmissionConfig; the full model, including acknowledgments, lives in Inbound demand.

Nothing is dropped at any level. What changes is whether demand reaches the inbox now or is acknowledged and queued - and how much the acknowledgment says.

describe() - explaining behavior to users

Every strategy can explain itself at any level, which is useful for settings screens and onboarding:

notificationStrategy.describe(50)
// "Steady: Only high priority, batched every 5min"

Full strategy reference: /docs/api/core.