Welcome to the show, and thanks to Jellypod for helping make this daily show a
reality.
I'm Ethan Park, here with Maya, and today we are looking directly at some highly
practical updates in Codex 0.142.0.
If you have ever run a multi-agent workflow and watched in horror as your primary
agent unilaterally decided to spawn five sub-agents, which then spawned their own
sub-agents, all burning through your API credits, you are going to appreciate this
release.
Oh, the classic agent sprawl.
It is a genuine nightmare for budget predictability.
You start a simple refactoring task, and suddenly you have a recursive tree of
agents discussing variable names on your dime.
It is basically the software engineering version of Mickey Mouse and the magic
brooms in Fantasia.
Exactly.
And to fix this, Codex has introduced three distinct delegation modes in
0.142.0: disabled, explicit-request-only, and proactive.
They give you direct, granular control over how and when an agent can hand off tasks
to a sub-agent.
Let us break those down.
"Disabled" is pretty self-explanatory-it completely cuts off the agent's ability to
spawn or delegate to any sub-agents, right?
It keeps everything strictly single-agent.
Right.
The agent has to solve the problem with the tools it has locally,
or fail.
Then you have "explicit-request-only".
In this mode, the agent can only delegate if it explicitly asks you,
the operator, for permission first, or if your prompt directly instructs it to spin
up a helper.
It cannot make that call on its own mid-run.
And then "proactive" is basically the old behavior?
Where the agent can autonomously decide, "Hey, this sub-task is better suited for a
specialized code-writer agent, I am going to spin one up right now"?
Yes, but now it is a deliberate choice you make, rather than the default wildcard
behavior.
And setting this up is incredibly straightforward.
It is all managed in your `.codex/config.toml` file.
You just add a ` ` block and set the `mode` key.
So, for example, `mode = "explicit-request-only"`.
That is great for global settings, but what if I have a specific script where I want
to allow proactive delegation just for that run, without changing my global config?
Can we override it dynamically?
Absolutely.
You can pass the mode dynamically on a turn-by-turn basis through the CLI or the API
wrapper.
This means you can keep a tight global default like "disabled" to prevent accidental
spend, and only open the gate to "proactive" when you are running complex,
trusted pipelines.
Speaking of preventing runaway spend, let us talk about the new rollout token
budgets.
Because even if you allow delegation, you still need a hard ceiling.
Under the hood, how does Codex actually track this now?
This is a big architectural improvement.
Previously, tracking was often localized to a specific agent's run.
Now, Codex tracks cumulative token usage across entire agent threads,
including all sub-agents.
You set a hard limit-a rollout token budget-and as the run progresses,
Codex calculates the cumulative burn.
If you start running low, it actually inserts remaining-budget warnings directly
into the system prompts to warn the agent.
Wait, so the agent itself is made aware that it is running out of money?
"Hey, you have fifty cents left, wrap it up"?
Literally, yes!
It tells the agent, "Your remaining budget is X tokens," which encourages it to wrap
up its work or stop spawning deep search loops.
And if the agent ignores that and hits the hard ceiling, Codex doesn't just let it
hang-it automatically aborts the turn cleanly, saving you from those infinite loop
scenarios where an agent tries the same failing tool call fifty times.
That is a massive relief for anyone who has left an autonomous run active while
grabbing lunch, only to return to a massive bill.
Now, let us pivot to some of the terminal and network resilience updates in this
release, because there are some really nice quality-of-life fixes here.
Specifically, the Linux TUI and Ctrl+Z.
Oh, this one was highly requested.
If you were running Codex's Text User Interface on Linux and wanted to temporarily
pause it-say, to run a quick git command in your shell-you would press Ctrl+Z to
suspend it.
But when you typed `fg` to bring it back to the foreground,
the terminal rendering would completely break.
Text would overlap, and the layout would turn into a scrambled mess.
I remember that.
You had to basically close the terminal window or run a manual `reset` command to
get your shell looking normal again.
Exactly.
In 0.142.0, they fixed the signal handling for the Linux TUI.
Now, when you bring it back with `fg`, it triggers a clean redraw of the interface
automatically.
It sounds minor, but for command-line purists, it makes the environment feel so much
more native and stable.
And speaking of stability, what about those network disconnects?
I saw something about stdio session survival.
Yes, Stdio MCP-Model Context Protocol-sessions and the underlying
exec-servers are now resilient to transient disconnects.
If you are on a flaky Wi-Fi connection or switching networks,
and the stdio connection drops momentarily, Codex doesn't just crash the session and
throw away your active state.
It keeps the session alive in a holding pattern and cleanly reconnects once the
pipeline is restored.
That is huge for anyone working on laptops while traveling.
You do not lose your entire context just because the train went through a tunnel.
Now, what about the `/usage` command update?
They have completely refactored `/usage`.
It is no longer just a static output of your current token consumption.
You can now inspect your usage-limit reset credits directly from the terminal.
And more importantly, you can redeem those credits in-line.
In-line redemption?
So you do not have to open a browser, log into a dashboard,
click three buttons, copy a code, and come back?
None of that.
You just type `/usage` in your terminal.
If you have earned reset credits, it will show them to you.
You can trigger a redemption right there with built-in confirmation prompts.
And they even built in retry states, so if the billing or credit server has a
momentary hiccup during the redemption request, it won't fail silently or break your
session.
That is incredibly clean.
It really feels like Codex is maturing from an experimental tool into something
designed for highly resilient, professional local development.
It really is.
Well, that wraps up our quick look at Codex 0.142.0.
Dynamic delegation modes, hard token guardrails, and much-needed terminal
resilience.
Thanks for listening, and we will see you tomorrow.
See you then!