You use Claude Code and Codex together by giving them one shared set of instructions, separate branches or worktrees so they never edit the same files at once, and a hand-off where one agent writes the code and the other reviews it. The catch is that both tools are built for one developer and work alone, so today you are the one who carries every diff, every brief and every "is it done?" between them.
This guide shows both ways to do it. First the do-it-yourself way: the shared AGENTS.md file, git worktrees, OpenAI's own Codex plugin for Claude Code, headless runs and GitHub reviews. Then the team way: running Claude Code and Codex as two teammates in one AI office, where a chief hands the work from one to the other and you only see the decisions that need you.
Quick answer
Can you use Claude Code and Codex together? Yes. Many developers already do. The most common pattern is simple: one agent writes the change, and the other agent reviews it before it ships, because a second model catches mistakes the first one keeps agreeing with.
The fastest setup (about 15 minutes):
- Put your project rules in one AGENTS.md file. Codex reads it by default, and recent versions of Claude Code read it too when there is no CLAUDE.md.
- Give each agent its own git worktree or branch, so they never edit the same files at the same time.
- Install OpenAI's Codex plugin for Claude Code and run /codex:review on Claude Code's changes before you commit.
- For the other direction, pipe Codex's diff into claude -p and ask Claude Code to review it, or mention @claude on the pull request.
- Keep a human yes on anything that merges, deletes or ships.
The limit of the DIY way: Claude Code and Codex are personal agents. Each one works for the person who started it, keeps its own memory and bills its own account. Neither knows what the other did yesterday. You become the glue.
The team way: In Vestra, Claude Code and Codex can each be the engine under a teammate. One teammate builds on Claude Code, another reviews on Codex, and your chief hands the work between them under one set of rules, one memory and one receipt.
Key takeaways
- Claude Code and Codex work well together because they are built by different companies on different models, so they make different mistakes. Using one to check the other is the most useful pattern.
- Both are personal tools. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes are each built for one person and work alone. Running two of them side by side does not make them a team.
- Shared instructions are now easy. Codex reads AGENTS.md. Claude Code can read AGENTS.md on its own when a repo has no CLAUDE.md, or import it from CLAUDE.md with one line.
- Worktrees stop collisions. Each agent works in its own checkout on its own branch. You merge only what passed review.
- OpenAI ships a Codex plugin for Claude Code. It adds /codex:review, /codex:adversarial-review, /codex:rescue and an optional review gate. All of it counts against your Codex usage limits.
- Costs stack. Running both means two subscriptions: Claude Pro starts at $20 a month and ChatGPT Plus at $20 a month, with heavier tiers at $100 and up on each side.
- The real cost is your time. In the DIY setup you brief twice, carry diffs by hand, keep two memories in sync and chase every result.
- An AI office removes the glue. In Vestra you pick the engine teammate by teammate (Vestra's own, Claude Code or Codex are live today), and a chief runs them as one team with limits, approvals and receipts.
Contents
- Can you use Claude Code and Codex together?
- What are Claude Code and Codex?
- Why use two coding agents instead of one?
- What goes wrong when you just run them side by side?
- How do you set up one repository for both agents?
- How do you stop Claude Code and Codex from overwriting each other?
- How do you get Codex to review Claude Code's work?
- How do you get Claude Code to review Codex's work?
- Which agent should write, and which should review?
- What does a full day of Claude Code and Codex together look like?
- How much does it cost to run Claude Code and Codex together?
- What are the most common mistakes, and how do you avoid them?
- How do you share memory and context between the two?
- How do you run Claude Code and Codex as teammates instead of tools?
- Should you build the DIY setup or use an AI office?
- How do you get started today?
- Frequently asked questions
- Glossary
Can you use Claude Code and Codex together?
Yes. Claude Code and Codex can work on the same codebase at the same time, and many developers run both. The usual setup gives them one shared instruction file, a separate branch or worktree each, and a review step where one agent checks the other's work. OpenAI even ships an official plugin that runs Codex inside Claude Code.
There is no switch that joins them. They are two separate products from two separate companies. Claude Code is Anthropic's coding agent. Codex is OpenAI's. Each has its own command-line tool, its own desktop and web apps, its own login, its own plan and its own memory. When people say they "use them together", they mean they have built a small workflow around both.
That workflow usually has three parts:
- Shared rules. Both agents read the same description of the project: how to build it, how to test it, what style to follow and what never to touch.
- Separate workspaces. Each agent edits its own copy of the code, so two agents never write to the same file at the same moment.
- A hand-off. Work moves from one agent to the other, most often from the agent that wrote it to the agent that reviews it.
The rest of this guide walks through each part in detail, with the exact commands each tool's own documentation gives. Then it shows what changes when the two agents stop being two tools on your laptop and become two teammates in one office.
Who this guide is for
This guide is for three kinds of reader. If you are a developer who already pays for one of the two tools, it shows you how to add the other without doubling your work. If you run a small engineering team, it shows you the rules and limits you need before two agents touch your main branch. And if you run a business and keep hearing that "the engineers use Claude Code and Codex", it explains in plain words what that means, what it costs and where the hidden work sits.
What are Claude Code and Codex?
Claude Code is Anthropic's coding agent: it reads your codebase, edits files, runs commands and opens pull requests from your terminal, IDE, desktop or the web. Codex is OpenAI's coding agent: it does the same jobs in its own CLI, IDE extension, app and cloud, and comes with ChatGPT plans. Both are built for the developer who starts them.
Claude Code in plain words
Claude Code is a coding agent made by Anthropic. You open it in a project folder, describe what you want, and it reads the code, plans a change, edits files and runs commands such as your tests. It can create commits and pull requests. It runs in a terminal, in IDEs, in a desktop app and in the cloud.
A few Claude Code features matter for working with a second agent:
- CLAUDE.md files hold persistent instructions for a project. Claude Code reads them at the start of every session.
- AGENTS.md support. Claude Code's documentation says it "can read AGENTS.md as your project instructions, so a repository already set up for other coding agents works without adding a CLAUDE.md, an import, or a setting." By default it does this only when there is no CLAUDE.md.
- Subagents are specialised helpers, each with "its own context window with a custom system prompt, specific tool access, and independent permissions." They are all Claude models.
- Worktrees. Running
claude --worktree feature-authstarts a session in its own git worktree, so parallel sessions don't collide. - Headless mode.
claude -p "your prompt"runs Claude Code without the interactive screen, which is how you call it from scripts. - GitHub Actions. Mention
@claudein a pull request or issue and the Claude Code GitHub Action can review, fix and push. - Plugins. Claude Code installs plugins from marketplaces, which is how OpenAI's Codex plugin gets in.
Claude Code is included in every paid Claude plan. Claude's pricing page lists Pro at $20 a month ($17 a month billed yearly), Max at $100 a month and Ultra at $200 a month, plus Team seats at $25 (standard) and $125 (premium) a month, or $20 and $100 billed yearly. Usage limits are shared with the rest of the plan.
For a full side-by-side of Claude Code and an AI office, see Vestra vs Claude Code.
Codex in plain words
Codex is OpenAI's coding agent. It works in a CLI, an IDE extension, a desktop app, on the web and on iOS, and it can run tasks in OpenAI's cloud. Like Claude Code, it reads your code, plans, edits, runs commands and opens pull requests.
The Codex features that matter here:
- AGENTS.md. OpenAI's best-practices page calls AGENTS.md "an open-format README for agents" that "loads into context automatically." Codex walks from the project root down to your current folder and joins the files it finds, with closer files winning.
- /review. Codex can review a branch against a base, your uncommitted changes or a single commit, with your own instructions if you like.
- GitHub code review. Comment
@codex reviewon a pull request, or turn on automatic reviews. In GitHub, Codex "flags only P0 and P1 issues", so the comments stay on high-priority risks. - codex exec. The non-interactive mode for scripts. By default "codex exec runs in a read-only sandbox."
- Subagents for bounded side work such as exploration, tests or triage, inside one Codex chat.
- Worktrees. OpenAI lists "running live tasks on the same files without using Git worktrees" as a common mistake.
Codex is part of ChatGPT. OpenAI's Codex pricing page lists Free and Go ($8 a month) for lighter tasks, Plus at $20 a month with the CLI, IDE extension, web and automatic code review, Pro at $100, $200 or $500 a month, Business at $20 per user a month billed yearly ($25 monthly), and Enterprise through sales. You can also use an API key at API prices, without the cloud features.
For the full comparison with an AI office, see Vestra vs Codex.
What they have in common
Strip away the brand names and Claude Code and Codex are the same kind of thing: a personal coding agent. Each one:
- Works for the person who started it.
- Keeps its own sessions, its own memory files and its own settings.
- Bills one person's account, or one seat on a team plan.
- Can spin up helpers (subagents), but only on its own maker's models.
- Has no idea what the other agent did, unless you tell it.
That last point is the whole story of this guide. Claude Code and Codex are excellent at the work. They are not built to work with each other, or with anyone else's agents. The same is true of the other personal agents people compare them with: Grok Bot, Meta Muse, OpenAI Dots and Hermes are each built for one person, and each works alone. We cover that wider picture in The best AI agents for business.
Why use two coding agents instead of one?
Because two different models make different mistakes. An agent that reviews its own code tends to agree with its own choices. A second agent, trained by a different company, reads the change with fresh eyes. You also get a backup when one service is slow or down, and a second opinion on hard design calls.
Reason 1: a second model catches what the first one missed
This is the reason almost everyone gives. A writer is a poor editor of their own work, and the same is true of a model. The author of an XDA Developers piece on running both tools put it plainly: self-review fails because a model "agrees with its earlier choices." When he hands Claude Code's diff to Codex, or Codex's to Claude Code, the second one finds gaps the first one walked past.
This is not about one tool being better. It is about two tools being different. Different training, different habits, different blind spots. The overlap between their mistakes is smaller than either one's mistakes alone.
Reason 2: each one has things it is good at
People who use both tend to split the work by taste. Some prefer Claude Code for planning and for front-end and design-heavy work, and Codex for patient debugging and careful, test-first changes. Others use Codex as the main driver and Claude Code as the reviewer. A Towards Data Science write-up describes Claude Code as the primary driver for planning and implementation, with Codex handling GitHub code reviews in a loop until the review passes.
There is no fixed rule. Section 9 of this guide shows how to decide for your own codebase.
Reason 3: a backup when one service has a bad day
Both services have outages and usage limits. If you already have both set up on the same repository, a bad afternoon on one side doesn't stop your work. You switch agents and keep going.
Reason 4: two opinions on decisions that matter
For a schema change, a security fix or a big refactor, you want more than one view before you commit. Codex's plugin for Claude Code even has a command built for this: an "adversarial" review that "challenges design choices, tradeoffs, hidden assumptions, and alternative approaches."
What two agents do not give you
Two agents do not give you a team. They give you two very capable individuals who never talk to each other. Everything that makes a team a team (a shared brief, a shared memory, someone who hands work over and checks it is done, one set of rules, one bill) is missing. You provide all of it. The next section is about that gap.
What goes wrong when you just run them side by side?
You become the glue. Claude Code and Codex each work alone, so you brief both, copy diffs from one to the other, keep two memory files in sync, watch two usage meters and chase every result to check it is done and right. The agents are fast. The hand-offs between them are slow, manual and easy to get wrong.
Picture a normal afternoon with both tools open.
You ask Claude Code to add a feature. It reads the code, writes the change and tells you it's done. You copy the diff, or switch to the branch, and ask Codex to review it. Codex finds two problems. You copy its notes back into Claude Code. Claude Code fixes one and argues with the other. You decide who is right. You ask Codex to look again. Meanwhile you remember that Codex learned something last week about the payment module that Claude Code doesn't know, so you paste that in too. Then you check both usage meters, because the review loop ran longer than you expected.
Every step in that story is a step only you can take, because neither agent can see the other. Here is the full list of jobs that land on you:
- Brief. You explain the same context to both agents, in two different places.
- Carry. Work moves between the agents only when you copy it, switch branches or run a command.
- Remember. Each agent keeps its own memory. What one learns, the other never hears about.
- Referee. When they disagree, you decide. Nobody else is in the room.
- Chase. You check whether each piece is done, and then whether it is right.
- Guard. You keep the agents from overwriting each other, running up costs, or touching what they shouldn't.
- Pay. Two subscriptions, two usage limits, two bills, and no single receipt that shows what a piece of work cost across both.
For one developer on one project, that's fine. Many people do it every day, and the tools below make it a lot easier. But the work grows fast. Add a second developer with their own agents, or a designer, or a founder who wants to know whether the fix shipped, and the glue work grows faster than the code.
This is the pattern the AI office idea exists to fix. People quietly become the glue between agents. They paste the same context again and again, carry work from one agent to another and chase every result. The DIY setup below shrinks that work. An office removes most of it. We'll come back to that in section 14.
How do you set up one repository for both agents?
Write your project rules once, in an AGENTS.md file at the repository root. Codex reads AGENTS.md by default. Claude Code reads it on its own when there is no CLAUDE.md, or you can keep a short CLAUDE.md that imports it with one line. Then both agents start every session from the same build commands, style rules and limits.
Step 1: write one AGENTS.md
AGENTS.md is a plain Markdown file for coding agents. Think of it as a README written for an agent instead of a person. Keep it short and practical. A good one answers six questions:
- What is this project? One or two lines.
- How do I set it up? The install command.
- How do I build and test it? The exact commands, and which tests must pass.
- How should code look? Style, naming, file layout, and the linter to run.
- What must never happen? For example: never edit the migrations folder by hand, never commit secrets, never push to main.
- How do we review? What a reviewer should look for. Codex's GitHub integration looks for a section called "Code Review Rules" in the AGENTS.md closest to the code.
Codex can draft this file for you. OpenAI's docs say "the /init slash command in the CLI is the quick-start command to scaffold a starter AGENTS.md in the current directory." Edit what it writes so it matches how your team works. Both tools' docs give the same advice: keep it short, and add a rule when you see the same mistake twice.
Step 2: let Claude Code read the same file
You have three choices here. Claude Code's documentation describes all three.
- Option A: AGENTS.md only. If the repository has an AGENTS.md and no CLAUDE.md (or CLAUDE.local.md) in your working folder or above it, Claude Code reads your AGENTS.md. In an interactive session you see a line such as "no CLAUDE.md found; AGENTS.md loaded". This needs Claude Code v2.1.277 or later.
- Option B: a CLAUDE.md that imports AGENTS.md. Create a CLAUDE.md with the line
@AGENTS.md, plus anything only Claude Code needs. Claude Code expands the import at launch. This works on every version and in sessions where direct AGENTS.md support is off. - Option C: both files, read together. Set Claude Code's "Project instructions" setting to read CLAUDE.md and AGENTS.md together. Claude Code skips an AGENTS.md it has already loaded, so it isn't read twice.
Option B is the safest choice for a shared repository. One file holds the rules. The other is a one-line pointer plus anything specific to Claude Code.
One trap to know about: if you add a personal CLAUDE.local.md to a project that relies on AGENTS.md, Claude Code stops reading AGENTS.md for you by default, because a CLAUDE.local.md counts as a CLAUDE.md. Claude Code's docs say to switch the setting to read both if you want to keep your local file.
Step 3: decide what doesn't go in the shared file
Some instructions belong to one agent only:
- Tool-specific commands. Claude Code's hooks, subagents and plugins live under the .claude folder. Codex's settings live in .codex/config.toml. Keep these out of AGENTS.md.
- Personal preferences. Your own sandbox URLs or test data go in a personal file (CLAUDE.local.md for Claude Code, your global ~/.codex/AGENTS.md for Codex), not in the shared one.
- Secrets. Never. Not in either file.
Step 4: match the safety settings
The two agents have different permission systems, and you want them to be equally careful. Codex's docs suggest starting "with default permissions" and loosening them only for trusted repositories. Its non-interactive mode starts read-only. Claude Code has permission modes, from a plan mode that proposes changes without editing to modes that accept edits automatically, and an allow list for tools and commands.
A simple rule for a shared repo: neither agent may push to the main branch, delete files outside its task, or run commands that reach production. Write that rule in AGENTS.md so both read it, and enforce it in each tool's own permission settings, because instruction files are guidance, not locks. Claude Code's own docs say CLAUDE.md is treated "as context, not enforced configuration", and point to hooks for anything that must be blocked.
Step 5: test that both agents see the same rules
Open each agent in the repository and ask it the same three questions: "How do I run the tests here?", "What must you never do in this repo?" and "What does a good review check for?" If the answers differ, one agent is reading something the other isn't. Fix it now, before they write any code.
How do you stop Claude Code and Codex from overwriting each other?
Give each agent its own git worktree on its own branch. A worktree is a separate checkout of the repository, so Claude Code and Codex each edit their own copy of the files and never write to the same file at the same moment. You merge their branches only after review, the same way you would with two human developers.
Why collisions happen
Both agents edit files on disk. If you point them at the same folder, they can overwrite each other's changes, read half-finished edits, or leave the test suite in a state neither of them expects. OpenAI's own best-practices page names "running live tasks on the same files without using Git worktrees" as a common mistake.
Set up a worktree for each agent
Claude Code can make its own worktree. Its docs show:
claude --worktree feature-auth
Run the same command with a different name in a second terminal and you get a second, isolated session. For Codex, scheduled tasks in the desktop app let you choose "whether the task runs in a dedicated Git worktree or in your local environment", and you can always create one yourself with plain git:
git worktree add ../myapp-codex -b codex/review-auth
Then open Codex in that folder. Now you have:
- Your main checkout, which you keep clean.
- A Claude Code worktree on a branch such as claude/feature-auth.
- A Codex worktree on a branch such as codex/review-auth.
Note that worktrees need at least one commit in the repository. Claude Code's docs show the error you get in an empty one.
Three ways to split the work
1. Writer and reviewer on the same branch, one at a time. Claude Code writes in its worktree and commits. Codex reviews that branch (read-only) and reports. Claude Code fixes. Codex never edits. This is the simplest and the safest.
2. Two writers on two branches. Each agent builds a different feature in its own worktree. You merge each branch after the other agent reviews it. Good for speed, but watch for features that touch the same files.
3. Same task, two attempts. Give both agents the same task in two worktrees and keep the better result. The XDA author does this: "the two models often reach different solutions", and the losing version still teaches you something. It costs twice as much, so save it for hard problems.
Rules that keep the branches clean
- One agent per worktree. Never two agents in one folder.
- Reviewers read, they don't write. If a reviewer finds a problem, it goes back to the writer.
- Commit small. Small diffs are easier for the other agent to review and easier to undo.
- Merge only after the tests pass and the other agent has signed off.
- Delete worktrees when the branch is merged, so old copies don't pile up.
How do you get Codex to review Claude Code's work?
The easiest way is OpenAI's official Codex plugin for Claude Code. Install it from inside Claude Code, run /codex:setup, then run /codex:review on your uncommitted changes or your branch. Codex reads the diff and reports problems without editing anything. You can also run codex exec in a script, or ask for a review on the pull request with @codex review.
Option 1: the Codex plugin for Claude Code
OpenAI publishes a plugin that "lets you use OpenAI's Codex from inside Claude Code." It uses your local Codex install and login, so the same settings apply. You need a ChatGPT subscription (the plugin's page says Free works) or an OpenAI API key, and Node.js 18.18 or later.
To install it, run these inside Claude Code:
/plugin marketplace add openai/codex-plugin-cc/plugin install codex@openai-codex/reload-plugins/codex:setup
The setup command checks whether Codex is installed and logged in, and can offer to install it. If Codex isn't logged in, run !codex login.
The commands you get:
- /codex:review runs a standard, read-only Codex review of your uncommitted changes, or of your branch against a base such as
--base main. - /codex:adversarial-review runs a read-only review you can steer with your own focus. It "challenges design choices, tradeoffs, hidden assumptions, and alternative approaches."
- /codex:rescue hands a task to Codex through a subagent: investigate a bug, try a fix, continue earlier work, or use a smaller, cheaper model.
- /codex:transfer turns the current Claude Code session into a Codex thread you can resume in Codex.
- /codex:status, /codex:result and /codex:cancel manage background jobs.
Long reviews can take a while, so the plugin's docs suggest --background, then checking in with /codex:status.
Option 2: the review gate
The plugin has an optional review gate. When it's on, a Stop hook runs a targeted Codex review of Claude Code's response before Claude Code finishes. If Codex finds problems, Claude Code is blocked from stopping and has to fix them first.
That sounds perfect, and for some work it is. But OpenAI's own docs warn that the gate "can create a long-running Claude/Codex loop and drain usage limits quickly", and say to turn it on only if you plan to watch the session. Use it for short, important changes, not for a long unattended run.
Option 3: codex exec in a script
If you'd rather keep the tools separate, call Codex from a script. Codex's non-interactive mode takes a task as one argument, runs read-only by default, and can write just the final message to a file:
codex exec "Review the diff between main and this branch. List bugs, risky changes and missing tests. Do not edit files." -o review.md
Run it from the Claude Code worktree after Claude Code commits, then hand review.md back to Claude Code. Because codex exec starts in a read-only sandbox, the reviewer can't change the code it is reviewing.
Option 4: @codex review on GitHub
If your team works through pull requests, let Codex review there. Comment @codex review on the pull request, or turn on automatic reviews for the repository in Codex's settings. Codex posts a normal GitHub review, flags only P0 and P1 issues, and follows the code review rules it finds in your AGENTS.md files. On an API key, Codex's pricing page notes you don't get cloud features such as GitHub code review, so this needs a ChatGPT plan.
What to ask Codex to look for
A review is only as good as its brief. Put these in the "Code Review Rules" section of AGENTS.md so every review checks them:
- Does the change do what the task asked, and nothing more?
- Are there tests for the new behaviour, and do they pass?
- Could this break anything that calls the changed code?
- Are errors handled, and are inputs checked?
- Does it touch security, money, data deletion or user privacy?
- Is there a simpler way?
How do you get Claude Code to review Codex's work?
Pipe Codex's diff into Claude Code's headless mode with a review prompt, for example git diff main | claude -p. You can also define a read-only reviewer subagent in Claude Code, or mention @claude on the pull request through the Claude Code GitHub Action. There is no official Claude plugin inside Codex, so this direction is a little more manual.
Option 1: claude -p on the diff
Claude Code's docs show how to use it as "a project-specific linter or reviewer" by piping a diff into claude -p. Piping the diff means Claude Code doesn't even need shell access to read it. From the Codex worktree:
git diff main | claude -p "You are reviewing another agent's change. List bugs, risky changes and missing tests. Do not suggest style-only edits." --output-format json
The JSON output includes the review text in a result field, plus a cost estimate, which helps if you want to track what reviews cost. For a security pass, Claude Code's docs show the same idea with an extra system prompt such as "You are a security engineer. Review for vulnerabilities."
For scripts and CI, Claude Code's docs recommend adding --bare, which skips local hooks, plugins and memory so the run behaves the same on every machine. Bare mode uses an API key rather than your subscription login.
Option 2: a reviewer subagent
Claude Code subagents are Markdown files with a short header. A reviewer that can only read is a few lines:
- Save it as .claude/agents/code-reviewer.md.
- Give it a name and a description such as "Reviews changes made by other agents."
- Limit its tools to Read, Glob and Grep, so it can look but not edit.
- Write its instructions: what to check, and how to report.
Then, inside Claude Code, ask: "Use the code-reviewer subagent to review the changes on branch codex/review-auth." The subagent works in its own context window and sends back only its findings.
Option 3: @claude on the pull request
The Claude Code GitHub Action responds when someone mentions @claude in a pull request or issue. Run /install-github-app from Claude Code to set it up, or add the workflow yourself. You can also install a code-review workflow that runs on every pull request and posts inline comments. When Codex opens a pull request, Claude Code reviews it in the same place your team already looks.
Claude Code's docs give one guard worth copying: by default the action rejects bot actors unless you list them, "which keeps bots from triggering Claude in a loop." Keep that on. Two agents reviewing each other's pull requests forever is an easy way to spend a month's limits in a night.
Option 4: go back to the plugin
If Claude Code is your main tool and Codex wrote the change through /codex:rescue, you're already inside Claude Code. Ask Claude Code to review what Codex returned before you accept it. Writer on one engine, reviewer on the other, all in one session.
Which agent should write, and which should review?
There is no fixed answer. Pick by your codebase, not by brand. A good default is to let the agent you trust most for planning and building do the writing, and let the other one review, because the reviewer's job is to disagree. Then swap roles for a week and compare. Keep whichever split catches more real bugs before merge.
What people report
Developers who run both describe different splits, and they don't agree:
- One XDA writer uses Claude Code for UI- and design-heavy work, and Codex for "the patient, unglamorous work of figuring out what's actually broken." He also has each review the other.
- A Towards Data Science author uses Claude Code as the main driver for planning and building, then asks Codex to review the pull request, fixes what Codex finds and repeats until the review passes. He finds Codex more token-efficient and closer to instructions.
Both agree on the shape, though: one builds, the other checks. Which way round matters less than having two different engines on the work.
A simple way to decide
Run a two-week test on your own repository.
- Week one. Claude Code writes, Codex reviews. Keep a list: every real bug the reviewer caught before merge, every false alarm, and every bug that got through to testing or production anyway.
- Week two. Swap. Codex writes, Claude Code reviews. Keep the same list.
- Compare. Count real catches, false alarms and escapes. Also note cost and time per task.
- Pick a default, but keep the other order for the kind of work where it did better.
Roles beyond writer and reviewer
Once both agents are set up, you can give them other roles:
- Planner and builder. One agent writes a plan in plain words. The other builds from it. The planner then checks the result against its own plan.
- Test writer and implementer. One writes the failing tests first. The other writes code until they pass. Neither can quietly change the target.
- Investigator and fixer. One reads logs and reproduces the bug. The other writes the fix.
- Second opinion. For a big decision, ask both the same question separately and compare their answers before you choose.
Every one of these roles needs someone to hand the work over, keep the brief straight and decide when it is done. In the DIY setup, that someone is you.
What does a full day of Claude Code and Codex together look like?
A good day runs in a loop: brief once in AGENTS.md and a task note, let one agent plan and build in its own worktree, have the other agent review read-only, fix and re-check, then merge only after tests pass and a person says yes. Most of the time goes into the hand-offs, so keep them short and written down.
Here is a realistic day for one developer, Sam, fixing a bug where appointment reminder texts go out twice.
9:00. Write the task down once
Sam writes a short task note in the repository, for example tasks/double-reminders.md:
- Goal: each patient gets one reminder text, not two.
- Where it shows up: the reminder job, for clinics in one time zone.
- Done means: a test that fails today and passes after the fix; no change to how reminders are scheduled; review passed.
- Never: don't touch the billing code; don't delete reminder logs.
Both agents will read this file. Sam doesn't explain the bug twice.
9:10. Claude Code plans
Sam starts Claude Code in a new worktree in plan mode, so it reads and proposes but doesn't edit:
claude --worktree fix-double-reminders --permission-mode plan
He asks: "Read tasks/double-reminders.md. Find the cause and propose a fix. Don't edit yet." Claude Code reads the reminder job, finds that a retry runs even when the first send succeeded, and proposes a fix and a test.
9:25. Codex checks the plan
Before any code changes, Sam asks for a second opinion on the plan itself. Inside Claude Code he runs /codex:adversarial-review with a focus such as "Is this the real cause? What else could send twice?" Codex, read-only, points out that a second code path (a manual resend button) could also double-send in the same edge case.
That one catch is the whole reason for running two agents. It took one command.
9:40. Claude Code builds
Sam approves the plan with Codex's addition. Claude Code writes the failing test first, then the fix, runs the test suite and commits on its branch.
10:05. Codex reviews the change
Sam runs /codex:review --base main --background, keeps working on something else, and checks /codex:status a few minutes later. Codex reports one real issue (an error isn't logged) and one false alarm. Sam passes the real one back to Claude Code and ignores the other.
10:20. Fix, re-check, open a pull request
Claude Code fixes the logging and re-runs the tests. Sam runs one more quick Codex review, then asks Claude Code to open a pull request. On GitHub, automatic Codex review runs again on the pull request, and Sam's teammate gets a notification to approve.
10:45. A person says yes
The pull request merges after a human review. Sam deletes the worktree.
What the day cost Sam
The agents did most of the reading, writing and checking. Sam did five things the agents couldn't do for each other:
- Wrote the brief (once, which is good).
- Started each agent and pointed it at the right branch.
- Carried findings from one agent to the other and decided which were real.
- Watched two usage meters.
- Told his teammate the fix was ready, and told the support lead it would ship today.
On a single bug, that is twenty minutes of Sam's time. Across a week of tasks, a team of five, and a support lead who keeps asking "is it fixed yet?", it adds up to a job of its own.
How much does it cost to run Claude Code and Codex together?
Running both means paying for two plans. On the makers' own pricing pages, Claude Code comes with Claude Pro from $20 a month, and Codex with ChatGPT Plus at $20 a month, so a light setup starts around $40 a month per developer. Heavy users pay $100 to $200 on Claude and $100 to $500 on ChatGPT Pro.
Claude Code plans
From Claude's pricing page, checked for this guide:
- Pro: $20 a month, or $17 a month billed yearly. Includes Claude Code.
- Max: $100 a month. Includes Claude Code.
- Ultra: $200 a month. Includes Claude Code.
- Team, standard seat: $25 a seat a month, or $20 billed yearly.
- Team, premium seat: $125 a seat a month, or $100 billed yearly.
- API: pay per token, for scripts, CI and the GitHub Action with an API key.
Claude Code shares usage limits with the rest of your Claude plan.
Codex plans
From OpenAI's Codex pricing page, checked for this guide:
- Free: $0, for quick coding tasks in the desktop app, subject to rollout.
- Go: $8 a month, for lightweight tasks.
- Plus: $20 a month. Codex on the web, CLI, IDE extension and iOS, plus cloud features such as automatic code review and Slack.
- Pro: $100, $200 or $500 a month.
- Business: $20 per user a month billed yearly (two or more users), or $25 monthly.
- Enterprise and Edu: through sales.
- API key: API prices, no cloud features such as GitHub code review.
What a two-agent setup really costs
The subscriptions are the easy part. The hidden costs are:
- Review loops. Every review is a full model run. A loop where Claude Code fixes and Codex re-reviews five times costs five reviews. The Codex plugin's review gate can run this loop on its own; OpenAI's docs warn it can "drain usage limits quickly."
- Duplicated context. Each agent reads your codebase on its own. Two agents means two reads of the same files.
- Two limits to watch. When one runs out mid-task, you either wait or switch, and the switch costs a re-brief.
- No single receipt. Neither tool can tell you what a piece of work cost across both. You add it up by hand, if at all.
- Your time. The biggest cost, and the one that grows with every person you add.
Ways to keep the bill down
- Use the cheapest plan on the reviewing side until you hit its limits.
- Review small diffs, not whole branches, where you can.
- Use the GitHub reviewers (they flag only high-priority issues) instead of full local reviews for routine changes.
- Keep the review gate off unless you're watching.
- Use a smaller, cheaper model for simple reviews. The Codex plugin's /codex:rescue takes a model flag, and Claude Code subagents can each name their own model.
- Put caps on CI runs: Claude Code's docs suggest
--max-turns, workflow timeouts and concurrency limits.
How this compares with an AI office
In Vestra, you pay one plan for the whole team, and every piece of work has a receipt. Plans start at $19 a month for Lite (up to 3 teammates and 2,000 credits a month), then Pro at $97 (20 teammates, 10,000 credits, phone calls), Max at $197 (50 teammates, 20,000 credits) and Ultra at $497 (150 teammates, 50,000 credits). One credit is one cent, the same on every engine, and unused credits roll over. A receipt shows what each teammate spent on each job, whether it ran on Claude Code, Codex or Vestra's own engine. Every new office starts with 1,000 free credits.
What are the most common mistakes, and how do you avoid them?
The common mistakes are letting both agents edit the same files, keeping two instruction files that drift apart, letting review loops run unwatched, trusting a "done" that nobody checked, and giving either agent more access than the task needs. Each one has a simple fix: worktrees, one AGENTS.md, caps, a test or second review, and tight permissions.
Mistake 1: two agents, one folder
What happens: both agents edit the same files, overwrite each other and leave the tests broken.
Fix: one agent per worktree, always. Reviewers read; they don't write.
Mistake 2: two rulebooks that drift
What happens: you keep a CLAUDE.md for Claude Code and an AGENTS.md for Codex, update one and forget the other. A month later the agents follow different rules and you can't tell why their work looks different.
Fix: one AGENTS.md as the source. A CLAUDE.md that imports it with @AGENTS.md, and nothing in the CLAUDE.md that contradicts it.
Mistake 3: the endless review loop
What happens: writer fixes, reviewer objects, writer fixes, reviewer objects. Each round is a full model run. Overnight it burns your limits and leaves you with a branch that has changed twenty times.
Fix: cap the rounds (two is plenty for most changes). Keep the Codex review gate off unless you're watching. Don't let bots trigger each other on GitHub; Claude Code's action blocks bot actors by default for this reason.
Mistake 4: trusting "done"
What happens: an agent says the task is done. It isn't, or it's done but wrong.
Fix: decide what "done" means before the work starts and write it in the task note. Code is done when a test proves it and a second agent or a person has read it. A fact is done when its source checks out.
Mistake 5: too much access
What happens: an agent with broad shell access and your production keys does something you didn't ask for.
Fix: start both tools on their default, careful permissions. Codex's docs say to loosen them "only for trusted repos". Use Claude Code's allow lists and hooks to block what must never run. Keep secrets out of instruction files. Keep a person's yes on anything that deletes, spends or ships.
Mistake 6: forgetting what you learned
What happens: you correct Claude Code about how the payments module works. A week later Codex makes the same mistake, because it never heard the correction.
Fix: when you correct an agent, write the lesson into AGENTS.md (or a doc it links to) so both agents read it next time. Claude Code's auto memory and Codex's memories are separate, and each stays with its own tool.
Mistake 7: one person as the only bridge
What happens: the setup works because one developer knows how to drive it. When they're away, nobody knows which agent did what, or why.
Fix: write the workflow down, keep task notes and review reports in the repository, and make pull requests the place where hand-offs happen. Or move the hand-offs somewhere built for them, which is what section 14 is about.
How do you share memory and context between the two?
In the DIY setup, you share memory through files both agents read: AGENTS.md for standing rules, task notes for the job in hand, and review reports saved in the repository. Each tool's own memory (Claude Code's auto memory, Codex's memories) stays with that tool. So every lesson worth keeping has to be written into a shared file by you.
Three layers of shared context
1. Standing rules: AGENTS.md. Build commands, style, limits, review rules. Changes rarely. Both agents read it at the start of every session.
2. The job in hand: a task note. One short file per task: goal, where the problem shows up, what "done" means, what never to touch. Both agents read it when they pick up the task.
3. What happened: review reports and decision notes. Save each review as a file (codex exec can write its final message to a file with -o), and keep a short decisions file for the choices that matter. The next agent, or the next person, can read what was already tried.
What doesn't cross over
Each tool keeps some memory to itself:
- Claude Code has auto memory, notes Claude writes based on your corrections and preferences. They load in Claude Code, not in Codex.
- Codex keeps its own sessions and settings under ~/.codex, and its subagents work inside one Codex chat.
- Chat history. A long back-and-forth in one tool, with all the reasons behind a decision, never reaches the other.
That's why the files matter. If a lesson isn't in a file both agents read, only one of them knows it.
Handing a session from one tool to the other
The Codex plugin for Claude Code has one direct bridge: /codex:transfer creates a Codex thread from the current Claude Code session and prints a codex resume command. It needs a Codex version that supports session import. There is no official command for the reverse (a Codex session into Claude Code), so for that direction you hand over the task note, the diff and the review file.
Where this breaks down
Files work for one developer. They get harder with a team:
- Who updates AGENTS.md when two people learn different lessons on the same day?
- Where does a lesson from a customer email or a design call go, if it never touches the repository?
- How does a founder or a support lead find out what the agents decided, without reading the git log?
A team needs a memory that fills itself from the work, keeps a source for every line, and is read by every agent before it acts, whichever engine it runs on. That is the next section.
How do you run Claude Code and Codex as teammates instead of tools?
Put them in an AI office. In Vestra, Claude Code and Codex can each run a teammate: one teammate builds on Claude Code, another reviews on Codex, and your chief hands the work between them. Both read the same memory, follow the same rules on spending, deleting and first contact, and every piece of work lands on one receipt.
The difference in one picture
Claude Code and Codex on your laptop: two very good individuals at two desks with a wall between them. Each one works for you, and only for you. You carry everything across the wall.
Claude Code and Codex in Vestra: two teammates in one office, run by a chief that hands the work over, checks it is done and only brings you what needs a decision.
Personal agents like Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes are built for one person and work alone. Vestra is the one office where agents on different engines work together as teammates. That is the whole idea, and Claude Code plus Codex is the cleanest example of it.
What an engine is in Vestra
Every teammate in Vestra has two layers. On top is everything that makes it yours: its job and goals, its skills, the apps it may use, its routines, what it remembers and the rules it works under. Underneath is the engine, the part that does the thinking and the working.
You pick the engine teammate by teammate. Live today, the choices are Vestra's own engine (which works with the top models), Claude Code and Codex. Your chief suggests an engine when it hires a teammate and says why in plain words. You can take the suggestion, pick another, or let your chief choose job by job. Gemini, Grok and Muse also appear in the engine picker; the engines you can run today are the three above.
You can switch a teammate's engine at any time. Its job, goals, skills, apps, routines and memory belong to the teammate, not the engine, so nothing is lost. The next piece of work simply starts on the new engine.
The same bug, the team way
Go back to the double-reminder bug from section 10. Here is how the same job runs in an office, using the example team in Vestra's own guide.
Leo runs engineering. He has a chief, Lobo, and two teammates: Mateo, who builds on Claude Code, and Freya, who reviews code on Codex. When Leo hired Freya, Lobo suggested Codex for code review because "Mateo builds on Claude Code, so a different engine reads his work with fresh eyes."
- Leo says it once. "The Houston reminder texts are going out twice. Fix it, and don't touch billing." Lobo writes the brief: the goal, what done means, and what's off limits.
- Mateo builds, on Claude Code. On its own cloud computer, Mateo reads the code, writes a failing test and the fix.
- Freya reviews, on Codex. Lobo hands Mateo's change to Freya with the same brief. Freya reads every change, runs the tests and asks for one fix. Mateo fixes it. Freya checks again.
- Anything risky waits for Leo. Part of the fix means deleting 3,200 old reminder logs. Deleting always waits for a person, whichever engine the teammate runs on, so Lobo asks Leo: approve or keep them.
- One receipt. Mateo on Claude Code: 142 credits. Freya on Codex: 58 credits. Lobo keeping everyone posted: 9 credits. Total 209 credits, $2.09.
Leo never copied a diff, never pasted context twice and never added up two bills. He made one decision.
What's live today, and what's being built
Vestra is plain about this, and so are we. Here is where things stand.
Live today, for one person and their team of agents:
- A chief and a team of teammates. Hire teammates in a sentence, shape them, give them routines, and get a morning brief.
- Any engine, per teammate. Vestra's own, Claude Code or Codex, picked by you or your chief.
- A cloud computer. Watch your team work in a real browser, and take over any time.
- A memory that learns. A wiki of what your team knows, with a source for every line.
- Connected business tools. More than 2,000 apps, including GitHub, Slack, Gmail and your calendar, connected in a click, with sealed logins.
- Limits, approvals and receipts. Daily and per-task caps, your yes on money, every credit itemised.
- Calls and email from your chief. Its own number and address, with phone calls from Pro up.
- Your chief in the app, Slack, Telegram and email, on the web and in the desktop app for Mac.
So today, one developer can run a Claude Code teammate and a Codex teammate under one chief, with one memory, one set of limits and one receipt.
Building now, the network:
- A chief for every person on a team, named by them.
- Chiefs working together: asking, answering, holding and handing work across.
- The office you can walk around, with every desk showing the engine underneath.
- Spaces: one goal, shared context and decisions for the right person.
- Every hand-off checked and written down, with the proof attached.
- Meetings with agents keeping the notes, access control, and WhatsApp and iMessage.
Then, one at a time: a phone and an inbox for every agent, the vault (a card and sealed logins per agent), shared apps, one shared brain for the whole company and the front door for clients.
Why this beats the DIY setup for a team
One brief instead of two. You tell your chief once. The context travels with the work to every teammate that needs it.
One memory instead of three. In the DIY setup, Claude Code's auto memory, Codex's memories and your AGENTS.md are three places a lesson might live. In Vestra, the memory belongs to the team, every line has a source, and a correction to one teammate reaches the others.
One set of rules on every engine. In Vestra the office rules hold whichever engine a teammate runs on. Spending over the limit, deleting something and contacting someone new always wait for a person. No engine can raise its own limit or approve its own payment.
One receipt. One credit is one cent, the same on every engine. Each piece of work shows which teammate spent what, on which job.
Done means checked. In Vestra, work counts as done only when something other than the teammate that did it has checked it: a test, the source, a second agent or a person. A Claude Code teammate's code reviewed by a Codex teammate is that rule in action. The full proof trail on every hand-off is part of what's being built now.
You don't have to drive it. Nobody has to start each agent, switch branches or carry findings. Your chief does that, and you hear from one agent, not two.
To see what that looks like across a whole business, read What is an AI chief of staff, and what does it actually do? and What is an AI office?.
Should you build the DIY setup or use an AI office?
If you're one developer who wants Codex to review Claude Code's diffs, DIY is enough: one AGENTS.md, worktrees and the Codex plugin. If several people use agents, if non-engineers need to see what the agents did, or if you want one memory, one set of limits and one bill, an AI office does the glue work for you.
Build it yourself if:
- You are one developer, or a very small team that already talks all day.
- The agents only write and review code. Nothing else.
- You're happy to be the one who starts each agent, carries the work and checks it.
- You already pay for both tools and want the cheapest way to combine them.
- You want full control of every flag and file.
Use an AI office if:
- More than one person runs agents, and they need to see each other's work.
- Non-engineers (a founder, support, sales) need answers about what the agents did.
- You want one memory that every agent reads, with a source for every line.
- You want one set of limits and approvals that holds on every engine.
- You want one receipt that shows what each piece of work cost across engines.
- The agents do more than code: research, writing, email, follow-up, books.
- You want to switch an agent's engine without rebuilding it.
You don't have to choose forever
The two aren't exclusive. Plenty of developers will keep Claude Code and Codex on their laptops for hands-on coding and run teammates in an office for the work around the code: reviews, release notes, customer replies, research and the morning brief. If your engineers already work with Claude Code or Codex, their teammates can run on those engines too.
We compared Vestra with each personal agent in turn. See Vestra vs Claude Code, Vestra vs Codex, Vestra vs OpenClaw, Vestra vs Grok Bot, Vestra vs Meta Muse, Vestra vs OpenAI Dot and Vestra vs Perplexity Teammates.
How do you get started today?
Start small. Write one AGENTS.md, give each agent its own worktree, install the Codex plugin in Claude Code and review one real change. Keep a person's yes on every merge. If the hand-offs start eating your day, or more people need in, move the same pair into an AI office as two teammates with a chief.
The DIY checklist
- Install both tools and log in: Claude Code with your Claude plan, Codex with your ChatGPT plan.
- Write AGENTS.md at the repository root. Use Codex's /init to start it, then trim it.
- Point Claude Code at it. Either no CLAUDE.md, or a CLAUDE.md with
@AGENTS.md. - Ask both agents the same three questions about tests, limits and reviews, and check the answers match.
- Create a worktree per agent.
claude --worktree <name>for Claude Code;git worktree addfor Codex. - Install the Codex plugin in Claude Code and run /codex:setup.
- Pick a writer and a reviewer for week one.
- Write a task note for your first real task, with what "done" means.
- Build, review, fix, re-check, with a cap of two review rounds.
- Merge only after tests pass and a person says yes.
- Write every lesson into AGENTS.md, so both agents learn it.
- After two weeks, swap roles and compare.
The team checklist
- Sign up for Vestra and name your chief. Every new office starts with 1,000 free credits.
- Hire a builder in a sentence, for example "I need someone to fix bugs in our app, with tests." Pick Claude Code as its engine, or let your chief suggest one.
- Hire a reviewer on a different engine, such as Codex, for "review every change before it ships."
- Connect GitHub and the tools the job needs, and choose which teammates may use each one.
- Set the rules: what each teammate may do alone, what it asks you first, and the daily and per-task caps.
- Hand over a real bug and read the receipt.
Frequently asked questions
Can Claude Code and Codex work on the same repository?
Yes. Give them one shared AGENTS.md for the rules and a separate git worktree or branch each, so they never edit the same files at once. Merge each branch only after the other agent has reviewed it and the tests pass.
Does Claude Code read AGENTS.md?
Yes, in recent versions. Claude Code's docs say it reads AGENTS.md as your project instructions when there is no CLAUDE.md or CLAUDE.local.md in your working folder or above it. This needs v2.1.277 or later. You can also import it from a CLAUDE.md with the line @AGENTS.md, which works everywhere.
Does Codex read CLAUDE.md?
Not by default. Codex reads AGENTS.md (and AGENTS.override.md). It reads other file names only if you add them to project_doc_fallback_filenames in your Codex config. The simpler fix is to keep your rules in AGENTS.md and have CLAUDE.md import it.
Is there an official way to use Codex inside Claude Code?
Yes. OpenAI publishes a Codex plugin for Claude Code. Install it with /plugin marketplace add openai/codex-plugin-cc, then /plugin install codex@openai-codex, and run /codex:setup. It adds commands such as /codex:review, /codex:adversarial-review and /codex:rescue.
Is there an official Claude plugin for Codex?
We didn't find one in OpenAI's or Anthropic's docs. To have Claude Code review Codex's work, pipe the diff into claude -p, use a read-only reviewer subagent in Claude Code, or mention @claude on the pull request through the Claude Code GitHub Action.
Which is better, Claude Code or Codex?
Neither is better at everything, and developers who use both disagree about which does what best. The useful question is which order works for your code: try one as writer and the other as reviewer for a week, then swap, and count the real bugs each review caught.
Do I need two subscriptions to use both?
Yes, unless you use API keys. Claude Code comes with paid Claude plans from $20 a month (Pro). Codex comes with ChatGPT plans, with Plus at $20 a month for the full CLI, IDE and cloud features. The Codex plugin also accepts an OpenAI API key, and Codex's pricing page says Free plans can use Codex too, with lighter limits.
Will the Codex review gate burn through my limits?
It can. The review gate runs a Codex review every time Claude Code tries to finish, and blocks it until the issues are fixed. OpenAI's docs warn it "can create a long-running Claude/Codex loop and drain usage limits quickly", so turn it on only when you're watching.
Can Claude Code and Codex share memory?
Not directly. Each keeps its own memory. You share context through files both read: AGENTS.md for standing rules, a task note for each job, and saved review reports. In Vestra, teammates on different engines read the same memory, with a source for every line.
Can I run Claude Code and Codex in CI?
Yes. Claude Code runs headless with claude -p and has a GitHub Action that responds to @claude. Codex runs non-interactively with codex exec, which starts read-only, and reviews pull requests on GitHub with @codex review or automatic reviews. Cap turns and timeouts so review loops can't run away.
What is the safest way to let two agents change code?
Keep each agent in its own worktree, start both on their default permissions, keep secrets out of instruction files, let reviewers read but not write, and keep a person's yes on anything that merges, deletes or reaches production.
Can I run Claude Code and Codex as one team?
On your own laptop, not really: they're personal tools that work alone, and you do the hand-offs. In Vestra, Claude Code and Codex can each be the engine under a teammate, and your chief runs them as one team under one set of rules, one memory and one receipt. That's live today for one person's team.
Do I lose anything if I switch a Vestra teammate from Claude Code to Codex?
No. In Vestra a teammate's job, goals, skills, apps, routines and memory belong to the teammate, not the engine. Switch the engine and the next piece of work starts on the new one, with everything the teammate knows.
How much does it cost to run Claude Code and Codex in Vestra?
Vestra plans start at $19 a month. Every plan includes monthly credits, and one credit is one cent, the same on every engine, so a Claude Code teammate and a Codex teammate are paid for from the same balance. Every piece of work has a receipt. New offices start with 1,000 free credits.
Can non-developers use Claude Code and Codex this way?
In the DIY setup, it's hard: you need a terminal, git and both tools' commands. In Vestra you hire a teammate by describing the job in a sentence and connect tools with a click. If you are technical, you can choose exactly which engine each teammate runs on.
What other personal agents work alone like this?
Most of the big ones. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes are each built for one person. See The best AI agents for business and OpenClaw alternatives for businesses for how they compare.
Glossary
Agent. An AI that does work, not just chat: it reads, decides the next step, uses tools and keeps going until the job is done.
Coding agent. An agent built for software work: reading code, editing files, running tests and opening pull requests. Claude Code and Codex are coding agents.
Personal agent. An agent that works for the one person who started it, with its own memory and its own account. It doesn't work with other people's agents.
AGENTS.md. A plain Markdown file of instructions for coding agents, kept in a repository. Codex reads it by default; Claude Code can read it or import it.
CLAUDE.md. Claude Code's own instruction file. It can import other files with @path, including AGENTS.md.
Git worktree. A second (or third) checkout of the same repository in another folder, on its own branch. It lets two agents work at once without touching the same files.
Headless mode. Running an agent without its interactive screen, from a script or CI. In Claude Code this is claude -p; in Codex it is codex exec.
Subagent. A helper an agent starts for a side task, with its own context. Claude Code's subagents run on Claude models; Codex's run inside one Codex chat.
Plugin. An add-on that extends a tool. OpenAI's Codex plugin for Claude Code adds Codex review and hand-off commands to Claude Code.
Review gate. An optional setting in the Codex plugin that runs a Codex review each time Claude Code tries to finish, and blocks it until the issues are fixed.
Adversarial review. A review that deliberately challenges the design: tradeoffs, hidden assumptions and other ways to do it.
MCP (Model Context Protocol). An open standard for connecting agents to outside tools and data. Both Claude Code and Codex can connect to MCP servers.
AI office. One place where people and AI agents on different engines work together as one team, with shared memory, shared rules and a record of the work.
Chief. In Vestra, the agent that runs your other agents, speaks for you and answers only to you.
Teammate. In Vestra, an agent hired for a whole job with goals, running on the engine you pick.
Engine. In Vestra, what a teammate runs on: Vestra's own, Claude Code or Codex today. You can switch it without losing the teammate's job or memory.
Credit. Vestra's unit of cost. One credit is one cent, the same on every engine.
Receipt. In Vestra, the record of what a piece of work cost, which teammate did it and who said yes.
Sources
- Codex plugin for Claude Code, README (OpenAI, openai/codex-plugin-cc)
- How Claude remembers your project: CLAUDE.md and AGENTS.md (Claude Code docs)
- Run Claude Code programmatically (Claude Code docs)
- Common workflows: worktrees, plan mode, subagents (Claude Code docs)
- Create custom subagents (Claude Code docs)
- Claude Code GitHub Actions (Claude Code docs)
- Plans and pricing (Claude)
- Codex best practices (OpenAI)
- Custom instructions with AGENTS.md (Codex docs)
- Non-interactive mode, codex exec (Codex docs)
- Codex in GitHub: code review (Codex docs)
- Model Context Protocol in Codex (Codex docs)
- Codex pricing (OpenAI)
- I use Claude Code and Codex together (XDA Developers)
- How to combine Claude Code and Codex (Towards Data Science)
