Codex can now share a thread as a read-only link. It shows someone how the work was reasoned — not the working thing it produced, and not a copy that keeps up with you. Here is exactly what the snapshot carries, the four boundaries the announcement doesn't spell out, and how to tell which of the two jobs you're actually doing.
You finished something in Codex and now someone else has to see it. A colleague reviewing a pull request, a lead who wants to know why the approach changed, a client waiting on the thing itself.
Codex will give you a link. Whether that link is the right one depends on which of those two people you are talking to — because the link carries the conversation, not the build.
OpenAI's own framing is the clearest one: shared threads let you show the process behind your build with a read-only link — the context and reasoning behind a pull request, a deep dive, or a project handoff.
That is a real and slightly unusual thing to be able to send. Most sharing features hand over an output. This one hands over the derivation: what you asked, what Codex proposed, where you pushed back, which approach lost and why. For a reviewer trying to decide whether to trust a diff, that is often more useful than the diff.
It is worth being precise about the boundary, though, because the word "share" does a lot of work here and the two jobs pull in opposite directions:
| A shared thread | A handed-over build | |
|---|---|---|
| What the reader gets | The conversation, read-only | Something that runs in their browser |
| Should it change after you send it? | No — a record that rewrites itself is a worse record | Usually yes — they should see your latest |
| What "done" looks like | They understand the reasoning | They can use or judge the thing |
| Who it's for | A reviewer, a teammate, your future self | A client, a stakeholder, a tester |
Neither column is better. They are answers to different questions, and the friction people report almost always comes from using one where they needed the other.
None of these are faults. Each is a defensible design decision that becomes visible only in a specific situation — which is exactly the kind of thing worth knowing before you send the link rather than after.
OpenAI is explicit that the snapshot does not update when the original thread changes. For its stated purpose that is correct: a handoff record that quietly rewrote itself would be worthless as a record.
The trouble is a reader cannot tell. If you shared a thread on Monday, kept iterating through Wednesday, and someone opens the link on Thursday, they will read a coherent, complete-looking conversation that stops at Monday and draws conclusions from it. Nothing on their screen flags that. If the work is still moving, say so in the message that carries the link, because the link will not say it for you.
Personal-account links can be opened by anyone with the link. Workspace-account links are limited to members of the originating workspace.
Same button, same visual result, materially different reach. The personal-account version behaves like a public URL that happens to be hard to guess: not restricted to the recipient, not tied to their identity, and as forwardable as any other link. That is fine when you meant to circulate something. It is worth a second's thought when you meant it for one person. We wrote about the same distinction showing up in what a Grok share link actually shares and in which Claude shares are public, and what unshare actually undoes — the specific behaviour differs per tool, but the question to ask is identical every time.
Codex redacts known secret patterns, and OpenAI still tells you to review the shared content because sensitive content may remain. That instruction is doing real work.
Pattern-based redaction is good at things that look like credentials — a token with a recognisable prefix, a long high-entropy string. It has no opinion about an internal hostname, a client's name in a code comment, a paragraph where you explained why the previous vendor was fired, or a database URL you pasted mid-sentence while debugging. Threads accumulate that kind of thing precisely because they are working conversations, and a working conversation is a lot longer than the answer it eventually produced.
The practical habit: skim the shared view itself, not your memory of the thread.
The changelog names the ChatGPT desktop app for macOS. If you are on Windows or Linux, or working from the web, thread sharing is not something you have misconfigured — it is not there for you today. Check OpenAI's changelog rather than a third-party page like this one for when that changes, since it is their feature and their schedule.
The question that sorts it: does the other person need to understand it, or use it?
They need to understand it — a reviewer, a teammate picking up your branch, a lead asking why. Share the thread. The reasoning is the deliverable, frozen is correct, and nothing else you could send captures the "here's what we tried and rejected" part.
They need to use it — a client, a stakeholder, someone who is going to click around and tell you what's wrong. The thread will not help them. They need the build, running, in a browser, and they should not have to learn anything to open it.
For that second case the honest answer depends on what the build needs, and the best option is often not a link host at all:
If the handoff is a whole Claude Code or Codex project rather than one page, where to put HTML an AI generated so someone else can open it compares the same options against the five things people actually ask for — assets that don't break, a stable URL, permissions, version history, and a reviewer who doesn't write code.
Codex thread sharing is a good feature aimed at a specific job: showing someone how you got there. It is read-only, it is frozen on purpose, its privacy depends on which account you're in, and its redaction is a first pass rather than a guarantee.
None of that makes it the wrong tool. It makes it a tool for the reviewer, not for the client. Once you can name which of those two you're sending to, the rest of the decision takes about five seconds.
Codex facts on this page checked against OpenAI's Codex changelog on 2 September 2026. OpenAI sets its own terms and ships often — check the changelog for what's current.
The prototype took an afternoon. Getting it in front of the person who has to say yes takes longer — because a repo-and-deploy is too much ceremony, an attachment opens as code, and a platform link drags your reader onto the platform. What the handoff actually needs.
From a Claude artifact to a vibe-coded app to a multi-file Codex bundle — how to share what an AI tool builds, as a private link, without a deploy pipeline.
A step-by-step: turn on Review for a private link, let anyone pin comments to the exact spot (no account), then export the thread as a prompt to paste into Claude or Codex.
miinideck turns a single HTML file into an unguessable link with optional password and expiry. Default-private, never indexed.