When AI Agents Do the Heavy Lifting: How Autonomous Agents Reshape Work and ROI

TL;DR: Autonomous AI agents (Perplexity Computer) execute dozens of machine-driven minutes per session versus seconds for conversational search. For multi-step, composable workflows they cut end-to-end time by roughly 80–90% and modeled labor cost by ~90%—creating a practical breakeven where agent delegation outperforms human-plus-chat for tasks longer than ~20 minutes of manual steps.

A quick scene: a product manager, a week saved in minutes

A product manager used to spend a week stitching together data, running scripts, and formatting a competitor-analysis report. She handed the job to an autonomous agent and watched a draft, charts, and a changelog appear in under an hour. It felt like hiring a setup-heavy machine: expensive to configure once, but astonishingly cheap for each item it churned through after that. That machine metaphor is exactly what the research quantifies.

Why leaders should care about AI agents and agent-based automation

Not all chat UIs are the same. A conversational search assistant (Search) answers questions and points users to facts. An autonomous agent (Perplexity Computer) plans, chains actions, and executes end-to-end workflows using connectors (APIs, file writes, code runtimes). New research from a Perplexity–Harvard working paper compares these two product modes on 10,000 matched tasks drawn from 90 days of production telemetry. The results show clear business implications for automation ROI, task design, and team roles.

“Agents impose a larger upfront cost per task but greatly lower the incremental cost of each step; that trade-off creates a breakeven task size where delegation pays off.”

Headline results — plain numbers that matter

• Machine-executed work per session: Computer ≈ 26 minutes vs Search ≈ 33 seconds (about 48× more).
• Median session duration: Computer ~9 minutes vs Search ~14 seconds (~40× gap).
• End-to-end time (matched tasks): Search+human ≈ 269 minutes → Computer+human ≈ 36 minutes (≈87% reduction).
• Modeled cost reduction: ≈94% lower overall labor cost (study converts time savings into wage-based cost estimates).
• User satisfaction proxy: Next-turn meaningful dissatisfaction fell—Computer 1.3% vs Search 2.9% (lower frustration despite more autonomy).
• Connector use (external tool chaining): Computer invoked connectors 7.9% of sessions vs 1.8% for Search—agents chain systems more often.

Those figures paint a simple picture: for the right kind of work—repetitive, multi-step, cross-system—autonomous agents don’t just answer faster; they change the shape of the job.

Breakeven, explained simply (and why it’s useful for routing work)

Think of delegation as a fixed setup plus a per-step cost. Agents have a higher fixed orchestration fee (setup and planning) but a much lower cost for each extra action they perform. The study estimates that when a task requires roughly 20 minutes of manual steps (or around that many repeated actions), delegating to an agent typically becomes cheaper and faster than doing the steps manually with a conversational search helper in hand.

Practical rule of thumb: use conversational search and human effort for quick lookups or single-step questions; hand multi-step, cross-system workflows to agent-based automation.

Worked example: the breakeven math (simple)

• Assume a human step costs the organization $2.05 on average per step (study proxy), while an agent’s marginal step cost is ~$0.16.
• If the agent charges a $4–$10 orchestration fee per task, the number of steps required to justify the agent is roughly where orchestration cost ÷ (human-step cost − agent-step cost) ≈ 20 minutes of manual work.
• So a 25-step reporting workflow is likely to favor the agent; a 2-minute fact lookup is not.

What kinds of work benefit most

• Executional, composable tasks: ETL/data cleaning, report generation, code runs and CI tasks, documentation assembly, data visualization pipelines.
• Cross-domain workflows: tasks that touch multiple knowledge areas (the study measured +38% breadth across occupational domains for agent queries).
• Higher-order creation: more creative, design-and-synthesize work—agents increased the share of create-level tasks (50% vs 26% for Search).

Quick pilot checklist for CIOs and automation leads

• Pick one repeated, cross-system workflow (reports, data prep, or document assembly).
• Implement connectors for the few critical systems involved (storage, BI tool, internal API).
• Instrument every run for time-to-complete, cost-per-task, error/rollback incidents, and user satisfaction.
• Start with a small user cohort (5–10 people), run a 30–60 day pilot, then measure and iterate.

Governance mini-framework for safe agent deployment

Pre-delegation

• Classify tasks by impact (low, medium, high) and allow automation only for low/medium by default.
• Define data access policies and permission scopes for connectors.

Runtime controls

• Require human approval for actions above a monetary or compliance threshold.
• Implement privilege separation for connector credentials—agents act using scoped service accounts.

Post-action

• Keep immutable logs and time-stamped audit trails of every agent action.
• Automate anomaly detection and immediate rollback/alerting for unusual behavior.
• Run periodic human audits and synthetic tests against critical workflows.

KPIs boards and finance teams will actually ask for

• Time saved (hours/month) and percent reduction vs baseline
• Cost saved ($/month) using agreed hourly rates
• Error / rollback rate and incidents avoided
• Next-turn dissatisfaction or user satisfaction delta
• Connector usage and fraction of fully automated runs

Example ROI vignette

A 5-person analytics team spends roughly 200 hours/month on repeated ETL and reporting. Applying the study’s ~87% time reduction:

• New time: ≈ 26 hours/month (174 hours saved)
• At $60/hour fully loaded, that’s about $10,440/month in labor reclaimed for higher-value work
• Payback is typically weeks to months after adding agent setup costs and small model fees—especially when repetitive tasks repeat weekly.

These are illustrative numbers. Actual ROI depends on task frequency, connector cost, and which parts of the workflow can be safely delegated.

How the study was done (short methods box)

The Perplexity–Harvard paper analyzed 90 days of production telemetry and 10,000 matched task pairs where the same user attempted the same task via both products (text-match >99%). Matching isolates product-mode effects rather than different user intent. Autonomy was measured as minutes of agent-executed work per session; connectors (APIs, code runtimes, file writes) were tracked to quantify composability. The preprint is available on arXiv: arXiv:2606.07489v1.

Caveats and risk considerations

• Early-adopter sample: the data comes from Perplexity users during Computer’s early rollout. Behavior and mix of tasks may shift with broader adoption.
• Scope sensitivity: sessions were gated where agents could act—results measure autonomy in contexts designed for action, not every possible use case.
• Quality, safety, and legal risk: longer or higher-impact workflows need stricter validation, human oversight, and often legal sign-offs (finance, contracts, healthcare).
• Cost-model assumptions: modeled wage multipliers and per-task model costs vary by region and vendor; recalculate for your teams and pricing tiers.

“Autonomy didn’t just speed up jobs — it made users attempt more complex, cross-disciplinary, and creative tasks they otherwise wouldn’t.”

Playbook in 90 days

1. Weeks 1–2: Map candidate workflows and classify by impact. Pick 1–2 pilot targets.
2. Weeks 3–6: Integrate connectors, build an agent flow, and launch with a small cohort. Instrument metrics from day one.
3. Weeks 7–12: Measure time/cost/error rates, tighten governance, and expand where ROI and safety align.

Will agents replace jobs?

No immediate mass layoffs—but role redesign is real. Agents shift where humans add value: strategy, oversight, validation, and domain-level synthesis. Expect reskilling (supervising agents, writing test cases, handling edge cases) and a move away from repetitive execution toward higher-order work. Treat agents as amplifiers—machines to do the heavy lifting while people keep the steering wheel.

Next practical step

Pilot one multi-step, cross-system task that currently consumes measurable team hours. Instrument outcomes from day one, require scoped approvals for any action that touches critical systems, and measure the KPIs above. Update procurement and chargeback models so model-inference costs are charged to the teams that benefit. If the pilot shows similar time and cost delta to the study, you’ve found low-hanging automation fruit with real business ROI.

Resources: Perplexity–Harvard working paper (arXiv:2606.07489v1) and internal automation playbooks for governance, connector engineering, and pilot KPIs.