Interactive companion to “Pricing Human Attention for Asynchronous Agents” · Oct 2026

When should an agent spend your attention?

An agent that asks whenever it is uncertain spends attention on questions its own investigation would have answered. The note’s rule asks only when the answer is worth more than what the agent will find before the answer arrives. Drag the controls to see the rule for one agent, check it against trajectory trees from a real coding agent, then scale it to many agents sharing one person.

Rule · Theorem 1ask at the first t with  ηt  ≥  κ ht\text{ask at the first } t \text{ with }\ \eta_t \;\ge\; \kappa\,h_t
ηtchance the answer is still needed when it arrives htrate at which the question is dissolving on its own κattention price: one interruption, in minutes

Experiment 1 · one agent

Investigate first, or ask now?

Proposition 1’s model. With probability p only the user can supply the missing information. Otherwise the agent’s own investigation dissolves the question after an exponential time with mean 1/μ. Replies arrive after an exponential delay. Cost is time until the information is in hand plus κ per question asked.

Scenarios
0.25

Prior that the answer cannot be found by investigating.

2.0 min

How long the agent’s own investigation takes to dissolve the question, when it can.

4.0 min

How long the user takes to answer.

6.0 min

Cost of one interruption, counted in minutes of delay.

1× the truth

How long the agent believes its self-resolution takes. It picks its wait from this belief and pays the true cost.

Investigate first Investigate for 4.2 min, then ask if the question is still open.
Optimal wait a*4.2minbefore the question goes out
User answers first, ρ0.33chance the reply beats the agent
Questions per task0.34at the optimal wait
Cost vs. asking now−30%expected cost
a∗=1μ log⁡+ ⁣[1−pp (κμ−ρ)]a^* = \frac{1}{\mu}\,\log^{+}\!\Big[\frac{1-p}{p}\,\big(\kappa\mu-\rho\big)\Big]with ρ=E[e−μD]\rho = \mathbb{E}\big[e^{-\mu D}\big]
a* = …

The agent knows its own speed.

Expected cost of asking at time a

Asking later saves attention when the question dissolves, and costs time when it does not.

The rule: ask when the lines cross

While the agent investigates, the question gets likelier to be truly needed, and the priced hazard falls.

Experiment 2 · a real coding agent

The same question on a real coding agent

Thirty Interactive SWE tasks, each with an issue cut down so that details only the user knows are missing. A coding agent (Qwen3.6-35B-A3B in OpenHands, 100-step budget) ran every task once without those details, once with the full issue, and once more without them as a repeat. Forks replay the no-answer run up to step K in a fresh sandbox, deliver the full issue as the user’s reply, and let the agent continue. The SWE-bench tests score every run. Pick when the agent asks and how long the reply takes, and the trees give the result for all thirty tasks at once (Eq. 8 of the note).

Need the user–fail without the details, pass with them
Solve it alone–pass with no answer at all
Out of reach–fail even with the full issue
Repeat agrees–same result on a second no-answer run
Agent asks at step0

A run that already ended by then never asks.

10 steps

The answer lands at the next fork point (step 0, 10, 20 or 35).

Ask at step 0 …
Resolved–
Questions per task–runs still going when it asks
vs. never asking–
Ask only when needed–hindsight upper bound

Resolved, by when the agent asks

Read off the trees for the chosen reply delay.

What the answer is worth when it lands

Tasks still running at step K, with and without the answer injected there. Bars: 90% intervals.

One tree per task

Each line is a run without the answer; marks on it are forks where the answer was injected. Rings show which run the chosen policy reads.

Without the answer, how soon do runs succeed?

Share of no-answer runs not yet resolved, by step (both no-answer runs of every task).

Experiment 3 · many agents, one human

One inbox, many agents

Each agent works through a stream of tasks drawn from the note’s population and asks without stopping its own work. The human answers one question at a time; a queued question is withdrawn when it dissolves. Every question delays the ones behind it, so the right price of attention rises with the crowd. The human can also answer by priority ci νiθi\frac{c_i\,\nu_i}{\theta_i}: needed, quick to answer, unlikely to dissolve.

How agents decide to ask
24

Restarts the live run.

16 min

Added to each agent’s attention price.

1.5 min

Mean minutes to read and answer one question.

2.0 min

What each agent charges itself per question, ignoring others.

Agents

investigating asked: question pending, still working has the information, finishing
Simulated time1:00hours : minutes
Tasks completed0warming up
Questions asked0
Withdrawn0dissolved while queued
Human busy0%share of time answering

Throughput per agent

Uncertainty-driven asking saturates the human first.

Attention spent per task

Pricing cuts questions as the crowd grows.