Some workflows are difficult to describe because their important details are spatial or procedural. A person may know exactly which project to open, which fields to copy, where to verify a setting, and what a successful result looks like, yet writing those steps as a complete prompt takes longer than performing the task.
Codex Record & Replay turns that demonstration into a draft reusable skill. OpenAI introduced the feature for eligible users on macOS in June 2026. The user records a known workflow, Codex observes the relevant actions and window content, and then Codex produces instructions that can guide a future run with new inputs.
The important word is “draft.” Record & Replay can capture a pattern, but it does not prove that the pattern is safe, complete, or robust. A useful skill still needs review, parameterization, permission boundaries, and a clear test of success.
How a recording becomes a skill
OpenAI’s documented flow starts in the ChatGPT desktop app. A user opens Work or Codex, goes to Plugins, chooses the option to record a skill, reviews the suggested prompt, and gives any useful context. Codex requests permission before recording begins.
The user then performs the workflow on the Mac and stops the recording when finished. During that interval, Codex observes the actions and window content it needs to understand the process. Afterward, it drafts a skill that describes:
- when the workflow should be used;
- what inputs it requires;
- which steps to follow;
- how to verify the result.
The user can ask Codex to refine the draft. On a later run, the skill can be invoked in a new conversation with values that changed, such as a different file, issue title, report date, or destination.
That is more useful than replaying exact mouse coordinates. A reusable workflow needs semantic steps: open the correct project, choose the approved file, verify a field, and stop if a condition is not met. Interfaces move, data changes, and permissions differ. The skill should encode intent and checks rather than a brittle video macro.
What Record & Replay is good at
OpenAI recommends stable, repetitive workflows with clear success criteria. Examples include filing an expense, booking a parking space, creating a correctly configured issue, publishing a video, or downloading a recurring report. These jobs have a recognizable beginning, a limited set of variable inputs, and a result that can be inspected.
Good candidates usually have four properties:
- the human already knows the correct procedure;
- most steps remain the same between runs;
- changing values can be named as inputs;
- success or failure can be checked objectively.
A task that depends on subtle judgment may still benefit from a skill, but the skill should organize evidence and request a decision rather than invent the decision. “Collect these design variants and prepare a review grid” is safer than “choose the best brand direction and publish it.”
Record & Replay is also useful when conventional automation is unavailable or disproportionately expensive. A stable internal web form may not have an API. Computer Use and browser actions can bridge that gap while a team decides whether a more deterministic integration is justified.
Workflows that should not be recorded blindly
Rapidly changing interfaces, undefined exploratory work, and procedures full of exceptions are poor candidates. If the user changes the process while demonstrating it, Codex has no clean pattern to generalize. If success is “looks right to me,” a replay cannot know when it has arrived.
High-risk workflows need special caution. A recording that sends money, deletes records, publishes externally, changes production access, or handles regulated data should not become an unattended skill merely because the happy path is repeatable. The reusable artifact should stop before the consequential action and ask an authorized person to review it.
The feature also has product limits. Record & Replay requires Computer Use to be available and enabled. Initial availability excludes the European Economic Area, United Kingdom, and Switzerland. It is a macOS workflow, and eligibility depends on the user’s product and workspace settings.
Recording captures sensitive context
During recording, Codex can observe actions and window content needed to learn the workflow. OpenAI explicitly advises keeping the recording focused and avoiding secrets or sensitive data. That recommendation is not cosmetic: a normal work session can expose passwords, API keys, customer names, private messages, temporary URLs, or unrelated browser tabs.
Before recording:
- close unrelated applications and tabs;
- prepare sanitized example data;
- sign in before recording rather than capturing credentials;
- use a test environment where possible;
- disable notifications that could reveal private content;
- identify the exact start and stop points.
After recording, inspect the skill for copied identifiers and assumptions. A one-time signed URL should not become a permanent instruction. A specific customer folder should be an input or an allowlisted location. A successful click should become a verifiable state, not an assertion that the click always works.
ChatGPT data controls apply to content processed through Codex, including Computer Use screenshots. Business and personal plans can have different default training settings, so organizations should verify the applicable policy rather than assuming a local-looking workflow never leaves the product boundary.
Turn the demonstration into an operational procedure
A reliable skill separates constants, variables, and decisions. Constants include company policy and the intended order of steps. Variables include filenames, dates, project IDs, and approved destinations. Decisions are points where evidence must be presented to a person or a more specialized validator.
Review a generated skill with questions such as:
- Are the inputs named and validated before use?
- Does the workflow choose from an allowlist rather than the nearest visual match?
- Which steps modify external state?
- Does it ask before uploads, purchases, publication, or deletion?
- How does it detect an expired session or changed interface?
- What evidence proves completion?
- Can the workflow safely resume after failure?
- Does it avoid repeating a billable action?
Run the skill with a harmless alternate input before adopting it. Then test one expected failure: missing file, invalid format, unavailable service, or permission denial. A workflow that succeeds only on the recording’s exact example is a demonstration artifact, not reusable automation.
Skills can combine several tool surfaces
OpenAI says a generated skill can later guide Codex using Computer Use, browser actions, connected plugins, or a combination of available tools. That makes skills an orchestration layer, not a new universal connector.
If the demonstrated workflow uses a plugin or remote MCP service, that service must still be installed or configured with appropriate authentication and permissions. Recording a sequence does not package third-party credentials, grant access, or turn an external service into a native Codex capability.
This separation is healthy. The skill explains policy and procedure; the tool connection supplies bounded capability; the user or administrator controls authorization. Each layer can be reviewed and changed independently.
A repeatable media-finishing example
Consider a team that repeatedly prepares approved clips for social publishing. The procedure may include choosing a source MP4, applying a standard logo, removing an unwanted subtitle band when authorized, merging an outro, checking duration, and saving the output under a naming convention. This is visually easy to demonstrate and tedious to describe from scratch every time.
Medux provides external media operations that Codex can access through a separately configured MCP connection. Its logo watermark tutorial, subtitle-removal tutorial, and video merge tutorial show real upload, task creation, polling, download, and verification patterns. They do not imply that Medux is bundled with Record & Replay.
A useful recorded skill would capture the policy around those tools:
- ask for the campaign identifier and approved source directory;
- inspect file types, dimensions, duration, and logo choice locally;
- show the selected inputs and request approval before external upload;
- obtain fresh upload URLs rather than retaining recorded ones;
- create each billable task once with a stored task ID;
- poll at a bounded interval and distinguish failure from delay;
- download to a versioned filename and verify the media properties;
- prepare, but do not perform, the publication step without approval.
The demonstration should use disposable sample assets and never expose API credentials. In the generated skill, filenames and placement settings become parameters. Signed URLs and task IDs remain run-specific state. Visual quality and rights approval remain human responsibilities.
Record & Replay lowers the cost of expressing a workflow, which is valuable. Its long-term value depends on what happens after recording: remove secrets, make inputs explicit, add failure paths, preserve approval gates, and test the skill on something other than the example it watched.