Delegation

Delegation is a configuration of agency where the locus shifts from shared to system-centric, coupling is loose, granularity is high-level, and dynamics are inherently dynamic — authority moves at handoff, takeback, and exception boundaries. The human offloads sustained work; the system runs the loop in the background; the human re-enters at discrete moments rather than attending continuously.

The interaction arc traces how actors move from recognising a need through to action and reflection. In the delegation frame, the system runs the loop on the human’s behalf. The same phases happen but the human is not necessarily in the room. They set the agent running and return only when something requires their attention.

This redistribution changes the focus of interaction design. There are no flows to optimise. Instead, the design problem becomes:

1. what does the human need when they first hand work to the system?
2. what do they need to remain informed while work happens out of sight?
3. what do they need when the system can’t proceed alone?

The sibling frame is assistance, where the human stays in the loop throughout and the system intervenes selectively. In practice a system often supports both frames. What distinguishes delegation is the background arc — the expectation that the system will act autonomously over time.

Touchpoints by lifecycle stage

Delegated work has a temporal arc from the moment the human first hands work to the system through the moment the work ends. The stages are not strictly sequential — a system may cycle between execution and exception handling many times — but each stage has characteristic touchpoints and design concerns.

Set-up

The human is learning what the system can and can’t do & defines goals while the system is learning what the human wants. Design concerns centre on calibrating expectations and getting the agent running without front-loading more specification than the user can provide.

Capabilities and constraints — the user learns what the agent can and can’t do before committing authority to it.

Goals and preferences — the agent learns what outcome the user wants and how it should be shaped.

Permissions and authorisation — the system requests data access and delegated authority it needs to act on the user’s behalf.

Test drive — the user rehearses the agent’s likely behaviour before real stakes begin.

Tuning tools — the user inspects or edits the rules that govern when the agent acts.

Launch — the system goes live; must show liveness and an immediate stop control.

Distributed customisation — lower-priority setup is deferred into early use rather than front-loaded.

Execution

Interaction shifts to lightweight maintenance. The design concern is keeping the agent actions legible without requiring constant babysitting.

Monitoring — the user checks status, trends, and next triggers at a glance.

Pause and restart — the user temporarily suspends the agent or resumes it when conditions change.

Notifications — suggestions, performance, or completion.

A hood to look under — the affordance to inspect the system’s current state and reasoning.

Exception handling

The agent has encountered something it cannot handle and must return the human to the loop without losing the context they need to act.

Steering — direct mid-stream controls to correct the agent without taking over wholesale.

Notifications — problems, concerns, or low resources.

Tuning tools (repair) — the user repairs triggers or behaviours when the agent misfires.

Handoff and takeback

Authority shifts in either direction: the system hands back because it cannot safely proceed, or the human takes back to intervene.

Handoff — control shifts from agent to human because the agent cannot safely continue.

Takeback — control returns to the agent once stability is restored; needs a readiness signal and a confidence-repair window.

Practice — the user maintains recovery skills through rehearsal so takeover is meaningful when needed.

Disengagement

The work is doen or the human stops using the system — deliberately or by neglect.

Disengagement check-ins — the agent checks whether a persistent task is still worth continuing.

Graceful shutdown — how a human turns the system off without losing context.

Data portability — what the human takes with them when they leave.

Death and succession — in higher-stakes or longer-lived systems, handling when the user can no longer disengage themselves.

Resources & references

• Noessel, C. (2017). Designing Agentive Technology.