How to Bring Claude Code and Codex Into the Same Team
Yes, Claude Code and Codex can work on the same project. The trick is to decide who does what, keep them from editing the same files at once, and make each one leave a clear note for the next. A person still approves the final merge or release.
You can manage this workflow without writing code, but someone still needs to own repository safety, tests, and merges. Git details appear later as an optional implementation layer.
A safe workflow for Claude Code and Codex
Start with this six-step workflow:
- A person defines one scoped task and what “done” means.
- One agent owns implementation; the other waits or works on a non-overlapping task.
- If both work at once, give them separate copies of the project so they cannot overwrite each other.
- The implementer sends a handoff with the work state and the requested next action.
- The reviewer checks the diff and returns findings to the implementer.
- A person approves the final merge and any release, permission, or customer-facing change.
Either tool can build or review. Pick the split that fits the task and your team.
What to include in every handoff
- Goal: what this task should achieve
- Working state: checkout, branch, commit when available, and any uncommitted changes that matter
- Files changed: the intended scope of the edit
- Decisions: what was chosen, rejected, or left undecided
- Checks: tests, linters, builds, or manual checks already run
- Open questions: risks or blockers that still need judgment
- Next action: review, revise, test, or escalate to a person
For non-code work:
Goal: Prepare the launch FAQ.
Completed: Claude Code drafted answers from the approved product notes.
Decision: Keep answers under 80 words and avoid pricing claims.
Open question: Does the security answer need legal review?
Next action: Codex checks for unsupported claims and missing questions.For a code task, add the repository details:
Goal: Add validation to the team-invite form.
State: branch feature/invite-validation; commit 8f31c2a; clean working tree.
Files changed: InviteForm.tsx, invite-schema.ts, invite-form.test.ts.
Decision: Validate on blur and submit; keep server errors inline.
Checks: unit tests and typecheck passed.
Open question: Should an expired invite use the same error state?
Next action: Review the diff for edge cases and test coverage.When a session ends, a new one does not remember that conversation. At checkpoints, record decisions and the next action, and preserve the current files or a commit. The next session must read the note and inspect uncommitted and untracked changes. In a temporary environment, use a durable commit or external artifact. If the note conflicts with the files or tests, stop and reconcile the difference.
Four ways to use Claude Code and Codex together
Use the simplest setup that fits how often the work changes hands.
| Situation | Start with | What it handles | Main limitation |
|---|---|---|---|
| One small or experimental task | Manual handoff | Full human control with almost no setup | You carry every update between sessions |
| Code moving between implementer and reviewer | Git branches, commits, and pull requests | Diffs, code history, and review | Git does not assign the next owner or preserve every decision |
| The whole job stays inside one product | Claude Code subagents or Codex threads | Parallel work inside one runtime | It does not connect independent Claude Code and Codex sessions |
| The same workflow repeats across both tools | A shared workspace such as Alook Agency | Keeps assignments, updates, and handoffs in one shared conversation | Extra setup may not be worth it for a one-off task |
Claude Code subagents can work in separate context windows and report back to a main Claude Code session. The Codex app supports multiple agents in parallel, with separate threads and isolated copies of a repository. These features work well when every agent is inside the same product. They do not make the other product share its private session.
Optional Git implementation
If you do not manage code, you can skip this section.
Branches separate commit history. They do not isolate two agents editing the same working directory. For concurrent edits, use separate checkouts as well as separate branches. A Git worktree, a separate clone, or a container with its own repository checkout can provide edit isolation.
implementation checkout: branch feature/payment-copy
review checkout: detached at the handed-off commit, or reviewing its PRA read-only reviewer does not need a separate review branch. If the reviewer will change files, create a branch from the handed-off commit. Merge only after dependencies, conflicts, and tests are checked. If both agents need the same file, let one edit while the other reviews or proposes changes.
When keeping Claude Code and Codex separate is simpler
You probably do not need a shared workflow across both tools when:
- one runtime and one session can finish the task;
- you are still learning either tool;
- native subagents or threads already cover the workflow;
- implementation and review rarely cross between products; or
- copying a short handoff is occasional, not recurring work.
Start with one agent or a manual note. Add a shared workflow when you keep losing track of ownership, forwarding updates, or repeating decisions.
What changes when the workflow repeats
Opening both tools side by side does not keep them coordinated. If work moves between them often, someone still has to say who is doing what, what is finished, and what happens next.
Trust the current checkout and test results over an outdated note. Committed Git history records committed code, but the working tree may contain newer work. Use the note for decisions, open questions, and the next action—not as a substitute for inspecting the project.
Running a recurring cross-runtime workflow through Alook Agency
Alook Agency puts the project owner, Claude Code, and Codex in one shared room. The sender posts the task, result, and next step once instead of copying updates between terminals. People and agents state roles and the next owner in messages; marks keep outstanding work visible. Alook Agency does not infer or route them. The room record remains available to accounts with access after a terminal session ends.
Alook Agency does not merge the agents, copy their private chats, or grant extra file and tool access. The sender still writes the update, the receiver still reads it, and each agent keeps the access set by its local configuration.
To try it, start a hosted shared room or self-host Alook Agency from GitHub, then follow the current instructions to connect a supported local agent.
Claude Code and Codex FAQ
How do you use Claude Code and Codex together?
Give each agent a scoped role, isolate concurrent edits, use Git for code changes, and send an explicit handoff when work moves between them. Keep final merge and release approval with a person.
Can Claude Code and Codex work on the same repository?
Yes. If they edit concurrently, use independent checkouts and branches so they do not write into the same working directory. A Git worktree, separate clone, or container with its own repository checkout can provide that isolation.
Can Claude Code delegate to Codex?
Not through a shared native session. A person or shared workspace must pass the goal, repository state, decisions, checks, questions, and next action explicitly.
Can Claude Code and Codex talk to each other directly?
They do not share a private conversation or context by default. A person can carry the update, or a shared workspace can provide a room where permitted people and agents explicitly send and read messages.
Do I need Git or worktrees?
Not for non-code work. If both agents edit the same repository at the same time, use separate checkouts and branches to prevent them from overwriting each other's files.
What happens when a coding-agent session closes?
The other tool does not inherit its private session. At checkpoints, preserve the current files or a commit and leave a note with decisions and the next action. A new session must inspect the checkout—including uncommitted work—and read the note before continuing.
Does Alook Agency replace Claude Code or Codex?
No. Alook Agency provides agent identities, room and thread history, read state, and marks. People or agents explicitly send the task, current state, and next action. Claude Code and Codex still run commands and edit files through their owners' local setups.