Topics/Human-Agent Interaction

“A human reviews it” does not describe an operating relationship. A person may revise content continuously, approve one consequential action, or intervene only when an agent exceeds a threshold. The agent may wait after every step or run continuously within a fixed limit. A design review must locate where the person enters, what they can see, which decision they make, and how that decision binds the next action.

One label rarely covers an entire workflow. Requirements may use co-editing, payment may use gated action, reconciliation may use supervised operation, and low-risk information handling may use bounded delegation. The relationship changes with the step, failure cost, and reversibility.

Four operating relationships

These are operating relationships, not maturity levels. Bounded delegation is not inherently better than co-editing. High-risk, infrequent, or subjective work often belongs in co-editing or gated action.

Three powers and one intervention condition

The human-agent boundary can be reviewed through three powers:

1. Information admission: What information is allowed to influence a decision? Who controls source, time, version, and visibility?
2. Acceptance authority: Which standard may prove that the result is correct? Where do model self-evaluation, deterministic checks, external receipts, and human judgement apply?
3. Action authority: Which permission may change the real world? Which tool, parameters, resource, version, and validity period does an approval bind?

Intervention conditions return control to a person when evidence is missing, a budget expires, rules conflict, an irreversible action approaches, external state diverges, or failures repeat. Without executable intervention conditions, “human in the loop” remains an organizational slogan.

The interaction contract

Record the operating relationship in the workflow definition. A generic confirmation button does not define the authorization boundary.

interaction_contract:
  task: payroll.allowance.change

  mode_by_step:
    clarify_goal: co_edit
    prepare_change: supervised
    commit_change: gated_action
    verify_result: supervised

  human_roles:
    requester: supplies_goal
    approver: authorizes_intent
    operator: handles_exception

  approval_binding:
    fields: [tool_version, normalized_args, resource, preconditions]
    expires_after: 15m
    single_use: true

  intervention:
    pause_when:
      - evidence_missing
      - amount_delta_above_200
      - employee_state_changed
      - retry_budget_exhausted
    handoff_artifact: exception_packet

  acceptance:
    probe: payroll_read_after_write
    reviewer: requester

approval_binding is critical. The user should authorize a replayable, auditable Intent, not a vague “continue.” If the tool version, normalized parameters, or target resource changes, the previous approval expires.

An effective interaction sequence

1. The agent exposes a gap: It lists missing fields, conflicting evidence, or authority limits without presenting guesses as facts.
2. The human completes the intent: They confirm the goal, non-goals, priority, and unacceptable outcomes.
3. The agent submits a candidate decision: It shows current and target state, evidence, proposed action, maximum impact, and rollback point.
4. A person or policy decides: The result is approve, reject, modify, or request evidence, bound to a concrete Intent.
5. The agent executes within bounds: It calls admitted tools and records ActionEvents and business-ledger entries.
6. The system returns an external result: A receipt, state delta, or consumer probe shows whether the action completed.
7. The human handles an exception: The handoff retains the original goal, completed work, remaining risk, evidence, and a recovery point.

Approval interfaces should present a concrete Intent

A payment or data-change approval view should show the target object, current and target values, effective time, tool and version, normalized parameters, evidence, maximum impact, and recovery method. Approval and rejection should emit structured events, and timeout behaviour should be explicit.

Long model explanations can be placed behind details. The approver first needs to see what will change, why it is allowed, the maximum possible effect, and how completion will be verified. Reviewing a prompt or reasoning transcript does not authorize a concrete side effect.

The handoff packet makes takeover possible

If the agent pauses with only “task failed, please handle manually,” the person must investigate from the beginning. An actionable handoff packet includes:

• original goal, active version, and non-goals;
• completed and remaining steps plus the last checkpoint;
• key evidence, conflicts, and current external state;
• attempted recovery, remaining budget, and non-repeatable actions;
• available next steps and their effects, without making the final judgement for the person.

Takeover also needs a resume protocol. If the person changes external state, the agent must read the facts again before it continues from an old context.

Relationship changes in a payroll workflow

When an employee requests an allowance change, the agent and requester co-edit the goal and complete the effective date and policy basis. The prepared change enters gated action, where the approver sees the concrete Intent. After the write, verification can run under supervision. A read-after-write mismatch pauses the workflow and creates a handoff packet. After repeated stable operation, small, single-employee, reversible changes may enter bounded delegation; batch, cross-region, or policy-conflict cases keep the approval gate.

Changing the relationship

Common problems

• The system has one HITL label but does not say where the person decides.
• The approval object is a prose plan; the tool, parameters, or resource changes before execution.
• The person carries accountability but cannot see evidence, impact, or rollback.
• The agent asks about every uncertainty and consumes human attention with low-value confirmations.
• The agent runs continuously without breach thresholds, pause points, or revocation.
• A human changes external state during takeover, and the agent resumes without perceiving it again.

Review checklist

1. Which human-agent relationship applies at each consequential step, and why?
2. Does the person see a concrete Intent, evidence, and impact, or only a general explanation?
3. Who controls information admission, acceptance authority, and action authority?
4. Does approval bind tool version, parameters, resource, preconditions, and expiry?
5. Are pause, escalation, revocation, and takeover conditions executable?
6. Can the handoff packet resume from a checkpoint instead of restarting investigation?
7. Do runtime evidence and revalidation support changes in the operating relationship?

Related material

• Composing Agent Patterns
• Agent Design Lifecycle
• G1 Approval Gate
• G2 Blast-Radius Control
• A4 Guardrail Sandwich
• Bo Liang execution-agent case
• First Governance Module Workshop