Someone published a small tool called codex-switch that solves a very specific, very annoying problem: your ChatGPT quota runs out, you flip Codex over to a third-party API like DeepSeek or Kimi to keep working, and then your old conversations refuse to resume. The cross-provider `resume` gets rejected by the API, and you lose the thread you were in the middle of.
The fix in that tool is a bash script that does two things. First, it rewrites the model name recorded in each old session's metadata, because Codex's pre-sampling compact step pins the model name from that metadata rather than your current config, and a mismatch throws `invalid_request_error`. Second, when you switch back to the official API, it recursively strips the `reasoning` items that DeepSeek's direct `/responses` calls leave behind — those carry a content array and a locally Fernet-encrypted `encrypted_content` that the official API rejects with `array_above_max_length` or `invalid_encrypted_content`. Before any rewrite, it drops an automatic backup. All of that is real, tested behavior from the author on Codex 0.153.4 and macOS.
It's a genuinely useful hack. It's also fragile in the way local scripts usually are: the backups pile up as loose files, there's no easy way to see what actually changed before you re-run resume, and the whole thing lives on one machine tied to one shell and one OS. That gap between "clever script that works on my laptop" and "tool I trust and can point other people at" is exactly where a hosted rebuild earns its keep.
What the shared signal actually is
Look across what people are building right now and a pattern shows up. There's a desktop cockpit for running multiple coding agents locally, keeping their accounts and CLIs on the machine. There's a multi-agent workbench that wires Claude, Codex, and OpenCode into a shared workspace. There's this Codex switcher. The common thread isn't the specific tool — it's that the interesting work has moved to the seams *between* agents and providers: session state, provider quirks, and the plumbing that keeps a conversation valid when you move it somewhere new.
That plumbing is stateful and error-prone, and it's the part that benefits most from being a service instead of a script. You want a record of every transformation, a way to inspect a change before it hits your real session, and something that isn't welded to one shell.
The rebuild, concretely
The idea is to keep the exact same rewrite and strip rules, but move them behind a hosted endpoint where you can run Python online instead of babysitting a bash script. The flow stays simple:
You upload a session file to a Python endpoint. The service parses it, applies the two known transformations — rewrite the pinned model name for a cross-provider resume, recursively strip the incompatible `reasoning` fields when going back to official — and returns the repaired file. Nothing exotic; it's the same logic the bash script runs, just in Python behind an API you call.
The difference is what happens around the transformation. Before touching anything, the service writes the untouched original into a SQLite table: a row per repair with a timestamp, the source provider, the target provider, and the raw pre-change blob. That's your audit log, and it's queryable. When something goes sideways three sessions later, you can pull up exactly what the file looked like before the rewrite and diff the two. Having a real SQLite editor available means you can go poke at those backup rows directly when you need to, instead of hunting for a `.bak` file you hope you didn't overwrite.
On top of that, a small HTML page. You hosted it, so it's just there in a browser — pick a session, see the before/after diff side by side, confirm the model-name rewrite looks right and the stripped reasoning items are the ones you expected, *then* commit and re-run resume. That inspect-before-you-apply step is the thing the original script can't really give you, and it's cheap to add once the tool is a web app hosting target rather than a terminal command. The diff view is where you catch the case where a rewrite would clobber something you actually wanted to keep.
Where the boundary sits, and don't pretend otherwise
This is the part worth being honest about, because it's easy to oversell. A hosted service does not touch your local Codex install. It doesn't hold your OpenAI, DeepSeek, or Kimi credentials, and it doesn't run the resume for you. It ingests a file, transforms it, keeps the backup, shows you the diff, and hands the file back. You still copy the repaired session into place locally and run `codex resume` yourself against your own accounts and CLI.
Anything provider-specific beyond parsing the file stays out of scope too. The Kimi path in the original tool needs a local codeproxy route for tool_search compatibility — that's local network plumbing on your machine, and it's not something a hosted transform endpoint can or should reach into. Same with the account-quota question that started this whole thing: the platform isn't a way to route your ChatGPT web quota into Codex or launder subscription access. It's a file-repair service with memory, nothing more.
Whether the repaired sessions actually resume cleanly on your setup is unverified here — that depends on your exact Codex version and provider behavior, and the only thing the original author confirmed was one specific version on macOS. Treat the diff view as your safety check, not a guarantee.
Why bother turning a working script into this
Because the script already proved the logic is right; the missing pieces are durability and trust. A per-repair backup in SQLite means you can undo. A diff page means you look before you leap. A hosted endpoint means the tool isn't trapped on the machine where the author happened to write it, and you can share it with a teammate who's hitting the same cross-provider resume wall without asking them to clone a repo and trust a bash script.
That's the whole move: take the fragile-but-correct local hack, keep its exact rules, and wrap it in state and inspection. Small surface, clear boundary, and the annoying part — losing a conversation mid-task because you swapped providers — stops being a coin flip.