The highest-signal Codex news right now is not a model launch. It is a runtime release.

On March 11, 2026, OpenAI shipped Codex 0.114.0 in the openai/codex release stream. As of March 13, 2026, the repository is already moving through a fast 0.115.0-alpha train, but the latest stable release is still 0.114.0. That is the version engineering teams should study first.

Why? Because this release continues a pattern that advanced Codex users should pay attention to: OpenAI is turning Codex from a powerful coding surface into a more governable runtime.

The headline features are not flashy:

  • experimental code mode
  • an experimental hooks engine
  • GET /readyz and GET /healthz for WebSocket app-server deployments
  • a config switch to disable bundled system skills
  • better handoff continuity through realtime transcript context

Individually, none of these sound like a breakthrough. Together, they change how serious teams should think about operating Codex.

What changed

The March 11 release notes for 0.114.0 call out six changes that matter most.

1) Codex now has an experimental code mode

OpenAI describes this as an experimental mode for more isolated coding workflows.

That wording matters. Codex releases over the last two weeks have already pushed harder on permissions, approval flows, and policy structure. In 0.113.0 on March 10, 2026, OpenAI added the built-in request_permissions tool and more precise permission-profile language. 0.114.0 extends that direction by adding a more explicit isolation lane for coding work itself.

Inference from the release notes: code mode is not just UI polish. It is a signal that OpenAI wants teams to separate general conversational steering from higher-trust implementation execution.

If that interpretation holds, the long-term implication is important: Codex is moving toward clearer runtime lanes for different risk classes of work.

2) Hooks moved from wish-list item to experimental runtime primitive

The release adds an experimental hooks engine with SessionStart and Stop events.

This is one of the most important changes in the release, even though it will get less public attention than code mode.

Hooks are how agent runtimes become operational systems instead of one-off tools. Once lifecycle events exist, teams can standardize:

  • environment bootstrap
  • audit logging
  • setup and teardown checks
  • custom telemetry
  • policy enforcement around session boundaries

In other words, hooks are not a convenience feature. They are a control surface.

3) WebSocket app-server deployments are now easier to run like real infrastructure

OpenAI added /readyz and /healthz endpoints on the same listener for WebSocket app-server deployments.

This is exactly the kind of change that separates demo-grade tooling from deployable systems. Health endpoints let teams integrate Codex app-server cleanly with process supervisors, container platforms, load balancers, and orchestration environments.

If you are running Codex app-server behind infrastructure that expects explicit liveness and readiness behavior, this release removes needless glue code.

4) Teams can now disable bundled system skills entirely

This is the most under-discussed change in 0.114.0.

Codex skills are useful, but default bundled behavior is also a governance question. When OpenAI adds a config switch to disable bundled system skills entirely, the company is acknowledging a real enterprise need: some teams want tighter control over exactly what instructions and capabilities are active by default.

That matters for three reasons:

  1. Reproducibility: fewer hidden defaults means fewer unexplained behavioral differences.
  2. Governance: organizations can enforce a narrower baseline and reintroduce only the skills they explicitly want.
  3. Legibility: agent behavior becomes easier to reason about when fewer built-in layers are implicitly active.

For regulated teams, this may be the most practically important feature in the entire release.

5) Handoffs now carry realtime transcript context

The release notes say handoffs now carry realtime transcript context, improving continuity when work is transferred between turns.

This is another subtle but meaningful step. Multi-agent systems only work well when context transfer is reliable enough that the receiving lane does not have to reconstruct intent from partial state. Better handoff continuity reduces a class of failures that experienced teams already know well:

  • missing rationale
  • repeated work after branch or resume
  • degraded task quality after delegation
  • brittle recovery when a turn is interrupted and resumed later

This is not just a UX improvement. It improves the economics of branching work.

6) Approval and permission behavior got more trustworthy

The bug-fix section matters here too.

OpenAI says granted permissions now persist across turns more reliably, work better with reject-style configs, and are honored by apply_patch. The release also fixes legacy workspace-write handling so newer permission profiles degrade more safely on older builds.

That is important because policy features only matter if teams trust them under interruption, resume, version skew, and mixed-config environments. This release improves that trust story.

Why it matters

The big pattern across 0.113.0 and 0.114.0 is straightforward:

Codex is getting better at being run as infrastructure, not just used as an interface.

That shift shows up in four layers:

  1. Isolation through code mode.
  2. Lifecycle control through hooks.
  3. Operational deployability through health endpoints.
  4. Behavioral governance through skill disablement and stronger permission handling.

Most teams still talk about coding agents as if the key question is model quality. Model quality matters, but once an agent is editing code, asking for permissions, running tools, and being embedded into workflows, the higher-order problem is runtime design.

This release is meaningful because it improves runtime design.

What teams should do now

If your team already uses Codex seriously, the right response is not “upgrade everywhere immediately.” It is to test the new control surfaces deliberately.

1) Pilot code mode on bounded implementation tasks

Do not roll experimental isolation paths into every workflow at once. Start with tasks where tighter boundaries are desirable:

  • focused code edits
  • constrained bug fixes
  • implementation branches with clear acceptance criteria

Measure whether it reduces review noise, permission churn, or accidental tool sprawl.

2) Treat hooks as an operations feature, not a customization toy

If you adopt hooks, use them for boring but high-value work first:

  • session bootstrap
  • environment validation
  • lightweight audit emission
  • stop-time cleanup

That will give you more value than trying to make them clever.

3) Add health checks anywhere app-server is part of your runtime

If you expose WebSocket app-server in containers, remote hosts, or managed environments, wire readyz and healthz into your standard liveness model now. This is low drama and high leverage.

4) Decide whether bundled system skills belong in your default posture

This should be an explicit platform decision, not an accident.

If your environment needs strict reproducibility, narrow permissions, or heavily standardized agent behavior, test with bundled system skills disabled and reintroduce only what you can justify.

Bottom line

The March 11, 2026 Codex release is not exciting in the way a new flagship model is exciting. It is better than that.

Codex 0.114.0 is a runtime-hardening release. It adds better isolation, better lifecycle control, better deployability, and better governance. For teams shipping agentic development systems, those changes are often worth more than one more benchmark headline.

Sources