A new study from Harvard and Perplexity, "How AI Agents Reshape Knowledge Work: Autonomy, Efficiency, and Scope" (Jeremy Yang of Harvard with Kate Zyskowski, Noah Yonack, and Jerry Ma of Perplexity, arXiv 2606.07489), does something the agent discourse mostly skips: it measures, from production data, how long agents actually run autonomously. The headline number is 26 minutes of machine execution time per session for Perplexity Computer, the agentic orchestrator, against 33 seconds for Perplexity Search, the conversational answer engine, a 48x gap. The medians are tighter but tell the same story, 9 minutes versus 14 seconds, a 40x gap. The value here is not the specific minute count, it is that the measurement comes from the same users hitting two products over the same 90-day window (February 27 to May 27, 2026), matched into 10,000 session pairs with cosine similarity above 0.99, so the comparison isolates the agentic-versus-conversational difference rather than confounding it with who is asking or what they are asking about. Computer sessions were gated on actually invoking "do" tools, code execution, browser actions, file writes, connector calls, so the 26 minutes is machine work, not user think-time.
The methodology is the part builders should take seriously, because it is a template for measuring your own agents honestly. Most agent autonomy claims are vendor demos: a single impressive run, a cherry-picked 35-hour session, a benchmark designed to be passed. This study instead takes the counterfactual seriously. It estimates that a professional using Search alone needs 269 minutes per task, while Computer-plus-human needs 36 minutes, an 87% time saving and a 94% cost saving, and then it names the breakeven honestly: a professional who can complete all the manual steps in under 20 minutes does not benefit, because the agent's overhead is not worth it below that threshold. That is a useful and unusually candid framing, the agent wins on tasks long enough to amortize its setup and oversight cost, and loses on short ones, which is exactly the calculation a builder should run before agentifying a workflow. The quality signal points the same way: Computer sessions showed a 1.3% dissatisfaction rate against 2.9% for Search, a 55% reduction, so the longer autonomous runs were not buying speed at the cost of correctness in aggregate.
The finding that opens a larger question than the benchmark is about scope, and it is the part worth sitting with. When users had an agent available, they did not just do the same work faster, they attempted different work. 76% of agentic queries reached higher-order Bloom cognition (analyze, evaluate, create) against 55% for conversational, and 59% crossed occupational boundaries against 50%, meaning people reached past their own domain into tasks they would not normally attempt. This is the second-order effect that the 26-minute number undersells. Autonomy does not merely compress the time a known task takes, it changes the set of tasks a person considers worth starting, because the cost of attempting something ambitious or outside your expertise drops when an agent can carry the 26 minutes of execution. The adoption curve underneath this is steep, cumulative Computer queries grew to 84x their first-week total across the study window, so the behavior change is not a lab artifact, it is what people did when the capability was actually in their hands. That reframes the whole agent-autonomy conversation from "how long can it run" to "what does cheap autonomy do to the shape of the work people choose," and that second question is the one with the longer tail.
Monday morning, if you are deciding whether to agentify a workflow: the under-20-minutes breakeven is the number to internalize, agents earn their overhead on long-horizon multi-step tasks and lose on quick lookups, so target the former and leave the latter as plain calls. If you are measuring your own agents: this paper is a methodology to copy, match agentic and conversational sessions from the same users, gate on actual tool invocation, measure machine execution time rather than wall-clock or vendor demos, and estimate the counterfactual cost of the human-only path, because that is what turns "our agent is impressive" into "our agent saves X minutes above a Y-minute threshold." If you are tracking the agent-runtime threads, this is the empirical floor under the persistence-in-time axis we have watched vendors assert (the 35-hour autonomous runs, the always-on scheduled tasks), now grounded in what production users actually got, tens of minutes per session, not hours, but enough to change which tasks they attempted. And if you are thinking past the build sheet, the scope finding is the one to keep: the interesting consequence of autonomous agents may not be the work they do, but the more ambitious work people start attempting once the execution cost of ambition falls.