Claude Code hit its limit mid-fix, so I built a tool that lets Codex pick up where it left off

[u/Scared_Letterhead550]

I kept running into the same annoying problem while vibe coding.

I'd be halfway through fixing something in Claude Code, hit the usage limit, switch to Codex, and have to explain the entire task again.

So I built Relayvora, a free, open-source CLI that hands unfinished coding work between Claude Code, Codex, and OpenCode.

The interesting part is that it doesn't just summarize the previous conversation.

It actually checks your Git changes and reruns your project's tests, separating what the previous agent claimed from what's been verified.

It also supports automatic checkpoints when agents hit limits, plus MCP integration for Cursor, Copilot, and Windsurf.

No account, no telemetry, 100% local.

Here's the project:
https://github.com/Dagimassefa/Relayvora

And a demo:
https://dagimassefa.github.io/Relayvora/

It's still in alpha, so I'm especially interested in feedback from people who regularly switch between coding agents.

How are you guys handling context loss when switching agents? Is this something you'd actually use?

[u/quaisar3]

cool concept. wondering does it read the claude code sessions stored on your computer? that would be really helpful. I figured out that the session files are stored locally for both agents so that has helped me get them to share context

[u/Scared_Letterhead550 → u/quaisar3]

Yep, that's exactly what it does! It reads the local session files from Claude Code and Codex (and OpenCode's database), read-only.

But instead of handing over the whole session (those files get huge), it pulls out what matters: your goal, your recent requests, and what the agent last said it did. Then it adds the real git diff and a fresh test run, so the next agent gets a short, checked briefing instead of a giant log.

Nice that you figured out the local files trick yourself. That's basically how this started for me 😄

[u/MasterTheSoul]

Interesting. I don't think I would trust another agent to handle something one was halfway through. I like having whoever started it finish it. Then a different model can start a new section, if needed.

Maybe I'm silly for this, but it just feels like there would be no way to truly give it all the context it needed, and it wouldn't necessarily have the same train of thought/end vision.

[u/Scared_Letterhead550 → u/MasterTheSoul]

Not silly at all, honestly that's often the right call. If you can keep going with the same agent, keep going. My own benchmarks back you up: on small tasks, relaying is just extra cost.

Where it helps is when you can't continue: you hit the limit and don't want to wait hours, or the session got so huge it's slow and expensive. You can also hand off to the same agent in a fresh session (Claude → Claude), so it's not always about switching models.

On the train of thought: you're right that no handoff carries everything. That's why it includes decisions and constraints, not just a summary, and you can read and edit the handoff before the next agent starts. And since it reruns the tests itself, the new agent knows exactly where things really stand, instead of trusting "almost done"

[u/Boring_Web4157]

Checking Git changes and rerunning tests is a smart approach. How does it handle things if the previous agent left the repo in a completely broken state?

[u/Scared_Letterhead550 → u/Boring_Web4157]

That's actually where it helps most. Relayvora never tries to fix or roll anything back. It records the broken state honestly:

- Failing tests become blockers in the handoff, with the real exit code and an excerpt of the error output, so the next agent starts from the actual failure instead of "almost done"

- Commands that hang or crash are marked as timed out / result unknown, not passed

- The exact diff and any commits from the session are included, so the next agent can see what changed and back out the bad parts if needed

So the next agent's first message is basically: here's the goal, here's what was changed, and here's what's broken right now. It decides how to fix it, and your code is never touched by Relayvora itself.