<think>Planning markdown-preserving translation

</think>

OpenAI Researchers Burn $7,000 in Tokens a Day as AI Coding Enters the Era of Heavy-Duty Tasks

OpenAI’s AI coding agents are no longer merely helping researchers fill in a few lines of code.

On Sunday local time, OpenAI disclosed in an internal overview of usage that, as of mid-August 2026, researchers in the company’s research division who ranked in the top 10% by AI coding agent usage were consuming more than $7,000 worth of tokens per day based on public API prices—equivalent to approximately RMB 47,000. The median daily token consumption of ordinary researchers in the research division also rose from $162 in July this year to more than $600 by mid-August.

This figure first illustrates one thing: within OpenAI, AI coding agents have evolved from “tools that improve coding speed” into infrastructure embedded in the research workflow.

More importantly, the increase in token consumption is not simply because employees are asking models questions more frequently. OpenAI said that over the past year, researchers have significantly accelerated the pace at which they deliver code and conduct experiments, while also beginning to delegate more advanced and complex tasks to agents. Over the past three months, the use of these tools in the research division has grown even faster than in other teams across the company.

This is not an ordinary case of tool adoption. The division of labor in R&D is changing.

$7,000 Is Not a Bill, but It Is Still Expensive

Let’s clarify the figure first.

The $7,000 disclosed by OpenAI does not mean that the company actually paid $7,000 in cash for this researcher. It is a “theoretical cost” calculated by converting input and output tokens according to public model inference prices. Large model companies typically use computing-resource scheduling, batch processing, and resource accounting methods that differ from those in the public market, so the actual marginal cost may be much lower.

But that does not mean the figure is meaningless.

Conversion based on public prices is more like a ruler used to measure how many computing resources an agent is actually consuming, as well as the “computational intensity” of an R&D task on the model side. When a researcher consumes more than $7,000 worth of tokens per day, it may mean that they are having an agent continuously read large codebases, run multiple rounds of testing, analyze error logs, modify implementations, and then plan the next step based on the new results.

The traditional workflow of chat-based AI is roughly this: a person asks a question, the model answers, and the two exchange messages back and forth. An AI coding agent is more like a junior engineer who can operate a terminal: it breaks down tasks, browses repositories, calls tools, executes code, reads test results, modifies files, and continues trying after failures.

Each step may generate new context. The longer the context, the larger the codebase, and the more test rounds involved, the faster token consumption grows. If a task also launches multiple sub-agents responsible for searching code, designing solutions, writing tests, and reviewing results, consumption will increase further.

Therefore, $7,000 does not necessarily mean that the researcher was “chatting.” More likely, it represents a model working continuously over a period of time.

From Code Completion to an Automated Research Intern

Over the past two years, the most visible value of AI coding tools has been code completion, function generation, error explanation, and converting natural language into simple scripts. These tools addressed local problems: how to write a function, how to modify an SQL query, or why an API was returning an error.

Now, OpenAI is pushing agents to another level: having them participate in the complete research loop.

A typical task might look like this:

1. A researcher proposes an experimental objective, such as verifying whether a particular training strategy can improve a model’s performance on a specific task;
2. The agent reads the existing training framework, data-processing scripts, and experiment configurations;
3. It identifies reusable code paths, designs a modification plan, and adds experimental scripts;
4. It automatically runs multiple sets of experiments and collects metrics, logs, and exception information;
5. It investigates failed results, determining whether they are caused by code defects, parameter issues, or an invalid experimental hypothesis;
6. It outputs change records, comparative results, and suggestions for the next round, while the researcher decides whether to continue.

This is no longer “help me write a piece of code.” It is “help me advance a research idea to a verifiable state.”

OpenAI says the company has already achieved the goal proposed by CEO Sam Altman last year: building an “automated research intern” capable of completing tasks under human guidance. Following its current roadmap, the company plans to build a fully automated AI researcher by March 2028.

Whether this goal can be achieved on schedule will still depend on model reliability, experimental environments, permission controls, and result validation. But judging from the internal usage data, OpenAI has clearly begun treating AI agents as a core variable in upgrading its R&D organization—not merely as developer plugins.

The Real Change Is That Humans Are Becoming Reviewers Rather Than Executors

The most direct impact of AI coding agents is not that engineers will disappear entirely, but that the places where engineers spend their time are changing.

Previously, a researcher might spend half a day familiarizing themselves with an unfamiliar module, modifying several pieces of code, and then waiting for an experiment to finish. Now, an agent can first complete code searches, an initial implementation, and test troubleshooting, allowing the researcher to focus on whether the problem is worth pursuing, whether the experiment is properly designed, and whether the results are credible.

This means that researchers’ focus is shifting from “how to write the code” to questions such as:

• How should the task be broken down, and which steps are suitable for delegation to an agent?
• Does the implementation generated by the model comply with system constraints?
• Are the experimental results reproducible, and are the metrics affected by the data or evaluation method?
• Is the agent actually solving the problem, or merely modifying code repeatedly until the tests temporarily pass?
• Does an expensive, long-chain invocation really deliver sufficient R&D value?

For mature teams, this shift may increase R&D throughput. For less experienced teams, the risks will grow as well: an agent capable of running continuously for hours may quickly produce large amounts of code that appears reasonable but is difficult to maintain in practice.

Code review will therefore not disappear. On the contrary, it will become more important. The object of review, however, will shift from a few hundred lines of human-written code to the entire change trajectory produced by an agent, including tool calls, testing processes, failed attempts, and final decisions.

Why Are Tokens Increasing So Quickly?

The cost of an AI coding agent is usually not determined by the few hundred lines of code it ultimately generates, but by the entire process.

1. Contexts Are Getting Longer

To understand a task, an agent needs to read the repository structure, dependencies, configuration files, interface definitions, historical error logs, and test results. In many cases, the amount of content actually processed by the model is far greater than the content ultimately written to files.

A seemingly simple bug may involve dozens of files. Every time the model replans, it may carry the previous context into the next round of calls. The larger the context window, the higher the number of input tokens in each request.

2. More and More Trial and Error

An agent does not necessarily generate a solution successfully in one attempt. It often goes through a cycle of “modify—run—encounter an error—analyze—modify again.” For complex projects, dozens or even hundreds of attempts are not unusual.

If every round requires reading the complete error stack, relevant code, and history of previous operations, token consumption can accumulate rapidly.

3. Parallel Multi-Agent Workflows

Complex R&D tasks are often divided among multiple roles: one agent locates the problem, another proposes an architectural solution, a third handles implementation, and another performs testing and review. Parallel collaboration can reduce waiting time, but it also increases the cost of repeatedly reading context and passing results between agents.

4. More Capable Models Are Taking on More Difficult Tasks

When an agent is used only for code completion, a low-cost model is usually sufficient. But once the task involves cross-module refactoring, experimental design, or complex troubleshooting, teams tend to call on more capable models with higher reasoning costs.

This is also an important reason why OpenAI’s internal token-price estimates are rising so quickly: usage is increasing, but so are task difficulty and the value of each individual call.

A 50% Drop in Posts on the Technical Support Channel Suggests It Is Taking Over the “Dirty Work”

OpenAI also disclosed an interesting internal metric: since January this year, the number of daily posts in the internally operated technical support channel has fallen by more than half.

This may mean that researchers have begun asking AI coding agents to troubleshoot problems first, submitting only unresolved issues to human support. Large volumes of repetitive technical inquiries—dependency conflicts, build failures, abnormal test scripts, API usage, and log analysis—are being absorbed by agents.

These tasks are not necessarily advanced, but they consume a great deal of engineers’ time. They share several characteristics: information is scattered, the troubleshooting path is relatively standardized, and the results can be verified through tests or logs. For agents, this is the type of work best suited for initial adoption.

There is, however, a boundary here. An agent’s ability to reduce questions about “how to fix something” does not mean it can automatically determine “whether it should be fixed.” When a problem involves system architecture, research direction, resource allocation, or security risks, decisions still require people with the necessary context and clearly defined responsibility.

In other words, AI can reduce the pressure on support teams by handling low-level repetitive problems, but it has not yet taken on ultimate responsibility for the organization.

High Token Consumption Does Not Equal High Productivity

The $7,000 figure can easily create a misconception: that the more tokens a researcher burns, the more productive they are.

The opposite is often true. Tokens measure the consumption of computing resources, not the output of R&D. A model can use billions of tokens to generate large amounts of useless code, or use relatively few tokens to identify a critical problem.

If a company directly uses token rankings to measure employees’ level of AI adoption, it can easily encourage “token maximization”—employees may run agents for long periods, repeatedly generate solutions, or even package simple tasks as complex workflows in order to demonstrate their enthusiasm for embracing AI.

This can result in three types of waste:

• Computational waste: Low-value tasks consume expensive inference resources;
• Review waste: The more code that is generated, the higher the cost of human verification and maintenance;
• Organizational waste: Teams shift their attention from delivery results to tool-usage data.

The metrics that truly deserve attention should be the effective output generated per token—for example, how much the experimental cycle has been shortened, whether the defect rate has fallen, whether the code can be maintained reliably, whether research hypotheses are being validated more quickly, and whether an agent’s results can be reused by other team members.

If a team spends tens of thousands of dollars every day without completing experiments faster, reducing production issues, or improving model capabilities, then the expenditure is merely automating inefficiency.

OpenAI’s Next Question: Who Will Manage the Compute Budget?

Once AI coding agents are deployed at scale, cost management will evolve from “purchasing a software account” into “managing a digital R&D team.”

Companies will need to answer several specific questions:

1. Which tasks can use high-cost reasoning models, and which must be switched to lower-cost models?
2. After an agent has run for how long without making progress should it automatically stop?
3. Does the benefit of running multiple agents in parallel outweigh the cost of duplicating context?
4. To what extent should code repositories, internal documents, and experimental data be made accessible?
5. Who is responsible for the code and experimental conclusions submitted by an agent?

In the future, R&D platforms may well develop an “Agent FinOps” function similar to cloud-computing budget management: tracking token consumption by project, task, model, and workflow, and associating costs with verifiable output.

For developers, this also means that prompt engineering is no longer just about writing a better prompt. More important are the design of efficient task boundaries, context caching, tool-calling strategies, failure-retry mechanisms, and human-approval checkpoints. An excellent agent workflow should know when to continue exploring, when to reuse existing results, and when to stop and request human judgment.

What This Means for Ordinary Development Teams

The figures from OpenAI’s research division cannot be directly applied to every company. OpenAI has access to cutting-edge models, vast code assets, and a high density of research tasks, many of whose experiments are inherently worth substantial computing costs.

But the signal it sends is clear: competition among AI coding tools is shifting from “can they write code?” to “can they continuously complete complex tasks?”

For ordinary R&D teams, a pragmatic rollout sequence would be:

• Start with verifiable tasks such as log troubleshooting, test completion, dependency upgrades, and documentation synchronization;
• Provide agents with isolated development environments and prevent them from directly operating production systems;
• Require all automated modifications to retain diffs, test records, and tool-call traces;
• Evaluate effectiveness using task success rates, delivery cycles, and defect rates rather than token volume alone;
• Set budgets, timeouts, and human-confirmation mechanisms for high-cost models;
• Connect agents to code search, test execution, and monitoring tools, while restricting their access to sensitive data.

If a team is using platforms compatible with the OpenAI format, such as OpenAI Hub, to centrally call models including GPT, Claude, Gemini, and DeepSeek, it should pay even more attention to incorporating model routing, cost tracking, and failure fallback into workflow design, rather than focusing only on which model generates code faster. Model aggregation can reduce switching costs, but it cannot solve permission, review, or budget issues for the team.

Conclusion: R&D Organizations Are Being Repartitioned

The story of OpenAI researchers consuming $7,000 worth of tokens every day may appear to be about “burning money,” but at a deeper level it demonstrates a new form of R&D organization: humans set the direction, agents conduct large amounts of exploration, toolchains handle verification, and researchers make judgments and bear responsibility.

When AI coding agents could only complete functions, developers treated them as productivity plugins. Once they can understand codebases, run experiments, locate faults, and iterate continuously, they begin to resemble schedulable R&D labor.

This is also why OpenAI has set the goal of a fully automated AI researcher by 2028. That goal does not necessarily mean human researchers will be directly replaced, but it does mean that many intermediate steps once requiring humans to perform personally are becoming machine tasks that can be executed in parallel, tracked, and billed.

The real dividing line going forward will not be who consumes more tokens, but who can turn those tokens into reliable results. For developers, the most valuable lesson is not “how to keep an agent running,” but “how to make it run long enough on the right problem—and stop it in time when it is heading in the wrong direction.”