FIELD REPORT 007 // JULY 24, 2026

The orb
blinked once.

That single second proved Codex realtime voice was already on the machine. The real problem wasn’t the mic, the model, or the plan. It was one remote boolean. For a physically disabled developer, finding that boundary meant removing a burdensome button press from the core coding loop.

Follow the evidence ↓Follow the guide

SPECIMEN A~1.0 SEC

X 0.500Y 0.500

↳ The avatar overlay rendered before the eligibility check canceled the session.

THE RECEIPTSTART 00:58:44.874ZDURATION 02:11.472STOP 01:00:56.346ZVERIFIED

01 / THE CLUE

Most bugs announce themselves with an error. This one appeared as a perfectly rendered sphere—and erased itself one second later.

The missing button suggested the feature had never arrived. The flash changed the diagnosis: the shortcut worked, the overlay existed, and the renderer had begun its launch sequence. Something downstream was saying no.

02 / WHY IT MATTERED

Accessibility is not a feature category. It changes the cost of every interaction.

“For me, voice-first coding removes a physical action from every exchange—not just once, but across an entire workday.”

Repeated effort

A small button press becomes material when it sits inside a high-frequency coding loop.

Continuity

Voice preserves focus by keeping intent, feedback, and iteration in one uninterrupted channel.

Independence

Keyboard-accessible voice reduces reliance on precise pointer movement and repetitive physical input.

03 / TRACE

Six moves from “missing” to speaking.

1
00:00
Enable the documented-looking flag
The config accepted the realtime conversation feature. Nothing appeared in the interface.
2
00:18
Add the hidden global shortcut
The shortcut reached code the missing button could not. The orb appeared for roughly one second—then vanished.
3
00:41
Treat the flash as evidence
A rendered overlay meant assets, window creation, and the invocation path existed. The failure was happening after launch.
4
01:26
Read the gate equation
The renderer required a remote experiment, an active account, and no session conflict. Only the remote experiment was false.
5
02:03
Override memory—not the app
Electron’s local inspector installed a temporary Statsig override in both renderers, then immediately closed.
6
02:11
Hear the proof
A real realtime session started, ran for more than two minutes, and stopped cleanly.

04 / EVIDENCE MATRIX

Five checks. One red light.

The account tier mattered—but it was not the final authority. A separate remote experiment still controlled whether the renderer considered voice eligible.

01TRUE

Local flag

realtime_conversation was enabled in the Codex config.

02ALLOWED

Microphone

macOS had already granted microphone access to the app.

03PRESENT

Voice engine

The packaged app contained session, voice, WebRTC, and overlay code.

04PASSED

Backend probe

A direct V1 probe created a live session with the bundled model.

05FALSE

Remote gate

The account was Pro. The staged rollout gate still evaluated false.

RENDERER ELIGIBILITYSIMPLIFIED

active accountANDno conflictANDremote gate=FALSE

A Pro subscription can make an account eligible while a staged rollout still evaluates false. Those are different decisions made by different layers.

05 / PRODUCT CONTEXT

Why a feature can be real—and still not reach everyone.

In a staged rollout, a company enables a feature for progressively larger groups instead of releasing it to everyone at once.

01Small cohort

02Expanded group

03Broad release

Validate reliabilityManage service capacityCatch unexpected issuesAddress regional or policy needsPrepare user support

In this case, the observed gate state was consistent with a staged rollout. The specific reason is not public, so this report does not infer one—and it does not suggest bypassing rollout controls.

06 / ENGINEERING JUDGMENT

Change the minimum state. Preserve a clean way back.

Patching the packaged application would have created a brittle new problem: modified bundles, broken signatures, and update drift. The working route was deliberately narrow and local: validate the existing feature path, alter no credentials, avoid a modified app bundle, and keep rollback explicit.

01ObserveCapture the one-second UI state

→

02IsolateTest each dependency separately

→

03ValidateConfirm the local feature path

→

04VerifyMeasure a complete voice session

→

05RollbackKeep the app bundle untouched

07 / STEP-BY-STEP GUIDE

Reproduce the unofficial workaround on macOS.

This is the exact one-session route that worked in the tested build. Read each step before running it. The helper is plain text, changes only live app memory, and clears when the app quits.

TESTED BASELINEmacOSChatGPT.app 26.721.30844Installed in /ApplicationsCodex account signed in

01
CHECK BEFORE CHANGING ANYTHING
Confirm the app version.
Open Terminal, paste this command, and press Return. Continue only if it prints 26.721.30844. A later build may use different internal code or a different gate.
```
/usr/libexec/PlistBuddy \
  -c 'Print :CFBundleShortVersionString' \
  /Applications/ChatGPT.app/Contents/Info.plist
```

MAKE THE EXIT EASY

Back up your Codex settings.

These copies let you return to your exact starting point. The second command is skipped automatically if you have never made a custom keybindings file.

mkdir -p "$HOME/.codex"
cp "$HOME/.codex/config.toml" "$HOME/.codex/config.toml.before-voice"
[ -f "$HOME/.codex/keybindings.json" ] && \
  cp "$HOME/.codex/keybindings.json" "$HOME/.codex/keybindings.json.before-voice"

03
ENABLE THE LOCAL HALF
Turn on the Codex feature flag.
Open the config in TextEdit with the command below. If a[features] section already exists, add only the second line inside it. Otherwise add both lines at the bottom, then save.
```
open -a TextEdit "$HOME/.codex/config.toml"
```
~/.codex/config.toml
```
[features]
realtime_conversation = true
```
04
CREATE A WAY TO CALL IT
Add the hidden voice shortcut.
Open the keybindings file. If it is new or empty, paste the complete JSON below. If it already contains shortcuts, add the object between its square brackets, separated by a comma.
```
touch "$HOME/.codex/keybindings.json" && \
  open -a TextEdit "$HOME/.codex/keybindings.json"
```
~/.codex/keybindings.json
```
[
  {
    "command": "realtimeVoice",
    "key": "Ctrl+Alt+Command+V"
  }
]
```
05
REVIEW THE ONE-SHOT HELPER
Download the helper and read it.
Save the file in Downloads. It asks the running Electron app to open its Node inspector on localhost, changes the one voice gate in memory, installs the same change in any voice window created later, and closes the inspector.
Download helper ↓Read source ↗
SHA-256add9e1f02b0aeecf1f5d8f288839dccc3358f3ba936cd27d8b7e468e87b79d96
06
LOAD THE CONFIG, THEN THE GATE
Restart the app and run the helper once.
Quit ChatGPT completely, reopen it, and wait ten seconds for the main window to finish loading. Then paste this command in Terminal. It uses the app's bundled Node runtime; nothing else needs to be installed.
```
"/Applications/ChatGPT.app/Contents/Resources/cua_node/bin/node" \
  "$HOME/Downloads/codex-voice-gate-once.mjs"
```
Success looks like: Voice gate enabled in memory for the current app session.
07
START REALTIME VOICE
Press the shortcut.
⌃ Control+⌥ Option+⌘ Command+V
The voice sphere should remain visible instead of disappearing after one second. The first session may also trigger the macOS microphone permission prompt; choose Allow.
08
VERIFY THE SAFE END STATE
Confirm the inspector closed.
Run this after the helper finishes. No output is the expected result—it means nothing is listening on the inspector port.
```
lsof -nP -iTCP:9229 -sTCP:LISTEN
```

UNDO IT COMPLETELY

Quit the app and restore your backups.

Quitting clears the in-memory gate immediately. These commands restore the two settings files and move the downloaded helper to Trash.

cp "$HOME/.codex/config.toml.before-voice" "$HOME/.codex/config.toml"
[ -f "$HOME/.codex/keybindings.json.before-voice" ] && \
  cp "$HOME/.codex/keybindings.json.before-voice" "$HOME/.codex/keybindings.json"
mv "$HOME/Downloads/codex-voice-gate-once.mjs" "$HOME/.Trash/"

08 / PROOF OF VOICE

Not a button. A session.

The final test produced real start and stop events with a clean two-minute realtime session between them.

realtime-session.log

2026-07-24T00:58:44.874Z  thread/realtime/start
····················   audio streaming
2026-07-24T01:00:56.346Z  thread/realtime/stop

✓ SESSION COMPLETE // 00:02:11.472

09 / PRODUCT FEEDBACK

Turn an invisible rollout state into a legible experience.

The engineering diagnosis points to a product opportunity: make availability understandable, preserve keyboard access, and treat accessibility need as first-class rollout context.

Explain availability

Distinguish plan eligibility from staged rollout status instead of presenting both as a missing control.

Keep the shortcut discoverable

Voice should remain keyboard-addressable even when its visual placement or onboarding is still evolving.

Create an accessibility path

Give eligible users a supported way to request access when the interaction meaningfully reduces a physical barrier.

Fail with a reason

Replace a one-second disappearance with a state message that says whether the blocker is permission, conflict, or rollout.

WHAT THE WORK REQUIRED

Hypothesis-driven debuggingElectron client analysisFeature-gate reasoningmacOS process lifecycleRealtime session validationAccessibility-led product judgment

READ BEFORE REPEATING

This is an unsupported workaround.

It does not turn an experimental rollout into an official setting. The local route was version-specific and is documented here as engineering evidence, not a recommendation to reproduce it. Remote gates exist for operational reasons. The responsible path is product feedback, disclosure, and a supported accessibility route.

The orbblinked once.

Accessibility is not a feature category. It changes the cost of every interaction.

Repeated effort

Continuity

Independence

Six moves from “missing” to speaking.

Enable the documented-looking flag

Add the hidden global shortcut

Treat the flash as evidence

Read the gate equation

Override memory—not the app

Hear the proof