One Command to Bridge Claude Code and Codex

On Seamlessly Bridging Claude Code and Codex

👦🏻 Author: GaKi

🥷 Editor: Koji

🧑‍🎨 Layout: NCon

Over the past year, Agent Memory has evolved from a mostly academic concept into a standalone track. Mem0 has hit 48,000 stars on GitHub and raised $24 million in funding. Letta, which builds OS-style memory layering, completed an A round of the same size.

Trailing behind are a host of players: Zep, LangMem, Cognee, and others.

In just one year, "how to give Agents long-term Memory" has become a question no Agent developer can avoid.

Amid this Memory Infra competition, a new domestic team has emerged.

In the AML (Agent Memory Leaderboard) benchmark launched at the end of July by a coalition of Tsinghua, Peking University, and other research institutions, a startup less than six months old took first place in the commercial product category — MemoraX. We covered its technical approach in detail in our article on Agent Memory at a crossroads: technical directions, evaluation methods, and the inaugural AML leaderboard.

Slightly different from pure general-purpose Memory frameworks, the team's recent release, MemoraX Code, embeds long-term Memory deeply into the Coding Agent workflow — preserving "key Memory" across session closures, context compression, and multi-Agent collaboration.

🚥

MemoraX Code's approach delivers clear value for local Vibe Coding projects.

For instance, we typically start with Codex paired with GPT 5.6 Terra, a relatively economical model, to rapidly scaffold the skeleton, then hand off to Claude Fable 5 for review and planning. But switching Agents breaks context sharing; having an Agent read source code directly burns tokens and risks losing critical information.

To test whether MemoraX Code alleviates this pain point, we ran it through a real development scenario:

Using MemoraX Code alongside Codex and Claude Code, we completed a full iteration of a previously built "real-time voice chat → social platform post" app. Through this process, we could grasp MemoraX Code's practical value.

A "Lightweight" Memory Skill

For this test, we used an "AI voice interview and content generation" tool that other team members had previously Vibe Coded and used regularly.

Its core logic is straightforward:

Hold a shortcut key to speak, transcribe in real time via local Whisper or the Doubao speech API; then DeepSeek asks follow-up questions sentence by sentence, simulating a voice interview; finally, the entire conversation is distilled into draft posts suited for Weibo, Moments, or Xiaohongshu.

But the project was initially rough around the edges, so this was a good opportunity to use MemoraX Code — a tool that provides a memory layer for Agents — and see what value it could bring to improving the overall development workflow.

Installing MemoraX Code is simple, requiring just this single command:

npm install -g @memorax/memorax-code --foreground-scripts — paste it into Claude Code or Codex, and it installs automatically.

Once installed, the daily invocation method is Skill-based. Unlike some other approaches, there's no separate app to download or additional Harness to install. When you execute Memory-related tasks, the Agent automatically runs this Skill — very lightweight.

How to Seamlessly Bridge Claude Code + Codex?

When your primary development Agent (say, Codex) has finished scaffolding a project, and you want to switch to Claude Code to use Fable 5 for discussing next steps and reviewing the overall skeleton, MemoraX Code proves highly valuable.

Because scaffolding involved multiple conversation rounds, the context is already lengthy and has undergone compression. Having Fable 5 in Claude Code read the entire project context directly would consume massive tokens — possibly exceeding Claude's Max subscription limits.

Moreover, Fable 5's efficiency drops with such long context, and it may not handle excessively long context well regardless.

MemoraX Code extracts key Memory directly from the development processes of Agents like Claude Code and Codex during daily work, effectively pre-distilling the Memory.

So at this point, you can simply tell Claude Code: "Let's continue the discussion from Codex about this voice project." It will invoke the MemoraX Code Skill:

MemoraX Code also has a web interface that records Memory from your Agents' daily development work, stored by entry and ID.

All routine development information inside has been distilled through multiple rounds, automatically stored as individual Projects, each containing Memory Summaries or various Facts.

The Skill's own specifications also explicitly require treating MemoraX Code's Memory as hypotheses, verified against current code — with verification skipping full context scans.

This ensures both efficiency and quality in Memory usage.

Creating Repo Memory

During development, you'll naturally accumulate issues, PRs, and commits. At this point, you can have the Agent use the MemoraX Code skill to build Repo Memory, pulling recent issues, PRs, and commits.

This Repo Memory is automatically constructed, containing all relevant records — such as commits for scaffolding local voice chat and DeepSeek integration.

While developing in Codex, you can also have it directly review recent issues from the entire Repo Memory.

These issues were initially created in Claude Code; now they can be queried directly in Codex, because the two Agents are connected through MemoraX Code.

During daily development, you can also have your primary development Agent use the MemoraX Code skill to memorize this coding experience, building a project-level development Memory library.

For example, after establishing this project-level development Memory library in Codex, you can start a fresh session, or even open a new conversation in Claude Code, and have MemoraX Code recall these development experiences — checking what suggestions remain, prioritized from P0 to P10.

Because Memory can be called across Agents, this enables using Codex Terra, a cost-effective balanced model, to rapidly scaffold; switching to Claude Code's Fable 5 for project review and planning; then seamlessly returning to Codex to continue with Terra, or even Luna, to complete full project development.

Back to the app itself.

Now, everything I say during real-time voice conversations, plus the content from AI interviews, automatically stores into this app's memory, then converts through DeepSeek into posts for Moments, Weibo, and Xiaohongshu — brainstorming assistance for me.

Overall, MemoraX Code bridges Codex and Claude Code through an intermediate Memory layer during daily development.

Claude Fable 5 offers cutting-edge intelligence, suited for project planning and review. GPT's Terra and Luna are also strong, fitting as sub-Agents or primary models for daily development. For ordinary developers or Vibe Coders, subscription limits matter too.

Because you want to reserve Fable 5 for truly critical tasks, using cheaper GPT models for daily development.

But in practice, bridging the two is extremely cumbersome. Doing a round with GPT first, then having Fable 5 review, incurs heavy context costs. Starting from zero with Fable 5 for planning isn't efficient either. So many developers, despite knowing each model's strengths, never attempt this collaborative approach.

After completing a small project, all Memory saves to the MemoraX AI platform in the cloud, making specific development experiences increasingly reusable over time — essentially a Memory data flywheel.

The final result looks like this:

Click the voice input at the lower left, a dynamic waveform animation appears, then it calls my local Whisper model or the Doubao speech API for transcription; after DeepSeek processes it, it asks follow-up questions based on the content, creating a voice interview effect that can later be enhanced into automatic duplex conversation.

All memories store within this app, then convert into Weibo, Xiaohongshu, and Moments posts.

Overall, MemoraX Code feels genuinely lightweight.

This lightness manifests in daily development as easy invocation. With two Agents like Claude Code and Codex alternating in collaboration, the Memory interaction is near real-time — the experience feels barely different from continuous development within a single Agent.

Based on official information, I also dug into some technical details. MemoraX Code is actually built on a dual-loop system, divided into two parts.

The upper half is an online Memory pipeline during inference; the lower half is an offline Memory model training flywheel. The two form a data closed loop through MemoraX Cloud.

Let's break this down.

First, the online loop: intent → memory → execution.

The loop's entry point is our natural language coding tasks for Agents, such as "continue fixing this set of related bugs." At entry, there's first an LLM-based intent understanding layer before retrieval — it doesn't retrieve using raw text directly.

Second, the memory component consists of MemoraX Local and MemoraX Cloud. MemoraX Local handles cold-start Memory for the entire codebase: key entry points, historical PRs and Issues, important decisions, current implementations, etc.

MemoraX Cloud handles cross-Agent, cross-device dynamic accumulation: your preferences, Procedures, Cross-Session experiences, failure experiences, etc. So the entire Memory layer isn't bound to any single Agent — it's a Harness-agnostic intermediate layer.

Throughout the solution, Memory isn't dumped wholesale into context; it's cropped on demand for context distillation — a fairly core design choice.

Now the offline loop. Beyond the data closed loop mentioned earlier, another important element is its Reward design.

Training involves three types of rewards. First, write rewards: whether this memory deserves storage. Then recall rewards: whether retrieved memories are correct. Finally, task outcome rewards: whether this Memory genuinely contributed to task success.

The foundation is a complete Agentic RL training infrastructure: sandbox, reward computation, evaluation, distributed training, etc. Online user trajectories also feed back into training, so the more it's used, the stronger the Memory model becomes — this is how the data flywheel forms.

When Andrej Karpathy proposed "Context Engineering" in June 2025, he used an analogy that's been widely cited since.

The gist:

Large models are like CPUs; the context window is their memory. Following this logic, Memory systems essentially solve OS-level scheduling problems: which information belongs in memory, which should be swapped out, which merits writing to disk for long-term retention.

And at this year's Sequoia AI Ascent, he further advanced the concept of "Agentic Engineering" — distinguishing systematic coding from casual Vibe Coding. The key to seriously using AI for code lies in doing requirements design well, understanding code changes, testing, and security review.

And these deep engineering steps almost all heavily depend on Agent Memory.

This, then, is where Agent Memory's true value lies.

The Agent Memory space currently has many experimental solutions: lightweight approaches, open-source frameworks, and products like MemoraX Code from domestic teams.

Which ultimately becomes the standard answer remains unknown, but in the coming year, this track should see more domestic team names emerge.