Codex Record & Replay: Show It Once, Let It Repeat Forever

There's a certain kind of task that's annoying to explain but easy to demonstrate. Filing an expense report. Downloading the same weekly report from a dashboard. Uploading a video with the right title, thumbnail, and subtitles. You know exactly how to do it — your hands just do it — but writing out every click as a prompt feels like more work than the task itself.

That's the gap OpenAI's new Record & Replay feature for Codex is built to close. Instead of describing a workflow in words, you perform it once while Codex watches, and it turns that demonstration into a reusable skill it can run on its own later. The feature shipped on June 18, 2026, in the Codex macOS app (version 26.616).

This guide walks through what Record & Replay actually is, how it works step by step, why it's different from the old screen-recording macros you might be picturing, and where it genuinely helps versus where it still falls short.

Read Now: OpenAI Codex CLI: The Complete Setup & Commands Guide

What is Codex Record & Replay?

Record & Replay is a way to teach Codex a task by showing it, not telling it. You start a recording, do the workflow yourself — navigating to a site, filling in fields, uploading files, clicking through screens — and when you stop, Codex studies what you did, figures out the pattern, and saves it as a skill.

The next time you need that task done, you invoke the skill with new inputs, and Codex runs the whole workflow for you. It can act across different tools and interfaces in one go: spreadsheets, web apps, browser tabs, and connected plugins, using whatever combination you demonstrated. It doesn't just memorize the mechanical clicks either — it picks up on your preferences and conventions, like which privacy setting you choose or how you name things.

In plain terms: you do the chore once, and Codex learns to do it for you after that.

How Record & Replay works, step by step

The flow starts with you doing the task, not with a prompt. Here's the sequence:

1. Open the Plugins panel in the Codex app.
2. Open the + menu and select "Record a skill."
3. Review the suggested prompt, add any helpful context about what you're about to do, and submit it.
4. Approve the recording permission. Codex asks to observe your actions and window content — you only grant this when you're ready to start.
5. Perform the workflow exactly as you normally would. Go to the site, fill the form, upload the file, set the options — the full task end to end.
6. Stop the recording. Codex inspects the captured sequence and drafts a skill file describing what you did.

From then on, that skill sits in your library, and you can trigger it again with fresh inputs whenever the same chore comes up. You control when recording starts and stops, so nothing is captured outside that window.

Why this isn't just a fancy macro recorder

If you've used RPA tools or screen-recording macros before, you might be thinking "haven't we had this for years?" The honest answer is: sort of, but the part that always broke is exactly the part Codex changed.

Traditional macro tools capture pixel coordinates — click at X=420, Y=310. The moment a button moves, a layout shifts, or a page loads a second slower, the macro breaks. That brittleness is why "record your clicks and replay them" never really graduated past simple, rigid use cases.

Record & Replay works differently. Instead of saving raw coordinates, Codex generates a natural-language SKILL.md file — a written description of the workflow that its reasoning model interprets each time it runs. Because the skill is described in language rather than fixed pixel positions, Codex can adapt to small changes in the interface instead of snapping the first time something moves.

There's a name for the idea behind this: programming by demonstration. Researchers have studied it since the mid-1980s, but it never reached everyday use because the hard step — turning one concrete demonstration into a reusable program that generalizes — was too fragile. Routing that generalization step through a language model is what makes this version actually hold up where older attempts didn't.

One more practical upside of the SKILL.md approach: the generated skill is inspectable and editable. It's a file you can open, read, tweak, or extend — not a black box. If Codex got a step slightly wrong or you want to refine the behaviour, you edit the skill instead of re-recording from scratch.

Read Now: OpenAI Codex Just Replaced My Junior Developer (Here's How)

Record & Replay is one of three ways to give Codex a skill

OpenAI is clear that recording isn't always the right tool. There are three ways to give Codex a skill, and they overlap less than you'd expect:

• Write a prompt. If the task is easy to describe in words, just prompt Codex and move on. Recording adds nothing here.
• Record & Replay. This earns its place when a task is easier to show than to describe — a repetitive workflow of your own, with stable steps and clear success criteria.
• Build a plugin. When you want to distribute a stable, documented capability across a whole team, bundle several skills together, or wire in MCP servers, you build a plugin instead.

Record & Replay is described as a fast way to create a skill from a demonstrated workflow — not the way to ship something durable to forty colleagues. Knowing which of the three you actually need saves a lot of frustration.

Where Record & Replay actually shines (and where it doesn't)

The official guidance is a useful tell: it works best when the steps are stable and the success criteria are clear. That splits real tasks into two buckets.

Good candidates — repetitive, well-bounded, run against interfaces that don't change much:

• Filing an expense report or submitting a time-off request
• Downloading a recurring report or data export on a schedule
• Publishing a video with consistent metadata, thumbnail, and subtitles
• Creating a correctly configured issue or ticket the same way every time
• A "morning brief" routine — open your analytics, grab the same charts, drop them into a doc

Weaker candidates — anything with variable layouts, branching error-handling, or judgment calls. These aren't yet suited to fully unsupervised execution, because the workflow changes shape depending on what it runs into, and a single demonstration can't capture all those branches reliably.

A simple gut check: if you could hand the task to a new hire by showing them once and they'd nail it every time, it's a strong fit. If you'd have to say "well, it depends…" a lot, hold off.

What you need to run it

Before you go looking for the button, check the requirements — there are a few real gates:

• macOS only. The feature lives in the Codex Mac app for now; there's no Windows or Linux version yet.
• Computer Use must be enabled in the Codex app settings. On a personal account you toggle it yourself; in enterprise deployments an admin enables it through a requirements configuration file.
• A paid ChatGPT account. The Codex app is free to download, but Record & Replay is available to ChatGPT Plus, Pro, Business, Enterprise, and Edu subscribers.
• Region limits. At launch it isn't available in the European Economic Area, the United Kingdom, or Switzerland.

It arrived alongside a couple of other version 26.616 additions worth knowing about: bulk actions for your Automations history, and the ability to hand off a thread between a local and a remote host so you can continue a task on a connected machine.

One important clarification: "record and replay" vs "session replay"

This trips people up, so it's worth one paragraph. The launched feature is about teaching Codex a skill by demonstrating a UI workflow — that's everything above. There's a separate, older meaning of "replay" floating around in developer circles: session replay, which is re-running a saved agent run to see what it did, reproduce a flaky result, or audit a decision after the fact. Codex sessions are stored as transcripts and there's real demand for replaying them that way, but that's a different thing. Only the workflow-recording feature shipped on June 18. If someone says "Codex record and replay," they almost always mean the skill-from-demonstration feature.

A few honest limitations

It's a genuinely useful feature, but it's early, and a couple of trade-offs are worth going in with your eyes open:

• The skill is locked to Codex. What you record is portable in concept but runs back through Codex in practice. That's a fair deal if you've already committed to the ecosystem and a real friction if you haven't.
• Mac and region gating rules out a lot of teams on day one.
• Stable workflows only. As above, anything that needs real error-handling or judgment isn't ready for hands-off use yet.

None of these are dealbreakers for the right task — they're just the difference between "automate this today" and "wait a release or two."

Frequently asked questions

Conclusion

Record & Replay quietly shifts the cheapest way to teach an agent from instruction to demonstration. For a long list of dull, repeatable desktop chores, that's a real change — you stop writing prompts and start just doing the task once.

Key takeaways:

• Demonstrate a workflow once; Codex saves it as a reusable skill and runs it later.
• It generates an editable SKILL.md, not brittle pixel-coordinate macros — so it adapts better and you can inspect what it learned.
• It's one of three ways to give Codex a skill: prompt for simple tasks, record for show-don't-tell workflows, build a plugin for team-wide distribution.
• Best for stable, well-bounded tasks with clear success criteria — not variable, judgment-heavy ones.
• macOS only, needs Computer Use enabled, requires a paid ChatGPT plan, and isn't available in the EEA, UK, or Switzerland at launch.

If a task in your week is easier to show than to explain, that's the one to record first.

Read Also: Codex CLI Official Description: Complete Command Guide