When you leave Claude Code running for a long time, tokens pile up alarmingly fast. The cost takes your breath away when you see hundreds of won disappearing on a single query as the context grows longer. This is why junior developers who don't want to give up the convenience of CLI-based autonomous refactoring, yet find Anthropic's bills burdensome, are turning their eyes toward the OpenAI Codex desktop environment.
However, if you switch tools without any precautions, all the project-specific instructions and Model Context Protocol (MCP) server configurations you've built up will be wiped out. If you don't want to waste two or three hours in front of the terminal re-injecting context from scratch, you need to lift and shift your existing assets as they are.
Conversion Script for Migrating MCP Settings to Codex Profiles
Claude Code and OpenAI Codex differ right down to the file formats they use to manage project rules and MCPs. While Claude mainly reads JSON, Codex uses the ~/.codex/config.toml specification. Because the file structures differ, manually copying them down by hand is a surefire way to make typos.
Creating a conversion script in your project root directory and running it handles this process automatically. It saves you the trouble of manually re-entering context.
First, create an mcp-to-codex.js file at the root path of your project and insert the code below. This script restructures the commands, argument arrays, and environment variables specified in the .mcp.json file into the [mcp_servers] block that Codex understands.
`javascript
const fs = require('fs');
const path = require('path');
const sourceMcp = path.join(process.cwd(), '.mcp.json');
if (!fs.existsSync(sourceMcp)) {
console.error('.mcp.json file not found.');
process.exit(1);
}
const claudeMcp = JSON.parse(fs.readFileSync(sourceMcp, 'utf-8'));
const mcpServers = claudeMcp.mcpServers || claudeMcp;
let tomlOutput = '# OpenAI Codex Project MCP Settings\n\n';
for (const [name, config] of Object.entries(mcpServers)) {
tomlOutput += [mcp_servers.${name}]\n;
tomlOutput += command = "${config.command}"\n;
if (config.args && config.args.length > 0) {
tomlOutput += args = ${JSON.stringify(config.args)}\n;
}
if (config.env && Object.keys(config.env).length > 0) {
tomlOutput += [mcp_servers.${name}.env]\n;
for (const [envKey, envVal] of Object.entries(config.env)) {
tomlOutput += ${envKey} = "${envVal}"\n;
}
}
tomlOutput += '\n';
}
const targetDir = path.join(process.cwd(), '.codex');
if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir);
fs.writeFileSync(path.join(targetDir, 'config.toml'), tomlOutput);
console.log('Successfully written settings to .codex/config.toml');
`
Running node mcp-to-codex.js in the terminal outputs the .codex/config.toml file. Next, load this profile in the Codex desktop app or activate it from the command line by entering codex --profile <project-name>, and the settings migration is complete.
There is one point to watch out for here. Prompt directives like @search that were frequently used for file navigation in Claude Code do not work in the Codex engine. Leaving these directives as-is will cause Codex to fail to find paths and output unhelpful answers. You must directly fix @search expressions within your prompts into the relative path format ./path/to/target/ that Codex can recognize to prevent context recognition errors.
Managing API Usage Limits and Blocking Orphaned Processes
Stepping away briefly after commanding an AI agent to fix code is dangerous. This is because an agent encountering an error message could get stuck in an infinite loop on its own, repeating the exact same API request thousands of times. You must prevent the nightmare scenario where hundreds of dollars in prepaid credit melt away in an instant and lock down your entire development environment.
Daily spending costs are determined by the unit price of input and output tokens, along with the discount rate depending on whether input caching is applied. Leaving an agent unattended without control mechanisms will cause your bill to balloon out of control.
Setting spending controls directly on the OpenAI developer portal (platform.openai.com) is the safest approach.
- Log in to the portal, click Settings in the left sidebar, and enter the Limits menu.
- Locate the Usage Limits section.
- Enter
2(dollars) as your maximum daily spending in the Hard Limit field. - Enter
1(dollar) in the Soft Limit field so you can receive warning emails.
Configuring it this way physically blocks token bombs because the OpenAI gateway rejects additional API requests the moment your daily usage hits 2 dollars.
Additionally, turning on Fast mode in the Codex desktop app settings pushes the token emission speed past 1,200 tokens per second. This means tokens are consumed three times faster than usual. Prepaid credits can hit rock bottom within an hour or two even before hitting hard limits, so you must monitor for zombie-like processes lingering in the background.
`bash
ps aux | grep codex
`
Entering this command in the terminal and finding that the agent session you thought you terminated is still holding onto network traffic means you must immediately force-terminate it with the kill -9 <PID> command to prevent cost leakage.
Resolving Port Conflicts and File Ownership Contention
Alternating between two or more AI CLI tools often leads to local port overlaps or fights over file permissions. When the OpenAI Codex agent starts up, it attempts to preempt port 50000 by default for proxy control. Overlapping with local development servers or specific database standard port ranges will crash processes and freeze the shell.
To avoid duplicate port binding issues, you need to cleanly separate environment variables and aliases.
First, specify that proxy ports should be redirected to another safe range when a terminal session opens.
`bash
export CODEX_PORT=8089
`
Next, open the ~/.codex/config.toml file and add port distribution settings. This configuration ensures that even if multiple sessions are running, they split and use ports within the specified range.
`toml
[port_allocation]
range = "8700-8999"
mode = "autonomous"
`
Finally, register aliases for each tool at the bottom of your ~/.bashrc or ~/.zshrc file. This prevents command invocation paths from getting tangled and turning on the wrong engine.
`bash
alias cc="claude"
alias cx="codex"
`
File watcher daemon collisions are just as troublesome as port issues. Both tools attempt to watch the entire project folder to track code changes in real time. If this crawls all the way inside the .git/ folder without filters, the timing of the agent writing code to disk conflicts with Git recording commit info, throwing a .git/index.lock permission error.
In the worst case, commits break or files vanish, so you must create a .codexignore file at the project root and explicitly specify the .git folder and .claude meta directory as exclusion targets for proper version control operation.
Automatically Tracking AI Work History Using Git Hooks
Mixing multiple AI tools makes it impossible to figure out the cause later when builds break. With no way of knowing whether Claude wrote the code or Codex crafted it, humans eventually have to debug by inspecting the code line by line.
Tracking the parent process ID ($PPID) that executed the commit from the operating system process table allows you to tag commit messages with which AI fixed the code.
Leveraging Git's prepare-commit-msg hook makes automating this task convenient.
Open the .git/hooks/prepare-commit-msg file inside your project folder and write the below Bash script. This script traces system processes to find out who executed the commit and attaches a tag to the front of the message.
`bash
#!/bin/bash
COMMIT_MSG_FILE=2
PARENT_PID=(ps -o comm= -p $PARENT_PID 2>/dev/null | xargs)
GRAND_PARENT_PID=$(ps -o ppid= -p GRAND_PARENT_PID" ]; then
GRAND_PARENT_PROCESS=$(ps -o comm= -p $GRAND_PARENT_PID 2>/dev/null | xargs)
fi
AI_TAG=""
if [ "GRAND_PARENT_PROCESS" = "claude" ]; then
AI_TAG="[Claude]"
elif [ "GRAND_PARENT_PROCESS" = "codex" ]; then
AI_TAG="[Codex]"
fi
if [ -n "(head -n 1 "FIRST_LINE" == "[Claude]" ]] && [[ ! "{AI_TAG} /" "COMMIT_MSG_FILE" && rm -f "{COMMIT_MSG_FILE}.bak"
fi
fi
`
After saving the file, grant execution permissions in the terminal.
`bash
chmod +x .git/hooks/prepare-commit-msg
`
Now, junior developers don't have to manually separate commit messages as [Claude] or [Codex] tags are attached to keep history organized.
Taking it a step further, archiving file diff metadata at the time of modification into a log file makes tracking much more precise. Create a .git/hooks/post-commit file that runs right after a commit completes and plant the following code inside.
`bash
#!/bin/bash
LOG_FILE=".ai_history.log"
TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
PARENT_COMM=$(ps -o comm= -p $PPID 2>/dev/null | xargs)
DETERMINED_AGENT="Manual/Unknown"
if [[ "PARENT_COMM" == "codex" ]]; then
DETERMINED_AGENT="OpenAI Codex"
fi
echo "[$TIMESTAMP] Generated by LOG_FILE"
git log -1 --pretty=format:" Commit Hash: %H%n Subject: %s" >> "LOG_FILE"
git diff-tree --no-commit-id --name-status -r HEAD >> "LOG_FILE"
`
Similarly, grant execution permissions with chmod +x .git/hooks/post-commit. Doing this leaves a clean record in the .ai_history.log file of exactly which agent touched which files. It is the only way to control code fragmentation risks that occur during the tool transition transitional phase.
