Codex Delegate plugin

A Claude Code skill that hands implementation-heavy work to Codex CLI while Claude keeps planning, review and acceptance.

  • 62 ★ on the repository
  • Last commit
  • MIT
Plugin

Broad access

Why this level

  • Launches Codex CLI, which edits project files and runs commands.
  • Model calls are paid for by the user.
All reasons and checks

wenyuchiou/codex-delegate

Install

Manual install

claude plugin marketplace add WenyuChiou/ai-research-skills

Then `claude plugin install codex-delegate@ai-research-skills`. Codex CLI must be on `PATH`.

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • Launches Codex CLI, which edits project files and runs commands.
  • Model calls are paid for by the user.

This is third-party code. Review the repository files before installing.

What it does

Codex Delegate makes Claude Code a supervisor and Codex CLI an executor. Claude writes a task file with scope and constraints, launches Codex through a wrapper and receives sentinel files and a machine-readable `result.json`. Claude then reviews the diff and runs verification itself: wrapper success is not acceptance. The skill suits tasks that are expensive in tokens and cheap in judgment: multi-file implementation, mechanical refactors, boilerplate, test scaffolding and large batch edits. Architecture, root-cause debugging, security review and ambiguous product decisions stay with Claude. There are bash and PowerShell wrappers with regression tests for both.

Who it is for. Claude Code users who want to save Claude tokens on bulk implementation and hand it to Codex CLI.

Good fit when

  • Dozens of files must be rewritten to one pattern and little judgment is needed.
  • A test scaffold is needed for a finished module.
  • A bulk edit is required with results verified on the Claude side.
  • Work happens on Windows where a PowerShell wrapper is needed.

Not a fit when

  • You need a proper integration plugin with background jobs: the official `codex-plugin-cc` exists for that.
  • The task is about architecture, root cause or security: it stays with Claude.
  • Codex CLI cannot be used or you have no access to it.

Example request

Prepare a task file for renaming a module across all files, hand it to Codex through codex-delegate and review the diff before accepting.

Limitations

Codex CLI must be on `PATH`, installed with `npm install -g @openai/codex`. The wrapper is synchronous: one run, one result, with no job tracking or background processes. The author advises preferring the official OpenAI plugin for a normal integration when its runtime fits, and does not claim better quality or lower cost. Claude always reviews the Codex result against an acceptance checklist, and model calls are paid by you.

How to disable. Run `claude plugin uninstall codex-delegate` or delete the skill folder. Task files and `.ai` logs in the project can be removed by hand.

FAQ

How do I install Codex Delegate?

With `claude plugin marketplace add WenyuChiou/ai-research-skills` and `claude plugin install codex-delegate@ai-research-skills`. The default scope is user, and for one project add `--scope project`.

What else is needed besides the skill?

Codex CLI on `PATH`: `npm install -g @openai/codex`, then check `codex --version`. Account and Codex access are set up with OpenAI.

How is it different from the official plugin?

This is a thin synchronous wrapper: run, `result.json`, exit. The official `codex-plugin-cc` keeps a broker with background jobs and the `/codex:status`, `/codex:result` and `/codex:cancel` commands.

What is `result.json`?

A machine-readable outcome next to the log that Claude uses to decide what to verify. It does not mean acceptance, which Claude gives after reviewing the diff.

Does it work on Windows?

Yes, there is a PowerShell wrapper and regression tests cover bash and PowerShell. The skill needs no Node.js runtime.

Discussion

No questions or reviews yet.

Plugins
Needs a VPN

The /codex-workflows skill: Claude Code writes a script, dozens of Codex agents run it, and the run shows on a map

SkillBroad access330Repository stars

A plugin that syncs Claude Code, Codex CLI and Antigravity on one project and lets them hand work to each other.

PluginBroad access57Repository stars

A Claude Code plugin that hands coding tasks to Codex agents, monitors them and verifies the results independently

PluginBroad access92Repository stars

Claude Code supervises while Codex, opencode and pi work on your quota: delegated edits, independent review, model discussions

PluginBroad access122Repository stars

A skill that links two to four open Codex CLI windows: one splits the work while the others execute, cross-check and deliver.

SkillExtended access105Repository stars

A skill that hands work to a team of a CTO, five PMs and fifty engineers: roles, permissions, a task log and resource leases.

SkillExtended access81Repository stars

README in short

The text describes the skill purpose, a four-step working pattern, a comparison with the official OpenAI plugin, the repository structure, plugin installation and the Codex CLI check.

README badge

Original SKILL.md

---
name: codex-delegate
description: Delegates implementation-heavy or repetitive coding work (batch edits, boilerplate, multi-file refactors with clear patterns, test scaffolding) from Claude to OpenAI Codex CLI. Use when token cost outweighs judgment cost. Trigger phrases include "delegate to codex", "let codex do this", "batch refactor across files", "scaffold tests for". Avoid for architecture, security review, or root-cause debugging.
license: MIT
compatibility: Designed for Claude Code. Marketplace plugins use ${CLAUDE_PLUGIN_ROOT}/scripts/run_codex.sh; direct agentskills.io-compatible installations bundle scripts under <skill-root>/scripts/. Resolve paths for the installed host rather than assuming a user skills directory.
---

# Codex Delegate Skill

Claude is the supervisor. Codex CLI runs the mechanical work. Claude plans, constrains scope, reviews the diff, and verifies outcomes.

## Why use this instead of raw `codex exec`

Use this as a minimal adapter when the supervising workflow needs its legacy
sidecar/sentinel contract and on-disk brief convention. Native `codex exec
--json` already provides machine-readable events, and the official
[`openai/codex-plugin-cc`](https://github.com/openai/codex-plugin-cc) supplies
Claude Code delegation, job tracking, and resume. Prefer those facilities when
they satisfy the workflow; do not build another broker in this wrapper.

| What the wrapper handles | What raw `codex exec` costs you |
|---|---|
| **stdin closure** (`</dev/null`) | A direct caller must close stdin or use the CLI's intended prompt-input mode. A historical session hit a 25-minute zero-byte hang on 2026-05-14. This is not an exclusive wrapper capability. |
| **Legacy `.result.json` / sentinel contract** | A caller using native `--json` events must adapt them if a downstream consumer expects these sidecars. `risks` and `tests_run` remain empty placeholders until supervisor acceptance. |
| **Brief convention** (`references/task-template.md`) | Both direct Codex and the official plugin can receive the same scoped brief. The wrapper validates a brief path; it does not prevent drift or enforce allowed paths. Historical F11/F12 incidents motivate independent scope review. |

No matched live comparison has established superior coding quality or total
model-token savings for this wrapper versus the official plugin. The ratios
below compare delegation with an estimated Claude-inline control, not with
native Codex or the official plugin.

### Token-saving ratios (directional dogfood data — measured treatment, ESTIMATED control)

From a 6-round mixed-workload session (`awesome-agentic-ai-zh` 2026-05-14, see `agent-collab-skills/docs/measured-benefits.md`). Honest methodology note (per that doc's own words): the delegated arm was measured (bytes/3 proxy), the Claude-inline control arm was "estimated, not measured, because we didn't run the control condition" — treat every ratio below as directional, not a precise multiplier. The 17-22× row was additionally produced on the since-retired gemini lane (R4 of that session) and has not been re-measured on Codex.

| Workload | Saving vs Claude-inline | When it applies to you |
|---|---|---|
| **Mechanical sweep × 2 parallel** (e.g., term replacement, § strip, doc renumber) | **~7× token reduction** + caught 4 drift files | Repo with > 20 files needing the same edit |
| **Mirror sync** (zh-TW → zh-Hans + en, 8 files) | **17-22× token reduction** | Multi-locale docs / curricula |
| **Multi-file rename / typed-API migration** | ~3× (extrapolated from Phase D title-sweep) | > 10 files following one pattern |
| **Single-file < 50 line fix** | **~1× (don't bother)** | Use Claude direct Edit |
| **Architecture / debugging / security review** | **1× (skill cannot help)** | Claude direct |

The wrapper helps for **token-heavy mechanical work**. It does not help for judgment-heavy work — be honest about which one your task is.

Report a problem