Skip to main content
November 22, 2026

OpenAI's Agent Spend Data: A Budget Model for Your Agent Fleet

OpenAI's Agent Spend Data: A Fleet Budget Model

Most teams budget for agents the way they budget for SaaS seats: a number per person per month. OpenAI's own usage data shows why that breaks. On November 18, 2026, OpenAI published Research acceleration: The jagged frontier, a follow-up to its September report The view inside OpenAI. It measures how its own research staff use coding agents, and the numbers are large, skewed, and moving fast.

This post turns those numbers into a model you can use for your own fleet: what to meter, where parallelism pays, and when a longer task is worth the tokens.

What the Report Says

The headline figures, all from the November report:

  • Spend. "At API list prices, the median researcher's daily usage reached $2,400 in October, up 62% from September." The 90th percentile reached $23,000 a day, up 105%. The September values were $1,500 and $11,000.
  • Runtime. OpenAI defines "every eight hours of agent use as one agent workday." Agent use rose from 0.5 to 5.7 agent workdays per researcher per day, "an elevenfold increase." Pretraining and posttraining teams averaged roughly eight.
  • Concurrency. "By mid-October, more than two-thirds of included researchers averaged a daily peak of at least four agents working concurrently and more than 10% averaged at least sixteen concurrent agents."
  • Autonomy. Estimated success without human intervention rose from 23% to 46% for tasks that take a human two to four hours, between March and October 2026. For four to eight hour tasks it rose from 13% to 35%.

The report also lists caveats, and they matter for anyone copying the numbers:

  • Spend is at list prices, not what OpenAI pays. It "captures a wide variety of changes including increased activity, shifts to more expensive models."
  • "OpenAI researchers do not currently have agentic coding quotas." This is demand without a cap.
  • The workday metric "generally includes interactive use only, so it may undercount automations."
  • A harness change on August 21 "coincided with a sharp decrease in input token utilization" and was reverted gradually from September 10. Token spend moved because the tooling changed, not because the work did.
  • On autonomy: "researchers may also have changed the types of tasks delegated within each duration bucket." Part of the gain may be better task choice, not better models.

Three Numbers Worth Deriving

The tail is the budget. The p90 user spends about 9.6 times the median ($23,000 / $2,400). In September the ratio was about 7.3. The tail is growing faster than the middle. A per-seat budget set at the median covers half your users and fails the ones who use agents most.

Runtime has a unit price. 5.7 agent workdays is 45.6 agent-hours per researcher per day, about two agents running around the clock. Divide the median spend by that and you get roughly $53 per agent-hour at list price. Treat this as a rough figure: it divides a median by an average, and the two numbers may not cover the same days. It is still useful, because it gives you a rate to multiply task lengths by.

Success rate is a cost multiplier. If an attempt succeeds with probability p and you retry until it works, you pay for 1/p attempts per success. At 23% that is 4.3 attempts. At 46% it is 2.2. The doubling in autonomy halved the cost of a finished two to four hour task, at the same price per token. For four to eight hour tasks, attempts per success fell from 7.7 to 2.9.

Worked Example: When Is a Longer Task Worth the Tokens?

The report does not give cost per task, so here is a model with our own assumptions. Change them to your numbers.

  • An engineer's loaded cost: $120 per hour.
  • Agent cost: $53 per agent-hour (the rough figure above).
  • An agent needs about two thirds of the human time to attempt a task.
  • Every attempt needs a human review: 15 minutes for a 3-hour task, 30 minutes for a 6-hour one.
Task Human cost Cost per attempt (agent + review) Success rate Expected cost per success
3 hours, March $360 $106 + $30 = $136 23% $591
3 hours, October $360 $136 46% $296
6 hours, March $720 $212 + $60 = $272 13% $2,092
6 hours, October $720 $272 35% $777

Under these assumptions, delegating a 3-hour task went from a loss to a saving. The 6-hour task is still slightly more expensive than doing it by hand.

The general rule falls out of the table: delegate when the success rate is above the cost per attempt divided by the human cost. Here that break-even is 136 / 360, about 38%, for both rows, because every cost grows with task length. So a longer task is not worse in itself. It is worth the tokens when its success rate in your environment clears the break-even.

Two traps make the model too optimistic:

  1. Failures correlate. The 1/p formula assumes every retry is a fresh coin flip. A task that failed twice for a missing permission or a vague spec will fail a third time. Cap retries at two, then hand the task to a human with the agent's notes.
  2. Review time is not fixed. A wrong result that looks right costs more review than a clean failure. If reviewers start to skim, your measured success rate goes up while real quality goes down.

Where Parallelism Pays

The report counts concurrent agents, but it does not connect concurrency to output. What it does say is that "workflows require close human involvement to avoid low-quality outputs and wasted cycles." That makes the human, not the GPU, the usual limit on parallelism.

A simple ceiling: useful concurrency is about review capacity divided by review time per result. Say a reviewer gives agent output three hours a day, and a review takes 15 minutes. That is 12 results a day. If each attempt runs two agent-hours, 12 attempts is 24 agent-hours, or three agent workdays. A fleet above that produces results nobody reads in time, and you pay for them anyway.

Parallelism pays when:

  • tasks are independent, so one agent's output does not block another's;
  • a machine check (tests, a build, a metric) filters results before a human sees them;
  • the task category has a high success rate, so most results are worth reading.

It does not pay when tasks share state, when review is the queue, or when the category fails often.

Route by Task Category, Not by Hope

"Jagged" in the report's title means the gains are uneven: "models are not equally good across all task categories." Its success rates from August 1 to October 18, 2026, for three broad categories (Communicate, Analyze, Build) and for individual tasks, turn into attempts per success:

Category or task Success rate Attempts per success Fleet policy
Monitoring runs 79% 1.3 Run in parallel, light review
Answering technical questions 72% 1.4 Run in parallel, spot-check
Communicate 69% 1.4 Parallel, human edits before sending
Analyze 58% 1.7 Parallel with a machine check
Build 43% 2.3 Few at once, full review
Building eval, RL or agent environments 29% 3.4 One at a time, human pairs
Writing inference or serving code 25% 4.0 Human leads, agent assists

The SRE reading is direct: watching things and answering questions are the cheap, parallel jobs. Writing production serving code is where an agent costs four attempts per success. Our post on which tasks to give an AI agent explains the pattern: tasks with an outside check succeed more often.

What to Meter

A fleet budget needs these meters, per person and per task:

  • Spend at list price and at billed price. List price compares across vendors. Billed price is what finance sees. Report both.
  • Spend distribution, not average. Track p50 and p90 per user per day. Alert on the ratio, not just the total.
  • Agent-hours. Use the eight-hour agent workday if you want to compare with OpenAI's figures.
  • Peak concurrency per user per day. This is what your rate limits and quotas meet.
  • Success without intervention, by task length and category. This is the cost multiplier.
  • Review minutes per result. This is the parallelism ceiling.
  • Harness and model version on every run. OpenAI's August harness change shows that token counts can move for tooling reasons. Without a version tag, you will read a tooling change as a usage change.

For where the tokens inside a single run go (cache hits, context re-reads, idle time), see our breakdown of AI agent token costs.

Metering Incident Agents in Akmatori

Incident agents fit the same model, with one run per incident. In the Akmatori API, GET /incidents/:uuid returns an incident with its agent runs, latest response, full log, token count and execution time, and GET /incidents filters by creation time with from and to. That gives you tokens and runtime per incident over any window, which is the input to a cost-per-investigation figure. If you want central keys, budgets and logs across model backends, the local models guide shows how to put a LiteLLM proxy in front of Akmatori as a Custom model. The budgets are LiteLLM's, enforced at the proxy.

Conclusion

OpenAI's numbers are one company's research staff, at list prices, with no quotas. Do not copy them as a forecast. Copy the method: budget for the tail, price agent time by the hour, treat success rate as a cost multiplier, cap parallelism at review capacity, and route by task category. A longer task is worth the tokens when its success rate clears cost per attempt over human cost, and you only know that rate if you meter it.

If your team wants AI-assisted incident workflows with token count and runtime recorded for every investigation, Akmatori helps SRE teams investigate alerts, coordinate response, and automate safe infrastructure actions. Powered by Gcore for global infrastructure reliability.

Automate incident response and prevent on-call burnout with AI-driven agents!