
Does a faster AI model make your agent finish sooner?
Unity Horizon8 min read
Barely. Claude Opus 5.5's output speed moves 11% across its five effort levels, while the wait before its first answer token moves 71 times.
Barely. Across the five effort levels of Claude Opus 5.5, Artificial Analysis measures output speed between 105 and 117 tokens a second. The wait before the first answer token runs from 4.98 seconds to 356.24. A tenth of a difference in typing speed, seventy times the difference in waiting. Checked by Unity Horizon on 17 November 2026.
What sets an AI agent's wall clock?
An agent run is a chain of model calls, and each call waits for the result of the one before it. Nothing in that chain is parallel, because step four is chosen on the basis of what step three returned.
Inside one step the clock splits. First the pause between sending the request and the arrival of a token the caller can use. Then the typing, which for a step ending in a tool call is tiny: a function name and a short argument object run to about seventy tokens, and at 105 tokens a second that is two thirds of a second of typing.
So the pause is the step. The agent pays it once per call, and the number of calls is the multiplier.
How much does a model's token speed vary?
Hardly at all, next to the pause. Artificial Analysis benchmarks each endpoint every six hours and averages speed and latency over the past five days. The figures below are for two reasoning models, neither of them deprecated, read on 17 November 2026.
| Claude Opus 5.5 | low | medium | high | xhigh | max |
|---|---|---|---|---|---|
| Time to first answer token | 4.98s | 13.03s | 22.40s | 67.92s | 356.24s |
| Output speed, tokens a second | 105 | 108 | 108 | 109 | 117 |
| Time per Intelligence Index task | 3.0 min | 6.8 min | 9.3 min | 15.8 min | 24.6 min |
| GPT-6.1 Sol | low | medium | high | xhigh | max |
|---|---|---|---|---|---|
| Time to first answer token | 3.03s | 5.20s | 32.01s | 67.15s | 158.41s |
| Output speed, tokens a second | 52 | 53 | 51 | 52 | 49 |
| Time per Intelligence Index task | 1.9 min | 4.3 min | 7.4 min | 9.7 min | 22.9 min |
Figures are from the Claude Opus 5.5 and GPT-6.1 Sol model pages, measured on each vendor's own API. The last row is derived rather than timed: the site calculates it as output tokens per task divided by output speed. Output speed moved by a tenth. The wait moved seventy times.
What does time to first answer token measure?
Everything the model did before it started answering. Artificial Analysis publishes both figures and defines time to first token as "the time in seconds between sending a request to the service or system and receiving the first token of the response", and time to first answer token the same way but for "the first answer token". On a reasoning model the first token is usually not an answer token, so the second figure carries the whole thinking phase inside it.
Output speed carries thinking too. The definition is "the number of output tokens, including reasoning tokens, received per second over a request's full duration", so the 117 tokens a second that Opus 5.5 posts at max effort is mostly tokens the caller never sees. We costed that side of it in Do you pay for AI reasoning tokens you never see?.
One cell deserves reading twice. Artificial Analysis puts the median time to first answer token at 12.58 seconds for models in the same price tier as Opus 5.5. At max effort it measures 356.24.
How long does a twenty-step agent run take?
Take a seventy-token tool call per step, twenty steps in sequence, Opus 5.5, and the figures above. The arithmetic is multiplication, and it belongs in the scoping call rather than the retrospective.
| Effort | One step | Twenty steps | Share spent generating |
|---|---|---|---|
| low | 5.6s | 1.9 min | 11.8% |
| medium | 13.7s | 4.6 min | 4.7% |
| high | 23.0s | 7.7 min | 2.8% |
| xhigh | 68.6s | 22.9 min | 0.9% |
| max | 356.8s | 119 min | 0.17% |
At the lowest effort setting, 88% of the run is waiting. At the highest, 99.83% is. Swap in the fastest speed in the table, 117 tokens a second instead of 105, and the low-effort run goes from 112.9 seconds to 111.6. One and a third seconds. Dropping the effort setting from medium to low takes 161 seconds off it.
These are estimates over published measurements, not timings of a production system, and the next section says where they are optimistic.
What did a measured agent run spend its tokens on?
Reading. METR's RE-Bench paper, submitted November 2024 and revised May 2025, ran language model agents against human experts across seven machine learning research environments on an eight-hour clock. It reports that "our agents use ~29M input tokens and ~499K output tokens in each 8-hour run, at a cost of approximately $123".
Fifty-eight tokens read for every token written. Put those 499,000 output tokens through the fastest speed in our table and they account for 71 minutes of a 480-minute run. The paper's own appendix reaches the same place from the other direction: "Since agents are limited by wall-clock time rather than tokens, the latency and throughput of generating tokens can determine how many actions the agent can take in a run. This means changes to the API speed would likely only have a minor effect on the pace of progress for these agents."
The paper limits its own claim in two places, and both limits belong here. Its agents are two years old. And it says they "spend a majority of the time waiting for computations to finish", which is true of a training run and not of a form.
Which levers move the clock?
The effort setting, ahead of everything else.
| Lever | What it moves | Evidence |
|---|---|---|
| Effort level | 71 times on one model | The table above |
| Count of sequential calls | Linear, and it is the multiplier on everything else | Arithmetic |
| Prompt caching | The prefill part of the pause | Anthropic documents cache pre-warming as "lowering time-to-first-token (TTFT) for latency-sensitive applications" and reports "improved time-to-first-token for long documents" |
| Streaming | Perceived responsiveness, and HTTP survival | The Claude SDK "requires streaming to avoid HTTP timeouts" on requests with large max_tokens values |
Caching pays twice. A cache read on Opus 5.5 is priced at 0.05 times base input, and the thing being read is the transcript that grows with every step. We worked the money side of that in Does trimming an AI agent's context save money? and the quota side in How many AI agents can you run at once before you hit a rate limit?.
There is also a ceiling. Anthropic's extended thinking page tells you to move to batch processing above a 32,000-token thinking budget, because longer requests "can hit system timeouts and open-connection limits". A single call that thinks for six minutes is near the edge of what the transport will carry.
Anthropic's reducing latency page recommends a faster model, shorter prompts and outputs, and streaming. Every item on it is about one call.
Who pays for the wait?
The wait costs nothing on one kind of work and decides the product on the other. Where nobody is sitting in front of the run it is free: a nightly queue of filings, a reconciliation, a batch of documents scored before the office opens. We built OFFSET, which files declarations directly to the ΑΑΔΕ portal, and a queue that finishes by seven in the morning does not care whether it started at two or at four.
Where somebody is waiting, every lever above is a product decision. We built askHermis, which publishes a 1.2 second average response time and answers 85% of guest queries instantly. Set 1.2 seconds against the top left cell of our first table, 4.98 seconds, which is where Opus 5.5 begins answering at its cheapest and fastest setting. A chat surface and a reasoning agent draw on different budgets, and a roadmap that prices them the same misses by two orders of magnitude.
Step count sorts the same two groups again. A demo makes one call and looks immediate. A computer-use agent reads the screen before it writes and reads it again to confirm, the pattern we costed in How do you stop an AI agent from doing the same thing twice?. Those confirmation reads are round trips like any other. Nobody waits on the overnight queue. Somebody waits on the chat window.
What should you measure instead of tokens a second?
The two numbers that decide this are not on any model card.
Log the time to the first usable token for every model call, tagged with the step it belongs to, and read the distribution rather than the mean. The mean hides the step where the model thought for four minutes about a field it had already filled, and that step is the one worth cutting.
Then count how many model calls one run makes in sequence. Not total calls, sequential ones, because that count is what multiplies every pause in the chain. Teams that have the number usually find a pair of steps that never needed to be separate.
The figures here are Artificial Analysis's single requests on each vendor's API, and its methodology page does not state the prompt length. An agent step carries the whole transcript, so prefill pushes the real pause above every number in our tables. We have not published per-step timings from our own runs, which means the step counts are ours and the latencies are theirs. If you have logged first-token latency per step across a full week of agent traffic, we would like to see the shape of it.
If you are scoping an agent where somebody is waiting for the answer, our agentic AI systems page sets out how we scope one. How many model calls does one run of your workflow make in sequence, and who has counted them?
Common questions
What decides how long an AI agent takes to finish a task?
The number of model calls it makes in sequence, multiplied by the pause before each call's first answer token. Token generation speed is the small term. On Claude Opus 5.5 a seventy-token tool call takes about 0.6 seconds to emit and between 4.98 and 356.24 seconds to start, depending on the effort level.
Does a model with more tokens per second finish an agent run faster?
Hardly at all. Across the five effort levels of Claude Opus 5.5, Artificial Analysis measures output speed between 105 and 117 tokens a second, an 11% spread. A twenty-step agent run at the lowest effort takes about 113 seconds, and moving from the slowest to the fastest of those speeds saves 1.4 of them.
What does time to first token mean for a reasoning model?
Not what it meant before reasoning. Artificial Analysis reports a separate time to first answer token, which includes the model's thinking time, because the first token off a reasoning model is often a reasoning token. On Claude Opus 5.5 at max effort that figure is 356.24 seconds, against a 12.58 second median for models in the same price tier.
How do you reduce AI agent latency?
Lower the effort level, cut the number of sequential model calls, and keep the transcript cached so prefill is not paid again on every step. Anthropic's own latency page recommends a faster model, shorter prompts and outputs, and streaming. All three address one call, and an agent is many calls in a row.


