What autonomous AI agents actually do
Everyone has an opinion about AI agents. Almost nobody publishes what they actually do at the run level. So we opened our own logs. This is a look at more than 8,000 real autonomous runs on Iris, between February and July 2026: how long they take, how many steps they need, how they end, and what people walk away with.
Based on real product telemetry. Figures are unrounded except where noted. Method is at the bottom.
Completed agent runs analyzed (Feb to Jul 2026)
Median time to finish a run, start to deliverable
Of runs that finished, share that completed instead of erroring
Runs that ended because the agent judged the work done
Real agent runs are fast, and a long tail is real
The median run finishes in about 40 seconds. Roughly six in ten wrap in under a minute, and around nine in ten are done inside five minutes. But a real tail exists: about one run in ten runs long, because deep research, a full deck, or a multi-file job genuinely takes longer. Averages hide that shape, so here is the full distribution.
Run duration, share of runs
n = 8,170 completed runs with a recorded duration. Median 42 seconds, 90th percentile about 4.8 minutes.
Most work takes fewer steps than people expect
The median run reaches its result in two internal steps. That surprises people who picture an agent spiralling through dozens of tool calls. Most real requests are well-scoped: research this and write it up, build this deck, fix this document. The agent plans, acts, and returns. The dramatic multi-step runs are the exception, and they live in that same 10% long tail on duration above.
How runs end says more than a success rate
A raw success rate is easy to game. What matters is why a run stops. On Iris, six in ten runs end in natural completion: the agent decided the work was genuinely finished. About a third end explicitly, when the result is delivered and the turn closes. Only a small slice hit a limit or an unclear state. An agent that mostly stops because it is done, not because it ran out of room, is the behavior you actually want.
Why runs end, share of runs
n = 8,187 completed runs. Of runs that terminated, about 92% completed rather than failing (8,187 completed against 722 failed).
What people actually build with an agent
When a run produces a file, this is the mix. Documents lead by a wide margin, followed by charts and presentations. It lines up with the plainest read of the demand: people reach for an agent to produce the written and visual deliverables that used to eat an afternoon. This slice covers the most recent month of tracked artifacts, so treat it as a current snapshot rather than a five-month average.
Deliverables produced, share of artifacts
n = 498 artifacts recorded over roughly one month. Newer instrumentation than the run data above, so the sample is smaller.
What the numbers add up to
The useful autonomous agent is not the one that runs for ten minutes. It is the one that finishes a real job in under a minute, most of the time, and knows when it is done.
A long tail is not a flaw. The 10% of runs that take longer are the deep research and multi-file builds that are worth the wait, and hiding them behind an average would misrepresent the tool.
Success rate alone is a weak signal. Why a run ends tells you far more, and natural completion leading at 60% is the healthy shape.
Demand is concentrated in written and visual deliverables. Documents, charts and decks are what people overwhelmingly ask an agent to produce.
How we measured this
The figures come from Iris product analytics, not a benchmark or a staged demo. Run statistics cover completed agent runs recorded between 8 February and 17 July 2026 (8,187 completed, 722 failed). Artifact statistics cover deliverables recorded over roughly the last month (498 total), which is why that sample is smaller: the instrumentation is newer.
Duration is measured end to end per run and reported as the median plus the full distribution, because a mean would be dragged around by the long tail. The completion figure is completed runs divided by completed plus failed runs. Runs that never reported a terminal state are excluded rather than assumed.
We deliberately left two metrics out. Per-run tool counts and token totals are not yet reliably recorded across all runs, so publishing medians for them would be misleading. We would rather show fewer numbers we trust than pad the report with ones we do not. When that instrumentation is solid, we will add it here and date the update.
See it for yourself
The best way to understand a run is to start one. Describe a job, and watch Iris plan, build, and deliver it.