OpenAI Codex release notes: 0.143.0-alpha.35 adds multi-agent policy and receipts

OpenAI Codex release notes: the alpha track is about operable agents

OpenAI Codex CLI is OpenAI Codex as a local coding agent in the terminal: it can read code, propose changes, and run tools inside the workspace you give it. OpenAI's stable Codex release notes still stop at 0.142.5, which we covered on July 1. But the GitHub and npm alpha track has moved to 0.143.0-alpha.35, and two signals matter for teams that test Codex early.

The first is 0.143.0-alpha.35: multi-agent V2 gets a configurable multi_agent_mode_hint_text. Multi-agent V2 means Codex can work with subagents instead of making one agent carry the whole task. The second signal, from 0.143.0-alpha.34, is structured timing logs for direct tool calls. A tool call is the moment an agent uses a tool, such as a command, file operation, or internal API action.

Source: OpenAI Codex changelog, GitHub release 0.143.0-alpha.35, npm registry for @openai/codex, and PR #30493.

What changed in the OpenAI Codex changelog and alpha releases

OpenAI's public Codex changelog still shows Codex CLI 0.142.5 for July 1. The GitHub releases after that are alpha releases with sparse release bodies, so the useful source text sits in the merged PRs. On July 3, 0.143.0-alpha.35 was published, and the npm registry showed latest: 0.142.5 and alpha: 0.143.0-alpha.35.

The most useful change in alpha.35 is PR #30493. Previously, multi-agent V2 derived its mode instructions from reasoning effort: Ultra could use proactive delegation, while other efforts required an explicit request. With features.multi_agent_v2.multi_agent_mode_hint_text, a deployment can set one delegation text that applies regardless of reasoning effort. If the field is absent, existing behavior remains. If the field is present, including as an empty string, Codex uses the custom mode.

Source: PR #30493 and GitHub release 0.143.0-alpha.35.

Why multi-agent policy matters for Swedish teams

This is not a shiny new button for every user. It is an alpha configuration for teams already running or evaluating Codex with multiple agents. Still, the direction is useful: when a coding agent can split work across subagents, the team needs a readable rule for when delegation is right, when it is noise, and what a human should review before the work continues. An approval gate is that human or policy checkpoint before a risky action.

For Hammer readers, the point is practical. You do not want agent work to become a black box where subagents start because the model happens to run at one reasoning level. You want a working rule people can read, debate, and change. For example: delegate only when parallel work shortens lead time or improves review quality, and always leave a short summary per subagent.

PR #30493 also gives a verified TOML example. This is a human configuration step, not a prompt the agent should guess:

[features.multi_agent_v2]
enabled = true
multi_agent_mode_hint_text = "Delegate to subagents when it will materially improve the result."

Source: PR #30493, Configuration examples.

Structured tool-call receipts in 0.143.0-alpha.34

The second signal is PR #30334, which landed in 0.143.0-alpha.34. It adds a structured codex.tool_call event for direct tool calls in app-server modes. The event can include conversation, turn, tool, call, trace, dispatch time, handler time, and total time. Code-mode calls are deliberately excluded so the measurement does not double-count nested runtime calls.

This matters once Codex does more than one-off terminal help. If an agent waits in a queue, waits on a tool, or runs an expensive command, the team should be able to see where the time went. That does not make the agent smarter. It makes the work easier to operate. The PR also gives a verified logging filter for app-server testing:

LOG_FORMAT=json \
RUST_LOG='warn,codex_core::tools::parallel=info' \
codex app-server

Source: PR #30334, Suggested logging filter and event example.

Short example: use the new Codex feature

Human step first: test the alpha channel in a separate workspace if you normally evaluate Codex pre-releases. Confirm the version and configuration through your usual package process. Do not put alpha configuration into production workflows without a clear rollback path.

Then paste a short agent instruction in the workspace where Codex is already allowed to read repository and configuration files:

Inspect this Codex workspace for multi-agent policy readiness. Do not edit files. Find any Codex multi-agent configuration, logging setup, and runbook notes. Return one short receipt with: current Codex channel or version, whether delegation policy is explicit or effort-derived, whether direct tool-call timing can be captured, and one human review step before wider rollout.

Good output should:

• separate stable 0.142.5 from the 0.143.0-alpha.35 alpha track
• show whether delegation is governed by a readable policy or only by reasoning effort
• mention where JSON logs, trace IDs, and tool-call timing can be reviewed
• end with one concrete human review point

What Hammer would test first

We would start with one focused workflow: an agent that reads issues, splits analysis into subagents when useful, and leaves a short run receipt before anyone merges a change. Put API keys in environment variables or a secret manager, use scoped permissions, redact sensitive content from shared logs, and keep an approval gate before the agent can write, push, or create a PR.

This fits naturally into Tool Forge: not more AI for its own sake, but a workspace where Codex rules, logs, and human review line up. The alpha changes are not a reason to chase every nightly build. They are a good reminder of what teams need when coding agents move from a chat tab into a workflow other people have to trust.