兩個大腦

How Claude Code And Codex Can Work Together

My project is becoming more and more complex.

At first, I may have only wanted a tool: drop in a paper PDF, let AI organize and summarize it, and then produce prompts for scientific figures.

But over time, that workflow became a full pipeline:

1. PDF / paper
2. Markdown normalization
3. section-aware chunking
4. vector index
5. local LLM summary
6. scientific figure prompt
7. ComfyUI / 3D / animation workflow

This is no longer something a single script can solve.

It involves document parsing, data structure design, chunking strategy, local model capability, prompt engineering, image generation workflows, and the stability of the whole project architecture.

So I started using two AI coding agents at the same time:

• Claude Code
• Codex

One is better suited to planning, checking architecture, and thinking through risks. The other is better suited to implementation, editing code, fixing bugs, and running tests.

At first, that looks like twice the capability. But soon a problem appears:

If two brains do not share memory, they can interfere with each other.

Two Brains, Both Smart, But Not Automatically Cooperative

Claude Code may look at the project and decide the architecture should be organized first.

Codex may look at the same folder and immediately start fixing a bug.

Claude Code may want to split the pipeline into clearer modules.

Codex may already have made a quick change in another file.

Neither AI is trying to damage the project. Each one is simply making decisions from the context it can see.

The problem is:

• Claude Code may not know what Codex just changed.
• Codex may not know what Claude Code just decided.

Without shared state, two agents are like two researchers working in the same lab without a shared lab notebook.

Everyone is working hard. But the project can still become more chaotic.

The Problem Is Not Intelligence. It Is Shared Working Memory.

This made me realize something:

In a complex project, the real question is not "which AI is stronger?"

The real questions are:

• Do they know what the current task is?
• Do they know who is responsible?
• Do they know which files should not be touched?
• Do they know what the previous agent did?
• Do they know what should happen next?

Without that information, even strong AI agents can work in separate directions.

So what I needed was not more agents. I needed a coordination system.

Markdown As A Shared Whiteboard

The solution is simple:

Use Markdown as the shared working memory for both AI agents.

Place three files at the project root:

• AGENTS.md
• CLAUDE.md
• AI_STATE.md

The most important one is:

AI_STATE.md

It is not an ordinary note. It is the shared whiteboard between Claude Code and Codex.

It records:

• current task
• current owner
• locked files
• latest status
• completed changes
• commands and tests that were run
• remaining issues
• recommended next step

Then Claude Code does not enter the project as if it were seeing everything for the first time. Codex also does not reinvent the workflow from its own partial angle.

Both agents read the same state file before deciding what to do.

Three Core Files

1. AGENTS.md

This file is for Codex.

It tells Codex:

• Read AI_STATE.md before starting.
• Do not edit files blindly.
• Write a plan before changing things.
• Update the handoff after changing things.

2. CLAUDE.md

This file is for Claude Code.

It tells Claude Code:

• Your role is usually planner and reviewer.
• Do not begin with a large architecture rewrite.
• Inspect the project state first.
• Check whether Codex is already responsible for a task.
• Write important decisions back to AI_STATE.md.

3. AI_STATE.md

This is where the two brains truly share state.

It can record things like:

• Current task: Improve Markdown-first paper processing pipeline.
• Current owner: Claude Code.
• Locked files: markdown parser and chunker.
• Latest status: Claude Code is reviewing the architecture.
• Next step: Codex should implement the next module after review.

This file becomes the handoff record between the two brains.

The Human Is Still The Commander

Even with Claude Code and Codex, the human remains the most important role.

AI can help plan, implement, review, and organize, but it does not know the true research goal or the real priority of risks.

The human role is to:

• define the goal
• decide task priority
• judge whether the architecture is reasonable
• assign which agent owns which part
• check whether the final result matches the research need

So this is not about letting AI run loose.

It is a division of labor:

• Human: direction and judgment
• Claude Code: planning, review, architecture thinking
• Codex: implementation, bug fixing, test execution
• Markdown: shared working memory
• Git: final change history

What This Means For notebooklm-comfyUI-3d

notebooklm-comfyUI-3d is no longer just an image generation project.

It is closer to a complete system for turning scientific documents into scientific visualization.

That means it especially needs to avoid two things:

• First, AI directly rewriting architecture without coordination.
• Second, two AI agents modifying the same pipeline at the same time.

So I want the basic working mode of this project to become:

1. write the task
2. assign the role
3. let one agent work
4. let the other agent review
5. write the status back to AI_STATE.md

In other words:

Task -> AI_STATE.md -> Claude Code / Codex -> Code change -> Review -> AI_STATE.md

This is how the project becomes more stable over time, instead of more tangled.

The Core Of The Story

Two-brain collaboration does not mean throwing two AI agents into the same folder and hoping they figure it out.

Real cooperation needs three things:

• shared task
• shared memory
• shared rules

Claude Code and Codex are both powerful. But they need a shared whiteboard.

In this system, Markdown is that whiteboard.

It keeps the two brains from thinking separately, and helps them work around the same project state.

That is what real multi-agent collaboration looks like.