OpenAI just made Codex more useful in the least glamorous and most operationally important way possible.

Codex can now keep using your Mac after the screen locks through what OpenAI calls Locked computer use. On paper, that sounds like a niche convenience feature. In practice, it matters because a lot of useful software work still lives inside graphical interfaces, app settings, browser flows, and GUI-only bug reproduction paths that do not fit neatly into terminal commands or tidy APIs.

The official Codex documentation says the feature works only after you enable Computer Use, install an Apple authorization plug-in, and grant both Screen Recording and Accessibility permissions. When a trusted active turn needs access after the Mac locks, Codex can temporarily unlock the machine while preserving the lock-screen protections, covering every display, and relocking if it detects local keyboard or pointer input. OpenAI also says the feature is unavailable at launch in the EEA, UK, and Switzerland, and that it cannot automate Terminal apps, Codex itself, administrator authentication, or security/privacy approval prompts. That is a pretty tight fence, and that is exactly why this launch is more interesting than a generic “remote control your Mac” headline. OpenAI Codex docs

This matters because too much real work still happens in the GUI

If you build software for a living, you already know the annoying truth: not every important workflow is scriptable.

Sometimes the task is buried inside a browser session. Sometimes it is a desktop app setting. Sometimes the bug only appears when an actual window redraws, a specific menu opens, or a click path crosses multiple apps. OpenAI’s own examples center on desktop-app testing, browser tasks, GUI-only bug reproduction, and settings changes that are hard to verify through files or command output alone. MacRumors highlighted the same point, noting that Codex can now be sent tasks from your phone while the Mac is locked, which makes it more practical for GUI-only flows and app-level approvals instead of just shell-heavy coding loops. MacRumors

That is the real product story. Locked computer use is not about showing off that an AI can wake a screen. It is about reducing the amount of dead time between “the agent can continue” and “the human has to sit back down at the machine.”

OpenAI is quietly killing the dumb workaround era

Macworld framed this feature as a cleaner alternative to the awkward tricks people were already using to keep AI agents alive, like caffeinate sessions or dummy display dongles. That framing is right.

The old workaround logic was simple: if the Mac sleeps or locks too hard, the agent stops working, so people start poking holes in normal device behavior just to keep long tasks running. That is ugly from both a security and ergonomics perspective. OpenAI’s approach is narrower. Instead of keeping the whole machine casually available, it creates a short-lived authorization window for an active trusted Codex turn, covers every display while the desktop is temporarily unlocked, and stops the automatic path when local input is detected. Macworld also notes that this does not help with clamshell-mode sleep, which matters because it shows OpenAI is not pretending to have solved every Mac power-state edge case. Macworld

That design choice matters. It shifts the workflow from “keep my machine artificially awake” to “allow a tightly scoped automation window under explicit platform rules.” For serious teams, that is a much healthier model.

The safeguards are the whole point, not a footnote

A sloppier product would have marketed this as seamless remote unlock. OpenAI did not. The docs repeatedly emphasize that locked use is intentionally narrow and not a general-purpose remote-unlock path for your Mac.

That narrowness shows up everywhere:

• Computer Use has to be enabled first.
• An Apple authorization plug-in has to be installed.
• Screen Recording and Accessibility permissions have to be granted.
• Codex still needs per-app approvals, with optional “Always allow” choices.
• Automatic unlock works only for active trusted computer-use turns.
• Every display gets covered during temporary unlock.
• Local keyboard or mouse input forces a relock and pauses automatic unlock until you manually unlock again.
• Terminal apps, Codex itself, admin prompts, and security/privacy prompts stay off-limits.

That is not just defensive product copy. It is the core of why the feature is usable without being obviously reckless. The practical lesson for builders is straightforward: the future of agentic desktop automation will belong to products that can prove they operate inside narrow, reviewable boundaries rather than pretending autonomy should float above operating-system controls.

What builders should take from this right now

If your team is evaluating agent workflows, do not reduce this announcement to a novelty Mac feature.

A few practical takeaways:

• Revisit any GUI-bound task you wrote off as “not agent-friendly.”
• Separate tasks that genuinely need Computer Use from tasks that should stay in structured integrations or the shell.
• Keep app approvals tight; “Always allow” should be rare and intentional.
• Treat locked-screen automation as an operational convenience, not a blank check for sensitive account or credential workflows.
• Measure whether this reduces supervision lag on long-running tasks started from the phone or away from the desk.

The broader market implication is that the best coding agent is increasingly the one that can keep useful work moving through real-world interruptions without asking users to weaken the machine around it.

My take

Locked computer use is one of those features that looks small in a screenshot and large in practice.

OpenAI did not solve autonomy by giving Codex more benchmark sparkle. It solved a workflow break. If the task depends on desktop apps, browser state, or GUI-only verification, the agent can now keep going after the Mac locks without turning the computer into a permanently half-awake science project.

That is a real product improvement. And it is a hint that the next wave of agent competition will be won less by flashier demos and more by who handles trust, supervision, and operating-system reality best.

Sources: OpenAI Codex Computer Use docs, MacRumors, Macworld