DEV Community: Aaron W

How Claude Code and Codex store sessions, and how to hand a task from one to the other

Aaron W — Fri, 23 Oct 2026 09:12:51 +0000

I pay for both Claude Pro and ChatGPT Plus and switch between Claude Code and Codex every day. Switching is easy. The handoff is the hard part: when Codex opens, it knows nothing about the project, how far you got, or which approaches already failed.

Here's how I made that handoff automatic, and what each side's sessions actually look like.

1. Claude Code sessions are local JSONL files

Every Claude Code session is a JSONL file under ~/.claude/projects/<escaped-project-path>/<session-id>.jsonl. One line per event: user messages, assistant replies, tool calls, tool results, todo updates.

So you can read a whole session without any API. The hard part is deciding how much to read:

Tool results can be huge (a full file read, a full test run). Paste them into another agent and you blow its context.
So you condense: keep messages verbatim, reduce each tool call to what was called, on what, and roughly what came back, then add the current todo list and git status.

2. Codex: use its own app-server

Codex keeps local session records too, but I don't parse them. I only use the app-server that ships with Codex: create a thread, send a message to it, read it back. That way a Codex update that changes the file format doesn't break anything, and writes go through the official path.

3. Two-way sync with cursors

My first version was a one-shot export: Claude writes HANDOFF.md, Codex reads it. But when you switch back, Claude has no idea what Codex did, so you export again.

What works now:

One Claude session is paired with one Codex thread.
Each side keeps a cursor: the last event already synced.
When you switch, only the condensed progress after the cursor is sent.
On the Claude side, a UserPromptSubmit hook prepends Codex's new progress to your next message. Each update is delivered once, usually a few thousand tokens.

The two sides end up working on one task instead of running two unrelated chats.

4. When to switch: watch the limits

Most of my switches happen because Claude's 5-hour window ran out, so there's also a heads-up when either side passes 90%.

I don't scrape usage myself. I read what tools you may already run write out: CodexBar, ccusage, abtop, claude-hud, ccstatusline and a few others. Whichever is installed gets used, with no setup.

5. The tool

I packaged all of this as ccx, an open-source macOS menu bar app. Click ⇄ to hand off. Everything runs locally, with no account and no server.

https://github.com/aaronwong1999/ccx

Even if you never use it, the approach is easy to copy: read Claude's JSONL, condense tool output, keep cursors, send only the delta. The point is to make the handoff cheap. If it isn't, you won't bother switching, and you'll be back to waiting out the limit.

I'm @aaron0x10 on X if you want to compare setups.

How to see your Claude Code and Codex usage limits before you hit them (6 open-source tools)

Aaron W — Thu, 22 Oct 2026 07:58:15 +0000

Hitting the Claude Code 5-hour limit mid-task hurts most when you didn't see it coming. These open-source tools show your Claude Code and Codex usage while you work, so you can plan a handoff instead of getting cut off.

Statusline tools (inside Claude Code)

These live in Claude Code's status line, right under your prompt.

claude-hud: a Claude Code plugin that shows context usage, active tools, running agents and todo progress. Install with /plugin install claude-hud. It can also write a usage snapshot to a file for other tools to read.
ccstatusline: a highly customizable statusline with powerline support and themes.
CCometixLine: a fast statusline written in Rust, installable via npm.
claude-code-usage-bar: one line with your 5-hour and 7-day rate-limit usage, reset countdowns, model and context window.

Standalone monitors (Claude Code and Codex)

CodexBar: a macOS menu bar app that shows usage for both Codex and Claude Code without logging in. brew install --cask codexbar.
abtop: like htop, but for AI coding agents. It shows every Claude Code and Codex session with tokens, context window and rate limits, and abtop --json prints a snapshot for scripts.

What to do when the bar turns red

Seeing the limit coming is half the fix. The other half is having somewhere to go. If you pay for both Claude and ChatGPT, the obvious move is to continue the task in Codex. The painful part is that Codex starts with no context.

That's why I built ccx. It links a Claude Code session with a Codex thread and syncs them both ways: messages, condensed tool calls, the plan and git status. It also reads the usage data from every tool above when you have one installed, so the menu bar warns you when either side passes 90% of its 5-hour window and offers to move the task to the other side in one click. No configuration, no keys, nothing extra installed.

FAQ

Do I need all of these? No. Pick one statusline you like, or CodexBar or abtop if you want both Claude and Codex in one place.

Does any of this bypass usage limits? No. These tools only show your usage. ccx only moves your task between your own two subscriptions.

Which one works with ccx? All six. ccx reads whichever is installed, without any setup.

If ccx saves you a re-explanation, a ⭐ on GitHub helps a lot. I'm @aaron0x10 on X.

Claude Code usage limit reached? 5 ways to keep working (ranked by what actually helped me)

Aaron W — Wed, 21 Oct 2026 21:15:16 +0000

You're mid-task, Claude Code says you've hit your limit, and the reset is hours away. I've been there most days since Opus 5.5 came out, so here's what I tried, ranked by how much it helped.

1. Run two plans and hand the task over (biggest win)

Claude Pro plus ChatGPT Plus costs $40 a month, less than Max 5x at $100, and the two limits are independent. When Claude caps out, Codex takes over. When Codex caps out, Claude has usually reset.

The catch is the handoff. Codex starts with zero context, so you re-explain the project, what's done, and what you already ruled out. I got tired of that and built ccx, an open-source macOS tool that syncs a Claude Code session and a Codex thread both ways: messages, condensed tool calls, the todo list, and git status. Click ⇄ in the menu bar and Codex picks up where Claude stopped; go back to Claude later and Codex's progress comes with you. It also warns you when either side passes 90% of its 5-hour window, so you can switch before you're cut off mid-step.

2. One task, one session

Every message re-sends the session's context. Long sessions get expensive fast. Finish a task, then /clear or start fresh. This alone stretched my 5-hour window noticeably.

3. Compact instead of dragging on

If you need the context, /compact it rather than continuing a bloated conversation.

4. Keep big files and logs out of context

Tell Claude in CLAUDE.md which folders to skip (build output, node_modules, logs). A single huge tool output can burn a surprising share of your window.

5. Use a cheaper model for simple work

Renaming, copy edits, running tests, reading an error: switch to Sonnet with /model. Save Opus for planning and hard bugs.

What doesn't help

Waiting it out. You lose hours of momentum.
Pay-per-token API as a fallback. It works, but a long agent session can cost more than a month of a second subscription.
Picking a long, idle session back up. After about an hour the prompt cache expires and your next message re-reads the whole conversation. Start a new session instead.

FAQ

Does running two subscriptions break any rules? No. You're using your own Claude and ChatGPT plans, each within its own limits.

Does ccx upload my code? No. Everything runs locally; the code is already on your disk. ccx only moves conversation context between the two desktop apps.

Windows or Linux? Not yet. ccx needs macOS 13+ and the Claude and/or Codex desktop app.

If the handoff pain sounds familiar, give ccx a try. A ⭐ helps a lot, and I answer every issue. I'm @aaron0x10 on X.

How I hand a Claude Code session to Codex (and back) without re-explaining anything

Aaron W — Wed, 21 Oct 2026 11:11:02 +0000

When Claude Code hits its 5-hour limit mid-task, you can wait for the reset, pay for API tokens, or move the task to another agent. I use both Claude Code and Codex, so the third option is the obvious one. The hard part isn't switching apps. It's the handoff: the other agent knows nothing about the task.

The problem with switching

I switch for two reasons:

One side runs out. Claude Code has a 5-hour window and a weekly cap, and so does Codex.
Cross-checking. When one model loops on a bug, the other often solves it in one pass.

Either way, the new side starts cold. You re-explain what the project is, where you were, which approaches you already ruled out, and what's broken now. Pasting the transcript doesn't work well either: tool calls and their output run to tens of thousands of words.

Then you switch back, and Claude doesn't know what Codex changed.

What I built: ccx

ccx links a Claude Code session with a Codex thread and keeps them in sync both ways, inside both desktop apps. It's open source (MIT) and runs entirely on your Mac.

Claude hits its limit.
Click ⇄ in the menu bar, pick the project and session.
Codex picks up the task with the full context.

When Codex runs out too, open the same Claude conversation and send anything ("continue"). Codex's progress comes in. Switch as many times as you like.

What gets carried over

Every user message and reply
Condensed tool calls and their output
The latest task list (Claude's todos or Codex's plan)
Whether the other side stopped mid-step
Pasted images, as the path of the app's own cached copy
git status

The code is already on your disk. All of this arrives as context for the model, not as new chat bubbles.

How it works

Claude side: reads the session JSONL files under ~/.claude/projects/.
Codex side: goes only through Codex's own app-server API (thread/list, thread/read, session import). It never parses Codex's internal files.
Pairing: a Claude session A and a Codex thread T form a pair in ~/.ccx/pairs.json, and each side keeps a cursor of how much the other has received.
Delivery: when you send a message in A, a UserPromptSubmit hook appends T's new progress to that message and moves the cursor. Nothing is delivered twice, and the hook never blocks a prompt. If something was condensed away, the model can page through it with a read_session tool.

Each update is usually a few thousand tokens. Clicking again with nothing new does nothing.

A heads-up before you run out

v0.0.32 adds a usage heads-up. When either side's 5-hour window passes 90%, and again when it's used up, the menu bar notifies you once and offers that side's newest session to continue in the other app.

Codex: read from its app-server's account/rateLimits/read. Built in.
Claude: Claude Code keeps no local signal before the limit, so ccx also reads CodexBar, Claude Code Usage Monitor or ccusage when one of them is installed, through their documented output only.

FAQ

Does it bypass usage limits? No. You use your own Claude and ChatGPT/Codex plans, each within its own limits. ccx only moves the task between them.

Is anything uploaded? No. Sync is local. ccx reaches GitHub only to install and check for updates.

Windows, Linux, standalone CLIs? Not yet. macOS 13+ with the Claude and/or Codex desktop app.

Install

Paste this into Claude Code or Codex and it installs itself:

Install ccx for me: run `curl -fsSL https://raw.githubusercontent.com/aaronwong1999/ccx/main/install.sh | sh` (it needs network access and writes to my home folder), then run `~/.local/bin/ccx doctor` and tell me the result.

Feedback is welcome in Issues or on X (@aaron0x10).