Run Codex and Claude Code side by side

Updated 2026-09-13

Start with two CLIs and two clear assignments

To run Codex and Claude Code side by side, launch codex and claude in separate terminals. Give them distinct responsibilities before submitting work. One can implement a change while the other later reviews it, or both can implement independent changes in separate worktrees.

Independent sessions do not automatically share instructions, context, or ownership.

SpeakCode hosts both real CLIs in neighboring terminal cards. You keep the tools' own accounts and configuration while arranging their output on the same canvas. The Codex workspace overview shows the product workflow.

Start with a pairing: Codex implements a search empty state, and Claude Code reviews the result after implementation pauses. Define the files and test command up front. That gives the second agent something specific to check and gives you a clear point at which to read the diff yourself.

Verify installation, accounts, and app requirements

Have both CLIs installed and authenticate each through its own supported account or API-key setup before adding a handoff. Verify that both commands are available in the terminal environment:

command -v codex
command -v claude

Then launch codex and claude in separate terminals and confirm each can accept a task. A command being present only verifies installation visibility; it does not prove authentication or available usage. Resolve account problems in that CLI before connecting it to another session.

SpeakCode requires macOS 26 or later. It costs $20/month or $200/year, with no free trial. The $20/month subscription covers the app only; AI usage is billed by OpenAI and Anthropic through your provider accounts. Running Codex and Claude Code together does not combine those accounts or include their AI allowance in the app subscription.

Keep the first exercise small enough to inspect fully, such as one component and its existing tests. You can expand the workflow after both terminals complete a turn.

Align CLAUDE.md and AGENTS.md before assigning work

Claude Code uses CLAUDE.md for project instructions; Codex uses AGENTS.md. Review the applicable instructions for each CLI and make sure they agree on package directories, test commands, generated files, and editing boundaries. The instruction-file comparison explains how each CLI discovers its instructions.

Keep shared project facts consistent. For example, if the package lives in web/, both agents need to know that its npm commands run from that directory. If one instruction file still names a retired test runner, a review can appear complete even though the relevant checks never ran.

State task-specific ownership in the prompt as well:

Implement the search empty state in web/src/search/.
Use the existing tests for that feature.
Do not edit shared navigation or package dependencies.
Finish with changed paths, exact checks run, and open questions.

This is an example assignment; replace the path with your repository's real scope.

A belt delivers terminal input. It does not share the first agent's conversation. The receiver still needs the paths and review instructions required to understand the handoff.

Configure each agent's completion signal

Set up Claude Code's Stop and Notification hooks and Codex's notify completion command using the agent status hooks guide. Preserve existing configuration when adding the entries. The guide's Claude Code examples emit explicit completion and awaiting-input markers; its Codex example emits completion only.

In each card, let the agent finish a small response and check the node's Activity feed. Verify an actual Claude Code notification separately. A manual marker checks the terminal route; an event produced by the CLI checks that the hook was loaded and invoked.

Without explicit hooks, SpeakCode can infer settling from quiet output. That estimate can identify a pause before the agent has finished.

Verify completion events before relying on a belt. Codex's notify example does not establish that every permission request produces an explicit attention event.

Recipe: Codex implements, Claude Code reviews

Open two terminal cards in the same worktree for this sequential recipe. Name them after their roles and branch, such as implement/search and review/search. Keep Claude Code ready at its input prompt and tell Codex to stop after its bounded implementation and report what changed.

Draw a belt from Codex to Claude Code. Open the belt inspector, choose Run command, and enter a fixed review prompt:

Review the current changes without modifying files.
Inspect the diff and relevant tests for correctness bugs,
missing coverage, and unintended behavior.
Report findings with file paths, or state that you found none.
Do not treat the implementation summary as proof of correctness.

Run command submits that text plus Enter to the destination. In an agent terminal it becomes a prompt. When Codex finishes its turn, Claude Code receives the same instruction regardless of the prose visible in Codex's terminal.

Keep Codex paused while the review runs so the reviewer sees stable files. Read the findings, decide what needs fixing, and assign the next implementation turn yourself. A no-edit prompt describes the reviewer's assignment; it is not a filesystem permission boundary.

The belt handoff guide covers the delivery modes and setup. Deliver output sends only the last 40 non-blank lines of captured screen text, so use Run command when the review instruction must be consistent. A stopped target receives nothing, and a busy target is not queued. Verify readiness before every repeated handoff.

Recipe: two implementers on separate worktrees

For simultaneous writing, put Codex on feature/search and Claude Code on feature/export, with a separate worktree for each. SpeakCode does not create these worktrees; use the parallel worktree guide to prepare them yourself.

Assign separate acceptance criteria and have each session identify its branch in the final report. If both need to change a shared API, settle the contract before they implement against it. File isolation prevents accidental overwrite during editing; it does not eliminate merge conflicts or incompatible decisions.

Review each branch separately and integrate in a chosen order. Do not send a vague “review this” prompt to an agent in another worktree and expect it to see uncommitted changes. Move the review session deliberately to the intended directory after stopping its previous work, or provide a specific committed revision and inspection instructions.

Recipe: one planner and one executor

Give Claude Code a read-only planning task, then ask Codex to implement the approved plan. You can also reverse those roles based on your experience with the repository; the arrangement does not depend on a claim that one model always plans or codes better.

Ask the planner for three concrete outputs: paths to change, acceptance checks, and unresolved decisions. Read those before handing the plan to the executor. A plan containing “update the service” is too loose; one naming src/search/service.ts and the expected empty-result behavior gives the executor a bounded starting point.

For the first attempt, transfer the approved instruction manually. If you later use a belt, prepare the receiver and keep the handoff concise enough for the selected delivery mode. Avoid a loop of agents sending revisions back indefinitely. Keep approval of scope and completion with the person responsible for the change.

Use the inbox to decide who needs you next

Each card shows idle, working, waiting, or exited. The agent inbox gathers waiting agents across the canvas with a standup-style summary. Use it to locate either provider's session, then open that terminal and read the actual question or output.

Check Activity when the phase alone is ambiguous. Quiet-output settling can produce waiting; the hook event tells you more about what occurred. A completed turn does not mean tests passed. For an exited terminal, inspect its final output before deciding whether to start another session.

Keep cost and review effort bounded

A Codex vs Claude Code workflow should earn the extra review step. Each provider retains its own billing and rate limits, and multiple sessions on one provider account can compete for its allowance. Do not assume a second canvas card increases capacity or that a review is free because implementation already finished.

Use one agent for a 10-line correction when you can read the whole diff and run its checks yourself. Use two when an independent review or separate implementation task justifies the extra context and attention. The Codex and Claude Code comparison offers more context for choosing a pairing. Judge the workflow by reviewed, tested changes you can integrate, not by the number of terminals producing output.

Questions

Does SpeakCode include Codex and Claude Code AI usage?

No. SpeakCode costs $20/month or $200/year for the app. Bring your own OpenAI and Anthropic accounts or API keys; the providers bill AI usage separately.

Can both agents edit the same checkout at once?

They can access the same files, but concurrent edits can overwrite each other. Use separate worktrees for simultaneous implementers, or pause the writer while a reviewer inspects its checkout.

Which belt mode should I use for a fixed review prompt?

Choose Run command in the belt inspector. It submits your fixed text plus Enter; an agent terminal interprets that text as a prompt.

Does the Codex notify example report waiting for permission?

The linked status guide configures Codex notify for completion only. Inspect the terminal and Activity events to understand why a session is waiting.

Codex and Claude Code on One Canvas | SpeakCode · All guides