I Gave My AI a Team. Here Is What Happened to the Expensive Work.

The new shape of the work

The expensive model leads. The specialists carry the bulk.

I had built an increasingly capable Codex setup, but I had also created an expensive habit.

The best OpenAI model was reading almost everything: source files, long logs, screenshots, repeated searches, build output and the full history of earlier decisions. It was acting as strategist, researcher, developer, tester and proofreader at the same time.

That works. It is also a poor use of the most expensive attention in the system.

So I changed the job. The OpenAI model now leads the work. It decides what needs doing, divides the task into bounded assignments, checks the returned evidence and makes the final call. Lower-cost models reached through OpenRouter do much of the reading, implementation and testing.

The simple version is this:

The short version

All four roles use high reasoning effort. That matters to me: delegation should change who does the work, not quietly lower the standard of thought.

Why tokens become a cost problem

AI systems do not read text as pages or words. They read tokens, small pieces of text. A short word may be one token; a longer word may be several. Code, data and tool output count too.

Every time the lead model needs the growing conversation again, much of that material can be processed again. A large result early in a long task can therefore keep affecting later turns.

The expensive part was not only the final answer. It was repeatedly carrying raw working material inside the OpenAI lead's context.

The old flow and the new flow

flowchart LR
  U["My request"] --> L["GPT-5.6 lead"]
  L -->|"Exact text task"| D["DeepSeek worker"]
  L -->|"Exact visual task"| Q["Qwen worker"]
  D -->|"Compact findings + proof"| L
  Q -->|"Visual findings + proof"| L
  L --> V["Validated result"]

The workers do not receive the whole conversation by default. They get the smallest complete package: the goal, the relevant files and the evidence they need. Credentials and unrelated private material stay out of those packages.

How this changes the bill

There is no magic removal of cost. The cost moves and, when the system behaves properly, shrinks at the expensive end.

Each model request is charged according to how much text it processes and produces. Keeping bulky working material away from the lead therefore reduces the amount OpenAI has to process. Large intermediate outputs are handled elsewhere and returned as shorter reports.

The OpenRouter calls have their own bill, so the honest comparison is not “paid versus free.” It is work moved from the more expensive lead to lower-cost specialists, plus a smaller lead-model review.

The exact saving will vary by task. A short question may not benefit at all. A long task involving dozens of files, test logs or screenshots can benefit much more.

What the historical evidence says

I built a usage-reporting tool and froze a real, unusually large TradeHero session so the numbers could be reproduced. An independent checker then calculated the totals again with a separate parser.

The strongest signal is not a promised percentage saving. It is the amount of supporting material that could have been kept out of the OpenAI lead's working memory if more of the session had been delegated properly.

In other words: the old workflow gives us clear evidence of the problem. The new workflow gives us a credible mechanism for reducing it. More comparable sessions are needed before I publish a reliable percentage or cash figure.

Reliability matters more than a clever diagram

Delegation only saves money if it does not create a second bill for correcting bad work.

The operating rules therefore make the lead responsible for quality:

1. The lead may inspect just enough to define the assignment.
2. A worker receives one bounded task and the exact material it needs.
3. The worker returns evidence, not merely “done.”
4. The lead checks that evidence before reporting completion.
5. A stalled worker is stopped and replaced with a narrower assignment.
6. Completed workers are closed immediately so work does not quietly duplicate.

The audit is session-scoped. It starts for significant work, watches only that Codex session and exits after 15 minutes without activity. There is no machine-wide job waking up every ten minutes when Codex is not in use.

What this proves, and what it does not

That distinction is important. “We changed the plumbing, therefore the bill fell by 80%” would be a good headline and bad evidence.

The honest conclusion is still useful: I now have a working system designed to reserve OpenAI's expensive context for the work that benefits most from it. The supporting labour can be sent to capable, lower-cost specialists, and the lead remains accountable for the result.

The part I like most

The biggest improvement is not that several models can run at once. Parallel activity is easy to make impressive and surprisingly easy to make wasteful.

The useful change is separation of responsibility.

The lead has to decide. The workers have to show their work. The visual specialist receives actual images. The text specialists receive exact files. A failed route has a defined fallback. A completed worker is closed. A significant session ends with a check that the delegation rules were followed.

That makes the setup easier to reason about, easier to test and much less likely to spend premium tokens on work that did not need a premium model.

The next stage is measurement rather than invention: compare several similar tasks, record the OpenAI parent tokens and OpenRouter worker tokens separately, and publish the real difference. Until then, I would rather show the mechanism and its limits than decorate an estimate with false certainty.

For the related local-model work, see How I Ran Qwen Locally Inside Codex on an Apple Silicon Mac.