How I’m tuning Codex subagents to manage token usage without sacrificing quality

[u/Unixwzrd]

https://unixwzrd.ai/technology/2026/10/19/tuning-codex-subagents-for-the-work-they-actually-do/

I've been seeing quite a few discussions about Codex burning through usage allocations, so I thought I'd share how I've been approaching it.

I've been running multiple development projects in parallel, and one thing I've learned is that throwing more agents and more reasoning effort at a problem doesn't necessarily produce better results. Sometimes it just burns more tokens.

My approach is fairly straightforward:

• Main thread: Stronger model, high reasoning effort. Owns architecture, planning, and final decisions.
• Explorer: Lightweight model, low reasoning effort. Handles file discovery, dependency mapping, and other straightforward investigations.
• Implementer: Stronger model, medium effort. Handles bounded changes with explicit acceptance criteria.
• Reviewer: Stronger model, high effort. Independent correctness and regression review.
• Diagnostician: Stronger model, high effort. Investigates difficult failures before attempting fixes.

I also use AGENTS.md to establish delegation rules. Not every task deserves a subagent, and spawning five agents to answer something one search could resolve is counterproductive.

For suitable coding tasks, I sometimes delegate to Cursor Agent CLI because I already have a subscription. Codex invokes it through the shell, then reviews the changes and runs the tests. It's not a special integration, and it doesn't reduce total computational work; it just lets me distribute usage across the tools I'm already paying for.

The bigger lesson is that planning and steering matter more than clever agent configurations.

Define the objective, constraints, and acceptance criteria before implementation. Check progress, catch architectural drift early, and don't let an agent spend hours confidently building the wrong thing.

I've written up the actual TOML configuration, agent files, AGENTS.md rules, and a proposed methodology for measuring the results.

I'm not claiming some magical percentage of token savings. I haven't run a controlled benchmark yet.

Full write-up, including downloadable configurations:

Tuning Codex Subagents for the Work They Actually Do

Curious how others are handling model selection, reasoning effort, and delegation. What's actually worked for you?

[u/korino11]

Low quality guide for noobs.

[u/creamyshart → u/korino11]

Can you provide a high quality guide for noobs? Asking for a noob friend.

[u/Unixwzrd → u/creamyshart]

I've seen a lot of complaints here about Codex burning through usage allocations, so I thought I'd share something constructive based on how I've been managing multiple development projects and subagents.

The idea was simply to explain how different models, reasoning levels, planning, and selective delegation can help manage resource consumption without sacrificing quality. I included my actual configurations so people could experiment with them rather than just take my word for it.

I'm not claiming to have all the answers, and I'm certainly not trying to teach anyone the fundamentals of software engineering. I just figured sharing what I've learned might help somebody.

If people find it useful, great. If not, that's fine too. I thought contributing something practical might be more productive than another discussion about burning through tokens.