OpenAI's Researchers Burn $600 to $7,000 a Day on Agents: Building the ROI Telemetry Your Team Needs

On September 6, 2026, OpenAI published an unusually candid post, "Research acceleration: The view inside OpenAI," opening the books on how its own researchers use AI coding agents. The eye-catching part is money: by mid-August the median researcher consumed more than $600 per day of inference at API prices, and the top 10% of users burned more than $7,000 per day. The more instructive part is efficiency: the research organization now runs 3.1 agent-workdays of effort for every workday of human labor, and experiments per active researcher hit an all-time high in August, the best month since tracking began in January 2025. OpenAI says it has reached its goal of an automated research intern. This post is not about OpenAI's strategy. It translates the report into what most engineering teams actually need: which numbers to track, how to measure real agent ROI, and how to build your own telemetry stack.

1. What OpenAI Actually Published

The report is an internal review of how OpenAI uses AI to accelerate its own research, published on its website on September 6 and covered by Fortune and Business Insider in the following days. The core framing is not "how much code we wrote" but three groups of metrics: inference spend per person, the ratio of agent-workdays to human workdays, and experiments per active researcher. The report says that at the start of 2026 the median researcher used coding agents only modestly; by mid-August agents were integrated into daily work, with median daily inference spend above $600 at API prices and the top 10% of users above $7,000 per day. Fortune added the aggregate figure: across the research organization, every human workday now corresponds to about 3.1 agent-workdays.

# Load daily usage events and group cost by developer.
import json, collections

def cost_per_user(events):
    by_user = collections.defaultdict(float)
    for e in events:
        u = e["user"]
        by_user[u] += (
            e["input_tokens"] / 1_000_000 * e["input_price_per_mtok"]
            + e["output_tokens"] / 1_000_000 * e["output_price_per_mtok"]
            + e["cache_read_tokens"] / 1_000_000 * e["cache_price_per_mtok"]
        )
    return by_user

with open("usage_2026-09-09.json") as f:
    events = json.load(f)
for user, cost in sorted(cost_per_user(events).items(), key=lambda kv: -kv[1]):
    print(user + ": " + "$" + f"{cost:.2f}")

2. Why Those Numbers Matter for You

OpenAI's figures look like big-lab extravagance, but they hide two regularities that hold for ordinary teams too. First, agent usage does not climb gradually; it jumps once people cross a habit threshold, moving from occasional use to daily use with almost no middle ground. Second, spend is extremely concentrated: a $600 median versus a $7,000 90th percentile means roughly 10% of users drive most of the cost. If your team starts rolling out agents at scale, both patterns will almost certainly reproduce. So never track only the average. Watch the median and the 90th percentile too, or you will discover the problem only when the top decile blows through your budget.

# Median and 90th percentile daily spend, OpenAI-style.
def percentiles(values, p):
    values = sorted(values)
    k = (len(values) - 1) * p
    lo, hi = int(k), min(int(k) + 1, len(values) - 1)
    return values[lo] if lo == hi else values[lo] + (values[hi] - values[lo]) * (k - lo)

daily = [120.0, 340.0, 610.0, 820.0, 1500.0, 2400.0, 4600.0, 7100.0]
print("p50: " + "$" + f"{percentiles(daily, 0.5):.0f}")  # median
print("p90: " + "$" + f"{percentiles(daily, 0.9):.0f}")  # heavy user

3. Where the Tokens Actually Go

OpenAI also disclosed where agent tokens go. In January 2026 the dominant category was research and infrastructure code. By August that category was still growing, but "technical help" and "monitoring runs" had risen noticeably, while high-level planning remained a tiny fraction throughout. This matches the current capability boundary of agents: they are best at well-defined, verifiable middle-layer work such as writing tests, fixing bugs, and watching experiment state, and weak at fuzzy strategic planning. The practical implication: deploy agents where there is a clear definition of done. Do not expect them to decide what should be built.

# Agent-workday ratio: agent minutes vs. human minutes in the loop.
# OpenAI reports 3.1 agent-workdays per human workday inside research.
def agent_ratio(agent_minutes, human_minutes):
    return agent_minutes / max(human_minutes, 1)

# If 3 engineers supervise agents for 6 hours while agents run 55 hours:
print(agent_ratio(55 * 60, 3 * 6 * 60))  # 3.06

4. The Right Way to Measure Agent ROI

Most teams measure agents by token counts or generated lines, and both metrics lie: more tokens can mean worse prompts, and more lines can mean more filler. A more honest KPI is cost per completed task: use one verifiable task, such as fixing a test, adding an endpoint, or refactoring a module, as the unit of account, then divide total cost by completions to get a true per-task price. Multiply that by the task's value to the business and you can finally judge whether the agent earns its keep. OpenAI's choice of experiments per active researcher as the output metric is the same philosophy: measure verifiable outcomes, not process volume.

5. Building Your ROI Telemetry in Four Steps

Step one: persist the usage payload of every API call per user instead of only the grand total, or you will never know who is burning money. Step two: convert input, output, and cache-read tokens to dollars using your price sheet, then aggregate by user and by task. Step three: tag every task with an ID, make cost-per-task the central dashboard metric, and spot-check outputs with a diff tool. Step four: add budget gates that warn at 80% of the daily limit and block at 100%; one false positive during the day beats a surprise invoice at month end. For tooling, estimate cost before running with a token counter and flatten logs into chartable CSVs.

# Cost per completed task beats tokens per prompt as a KPI.
TASKS = {"fix_test": 3, "add_endpoint": 5, "refactor_module": 11}

def cost_per_task(cost_by_task_id, task_ids):
    return {t: cost_by_task_id[t] / task_ids.count(t) for t in set(task_ids)}

costs = {"t1": 4.2, "t2": 9.8, "t3": 12.1, "t4": 1.9}
ids = ["fix_test", "fix_test", "add_endpoint", "refactor_module"]
print(cost_per_task(costs, ids))

6. Don't Copy OpenAI's Budget Book

One dose of sobriety: the $600 median is the result of an internal research organization, first-party models, and an experimentation-first culture. Copying it directly will produce a wrong budget. Your team more likely faces external API prices, more conservative task types, and deliverables that need human review. The practical move is to treat OpenAI's numbers as an upper bound, not an average: pilot on a small scale for two weeks, record cost-per-task and human review rates for each task class, then decide whether to expand. And remember the report's quieter finding: high-level planning still consumes a tiny fraction of tokens, which means the human-machine division of labor is not going away. Let agents execute, and let humans decide what to build and whether the result is correct. That is the organizational shape with the highest ROI.

# A daily budget gate: warn, then block, as spend climbs.
class AgentBudget:
    def __init__(self, daily_limit):
        self.daily_limit = daily_limit
        self.spent = 0.0

    def charge(self, amount):
        self.spent += amount
        if self.spent > self.daily_limit * 0.8:
            print("WARN: over 80% of daily budget")
        if self.spent > self.daily_limit:
            raise RuntimeError("BLOCK: daily budget exceeded")

budget = AgentBudget(daily_limit=100.0)
budget.charge(95.0)  # prints WARN