OpenAI just published how it maintains its own codebase, and the numbers are worth a slow read: five engineers, working part-time over two weeks, merged more than 1,400 pull requests that started as GPT-6 proposals and deleted over 800,000 lines of dead code. One service's container image went from 3.31 GB to 1.72 GB.
The post, by Rodrigo Roim of OpenAI's Core Experimentation team, published October 15, is a workflow document, not a launch announcement. Nothing in it requires an OpenAI model. Codex loads third-party providers from config.toml, so the same loop runs on any endpoint that speaks the Responses API. Below: the workflow as they describe it, then the part they didn't include: what a maintenance pass costs on three model tiers, including the open-weight one.
Disclosure: Wallaby Token sells API access to Kimi K3, one of the three configurations priced below. The workflow facts are quoted from OpenAI's post, fetched October 16, 2026.
The three jobs
Removing unused code. The origin story: one prompt that found dead code well enough that five engineers ran variations of it across repositories. The 1,400-PR total came from that, part-time, in two weeks. Beyond the 800k deleted lines, the side effects were concrete: the 48% smaller container image, and about 400 visual snapshot variants dropped from a test suite.
Cleaning up stale experiments. Harder, because the code still runs in production. Static analysis alone produced false negatives, so Roim did something notable: he brainstormed the prompt with GPT-6 Astra, ran it, reviewed the pull requests, fed his review comments back, and had the model fold them into a new prompt that scans the entire codebase, plus a second prompt to prioritize what it found. The prompt is the artifact that improves, not just the code.
Fixing flaky tests and CI time. Same pattern, aimed at continuous integration. About 30 CI optimization PRs later, median CI completion fell from roughly 10 minutes to 4.5, and the 90th percentile from 12.5 to 6. One fix, adding a missing mock, took a 63-test resolver suite from 592.6 seconds to 29.8, with all 63 tests retained.
The loop, not the model
Strip the model names out and the method is four steps: pick one small maintenance task, ask the agent to find an instance and gather evidence, review the draft PR like you'd review a junior colleague's, then fold your review into the next prompt and widen the scope. OpenAI's own advice is to compare models and effort levels on the small task first, because "a cheaper configuration may be enough." They suggest GPT-6.1 Sol at Medium effort as the starting point.
They also include the honest caveat: some proposals added more complexity than their benefit justified. A maintenance agent without a review discipline is a complexity generator. The loop is the product.
What one pass costs
Here's a worked example. Say a cleanup pass on a mid-size service burns 1.0M input tokens and 0.15M output tokens, with 80% of the input served from cache after the first turns, which is typical for an agent loop that rescans the same tree. At list prices as of mid-October 2026:
| Configuration | Input (20% full + 80% cached) | Output | Cost per pass |
|---|---|---|---|
| GPT-6 Astra ($10 / $1 / $50) | $2.00 + $0.80 | $7.50 | $10.30 |
| GPT-6.1 Sol ($2 / $0.10 / $10) | $0.40 + $0.08 | $1.50 | $1.98 |
| Kimi K3, official list ($3 / $0.30 / $15) | $0.60 + $0.24 | $2.25 | $3.09 |
| Kimi K3 on Wallaby ($2.70 / $0.27 / $13.50) | $0.54 + $0.22 | $2.03 | $2.78 |
Rows are rounded to the cent; totals are computed before rounding.
Wallaby's rate is 10% off the official Kimi K3 list, ongoing.
Read the table the way OpenAI's advice implies: per pass, GPT-6.1 Sol is the price-performance answer for this workload — its cached input rate is the lowest in the table, and maintenance loops are cache-heavy by nature. Astra costs five times more per pass and earns it only on the hardest audits. Kimi K3 sits between them on price, and it's the row that's different in kind: an open-weight model you're not renting from the company whose codebase strategy you're copying. If OpenAI changes a price, a context window, or a deprecation schedule (and it just retired GPT-5.5 out from under Codex users on three days' notice), an open-weight checkpoint is the one asset that stays put.
One number the table can't give you: quality on your repository. OpenAI's own guidance is to run the small task on candidate models and compare, which is cheap to actually do. A single pass at the scale above costs less than a lunch on any row of that table — and $0.50 of trial credit covers several of them, with every request itemized so you can check this math against your own meter.
Running it on a third-party endpoint
Codex's custom-provider door is documented: a [model_providers] block in config.toml, any endpoint that speaks the Responses API natively. The full configuration, including the current-version pitfalls, is in our earlier walkthrough: Kimi K3 in Codex CLI. If you're migrating off a ChatGPT-signed-in Codex setup after this week's GPT-5.5 retirement, the migration post covers that path.
Then steal the loop verbatim: one stale feature flag, one flaky test, one draft PR. Measure. Widen.
A note on dates: workflow details come from OpenAI's October 15, 2026 post; prices were checked October 16 and change often, so verify each provider's current rate card before budgeting around this table.
Want to price this on your own repo? A new Wallaby Token account comes with $0.50 in trial credit — enough for several cleanup passes at the scale above, with every request itemized in the dashboard so you can check our math. The minimum top-up is $20, and the rate stays 10% off the official list, ongoing.