What makes CodexDelegate notable?

1K downloads. Trust evidence available

How should CodexDelegate be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

CodexDelegate

Delegate coding, repository analysis, file edits, test runs, or code review to the local Codex CLI without embedding an OpenAI API key. This skill was created to work with ChatGPT/Codex enterprise accounts that may not have the same level of API access. Invokes codex exec with existing ChatGPT/Codex CLI authentication and returns Codex's final output.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.0k

Updated

Oct 11, 2026

Version

0.1.3

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1K downloadsadoption · observed Oct 11, 2026
Latest release: 0.1.3release · observed Aug 2, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: medium.

clawhub skill install s175p518b8g47fx6r9zyvs95ks876t4t:agent-codex-delegate

Install using `clawhub skill install s175p518b8g47fx6r9zyvs95ks876t4t:agent-codex-delegate` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/jlacroix82/agent-codex-delegate before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-jlacroix82-agent-codex-delegate/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

49,746 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: codex-delegate
version: 0.1.3
description: Delegate coding, repository analysis, file edits, test runs, or code review to the local Codex CLI without embedding an OpenAI API key. This skill was created to work with ChatGPT/Codex enterprise accounts that may not have the same level of API access. Invokes codex exec with existing ChatGPT/Codex CLI authentication and returns Codex's final output.
license: MIT
metadata: {"openclaw":{"requires":{"bins":["codex"]}}}
---

# Codex Delegate

Use this skill when the user wants OpenClaw to hand a coding or repository task to Codex and receive a result back. It is meant for local, trusted operator setups where `codex` is already installed and signed in.

## Preconditions

- `codex` is installed on `PATH`.
- Codex CLI has already been authenticated by the operator, preferably with ChatGPT sign-in. Do not ask the user for an API key.
- Run inside the target repository or pass `--cwd`.
- OpenClaw must allow this agent to use `exec` for the wrapper script.

If Codex is not authenticated, tell the operator to run `codex` or `codex login` once and complete the ChatGPT browser login. Do not request, print, copy, or inspect `~/.codex/auth.json`.

## Wrapper

Prefer the bundled wrapper:

```bash
{baseDir}/scripts/codex-delegate.sh --cwd /path/to/repo --prompt "summarize the repository and list the riskiest files"
```

For file creation or edits:

```bash
{baseDir}/scripts/codex-delegate.sh \
--cwd /path/to/repo \
--sandbox workspace-write \
--prompt "Create docs/architecture.md explaining the current service layout."
```

For machine-readable event logs while still returning the final Codex answer:

```bash
{baseDir}/scripts/codex-delegate.sh \
--cwd /path/to/repo \
--sandbox workspace-write \
--json-log .openclaw/codex-runs/last.jsonl \
--output .openclaw/codex-runs/last.md \
--prompt "Review the auth changes and fix any failing tests."
```

To pass CLI-style context:

```bash
npm test 2>&1 | {baseDir}/scripts/codex-delegate.sh \
--cwd /path/to/repo \
--sandbox workspace-write \
--prompt "Summarize the failing tests and make the smallest safe fix."
```

Use `--prompt-file path` when a generated prompt is already on disk. Use `--stdin-file path` when another tool wrote context to a file.

## Permissions

This skill requires:
- `exec`: Run the `codex` CLI and the bundled wrapper script
- `fs.read`: Read repository files for analysis
- `fs.write`: Write files when `--sandbox workspace-write` is used

## Scope

This skill is limited to delegating coding and repository tasks to the local Codex CLI.
It does not manage Codex configuration, handle authentication, or perform actions outside the target repository.
All write operations require explicit user confirmation before proceeding.

## Delegation Workflow

1. Restate the exact Codex task in one compact prompt.
2. Choose the narrowest sandbox:
- `read-only` for analysis, review, summaries, planning.
- `workspace-write` for creating o

README.md

# Codex Delegate 🔧

**Delegate coding tasks to the local Codex CLI without embedding API keys.**

## What It Does

Hands OpenClaw to a coding or repository task via the **Codex CLI** — using your existing ChatGPT authentication, not an inline API key.

- Repository analysis, summaries, and risk assessment
- Code generation and multi-file edits
- Test runs and debugging
- Code review and refactoring

## Why This Skill Exists

Embedding an OpenAI API key in agent prompts is a security risk. Codex Delegate solves this by invoking the **local `codex` CLI** which already has your ChatGPT sign-in authenticated. The wrapper script strips all API-key env vars before calling `codex exec`.

## Installation

### Prerequisites

1. **Codex CLI installed and authenticated**
   ```bash
   npm i -g codex
   codex login  # Complete ChatGPT browser sign-in
   ```

2. **OpenClaw** with the skill installed in your workspace

### Install via ClawHub

```bash
clawhub install codex-delegate
```

### Manual Install

```bash
cp -r skills/codex-delegate ~/.openclaw/workspace/skills/
```

## Usage

### Ask Jarvis to use Codex

Just say "use Codex" or "delegate to Codex" for any coding task. I'll handle the rest.

### CLI Usage (direct)

```bash
# Analysis (read-only)
codex-delegate.sh --cwd /path/to/repo --prompt "summarize the repository and list the riskiest files"

# File edits (workspace-write sandbox)
codex-delegate.sh --cwd /path/to/repo --sandbox workspace-write --prompt "Create docs/architecture.md explaining the current service layout."

# Piped context (e.g., test output)
npm test 2>&1 | codex-delegate.sh --cwd /path/to/repo --sandbox workspace-write --prompt "Summarize the failing tests and make the smallest safe fix."

# JSON event logging
codex-delegate.sh --cwd /path/to/repo --sandbox workspace-write \
  --json-log .openclaw/codex-runs/last.jsonl \
  --output .openclaw/codex-runs/last.md \
  --prompt "Review the auth changes and fix any failing tests."
```

## Sandbox Levels

| Sandbox | What it can do | When to use |
|---------|---------------|-------------|
| `read-only` | Read files, analyze, summarize | Always start here |
| `workspace-write` | Create/edit files in the repo | When edits are needed |
| `danger-full-access` | Unrestricted system access | Isolated machines only, with approval |

## Security

- **Never** passes `OPENAI_API_KEY`, `CODEX_API_KEY`, or raw tokens to Codex
- **Never** reads or reveals `~/.codex/auth.json`
- Uses saved Codex CLI authentication (ChatGPT sign-in)
- Do not use in public or untrusted chat channels
- Prefer isolated checkouts or git worktrees for write tasks

## Failure Recovery

| Error | Fix |
|-------|-----|
| `codex: command not found` | Install Codex CLI: `npm i -g codex` |
| Authentication failure | Run `codex login` with ChatGPT sign-in |
| Git repo error | Run inside a git repo, or use `--skip-git-repo-check` |
| Permission error on edits | Retry with `--sandbox workspace-write` |

## License

MIT

_meta.json

{
  "ownerId": "kn7b6eyf5vc7khg5fr63pjm8xd82qvw5",
  "slug": "agent-codex-delegate",
  "version": "0.1.3",
  "publishedAt": 1785700993369
}

CHANGELOG.md

# Changelog

All notable changes to this skill.

## [Unreleased]

### Added
- Initial release of codex-delegate skill
- Wrapper script with sandbox support (read-only, workspace-write, danger-full-access)
- JSON event logging
- Piped stdin support for test output and other context
- Prompt file and stdin-file support
- Ephemeral session mode
- Git repo check bypass
- Comprehensive safety rules (no API key passthrough, no auth.json access)
- Integration with OpenClaw agent routing

skill-card.md

## Description:

Delegates coding, repository analysis, file edits, test runs, and code review tasks to the local Codex CLI using existing Codex CLI authentication rather than embedded API keys.

This skill is ready for commercial/non-commercial use.

## Publisher:

[jlacroix82](https://clawhub.ai/user/jlacroix82)

### License/Terms of Use:

MIT

## Use Case:

Developers and engineering agents use this skill to delegate repository analysis, code changes, test debugging, and code review to a locally authenticated Codex CLI. It is intended for trusted local operator setups where Codex is already installed and signed in.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: The wrapper can invoke powerful Codex execution modes, including workspace-write and danger-full-access.

Mitigation: Default to read-only for analysis, approve write tasks explicitly, and use danger-full-access only in an isolated environment.

Risk: Caller-provided output and JSON log paths may write outside the intended repository.

Mitigation: Keep all output and log paths inside the target repository and inspect resulting diffs before treating a task as complete.

Risk: Repository contents and supplied context are delegated to the local Codex CLI.

Mitigation: Use the skill only when the local Codex CLI on PATH is trusted and the operator has approved the exact data flow.

## Reference(s):

- [ClawHub Skill Page](https://clawhub.ai/jlacroix82/skills/agent-codex-delegate)

## Skill Output:

**Output Type(s):** [text, markdown, code, shell commands, configuration, guidance]

**Output Format:** [Markdown or plain text, with optional code blocks and Codex JSONL logs when requested]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [May write a final Markdown response or JSONL event log to caller-provided paths when those options are used.]

## Skill Version(s):

0.1.3 (source: evidence release, SKILL.md frontmatter, clawhub.yaml)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.