OpenAI shows from the inside how it uses coding agents in its own research

OpenAI published a piece called Research acceleration: The view inside OpenAI, commented on by Simon Willison on his weblog on September 6, 2026. The text describes how the company's own research team started using coding agents in its day-to-day work. And, according to Willison, the same day brought another in-house essay, An Alien Mind, by chief scientist Jakub Pachocki, both revolving around RSI, short for Recursive Self-Improvement, a term the material doesn't even bother to spell out.

For those who build software, the important detail isn't the rhetoric about self-improvement. It's the admission, coming from the inside, that 2026 was the year agentic engineering "truly took off" at OpenAI, in Willison's words. In other words: the company that sells the tools is itself reorganizing its research workflow around them. That shifts the benchmark of expectations for any team that still treats coding agents as a weekend toy.

What the chart really says

The point Willison highlights is a chart of AI spend per researcher. There was a significant acceleration at the end of July 2026. His reading, explicitly presented as speculation, is that this is the moment internal employees gained access to the model later released as GPT-6 Astra.

I'm intrigued at what caused that significant acceleration in AI spend per researcher in late July, my best guess is that's when internal employees gained access to the model later released as GPT-6 Astra.

>

-- Simon Willison

It's worth separating fact from inference. The reported fact is the per-researcher spend curve going up. The link to Astra is Willison's hypothesis, not an official OpenAI announcement. But the hypothesis is plausible and says something concrete about the economics of it: when a better model comes into play, cost per person goes up, not down. More capable models get used more intensively (more tokens, more calls, more agent loops), and the payoff shows up in research speed, not in a smaller bill.

In practice, this is the opposite of the intuition held by those who expect that "the new model will make my pipeline cheaper." Those who seriously adopt agents tend to spend more on inference, because the bottleneck stops being token cost and becomes the human time saved.

Why this matters for those choosing a stack

The practical angle for the Brazilian developer is the architecture decision: use a frontier model like Astra via API, bet on open-source models run on your own infrastructure, or mix the two. OpenAI's material doesn't settle that choice, but it does offer a useful market signal: the very owner of the model is willing to spend more per head to speed up delivery. That reinforces a trade-off that already shows up in any agent project:

| Approach | Where it wins | Where it hurts | |---|---|---| | Frontier model via API (e.g., Astra) | Cutting-edge capability, less setup, updates itself | Cost per token grows with agentic use; data leaves your infrastructure | | Open-source self-hosted | Data control, predictable fixed cost, no vendor lock-in | Needs GPU, ops, and a team; lower capability ceiling | | Hybrid (task-based routing) | Sends expensive tasks to the strong model, cheap tasks to the local one | Routing and observability complexity |

The hybrid case is what OpenAI's curve indirectly suggests as the mature path: a strong model isn't for everything, it's for the loop that actually unblocks work. In a typical agentic flow, you can reserve the expensive model for reasoning and planning steps, and delegate mechanical tasks (formatting, extraction, trivial tests) to smaller or local models.

What a research agent loop looks like

The material doesn't publish OpenAI's internal code, so the sketch below is a reconstruction of the pattern that agentic engineering teams have been adopting, not an excerpt from the source. It serves to make the idea of "spend per researcher" concrete:

# Agent pattern that explains why cost per person goes up:
# each task turns into multiple calls in a loop until it passes the tests
for task in research_tasks:
    plan = model_forte.plan(task)          # expensive reasoning
    code = model_forte.write_code(plan)    # generation
    while not tests_pass(code):
        feedback = run_tests(code)         # actual execution
        code = model_forte.fix(code, feedback)  # expensive iteration
    commit(code)

Every while that doesn't converge on the first try multiplies the cost. That's why a better model, one that solves things in fewer iterations, can simultaneously raise total spend (because it gets used on more tasks) and lower the cost per completed task. Measuring cost per isolated token is misleading; the honest number is cost per delivered task.

What remains open

There are clear limits to what the source delivers. Willison is the first to set the tone: he ironically calls the day "RSI day" at OpenAI, pointing out that the material treats Recursive Self-Improvement almost as a new label for AGI, without even explaining the acronym. In other words, a good part of the text is institutional positioning, not reproducible engineering. There's no public Astra benchmark in this specific post, no dollar cost per task, and no detail on which internal agent OpenAI uses.

For the dev, the practical conclusion is sober: the signal that agentic engineering became standard even at the frontier is real, and it's worth calibrating expectations by it. But the decision between Astra, open-source, or hybrid remains an exercise in measuring your cost per task, in your flow, with your latency and privacy data. The sensible path is to run the same task across all three configurations, time iterations until convergence, and compare cost per delivery, not per token. That number, not OpenAI's internal curve, is what pays the bill at the end of the month.

For those who want to follow critical coverage of this kind of material, Willison himself keeps up continuous coverage of LLM releases at simonwillison.net, and it's worth reading the original post to see the cited chart in full.