Back to AI Tools & Agents

codex

AI agentcode analysisrefactoringcode generationOpenAI CodexGPT-5.2CLI toolsoftware engineering
⭐ 2.0kπŸ“„ MITπŸ•’ 2026-03-05Source β†—

Install this skill

npx skills add softaworks/agent-toolkit

Works across Claude Code, Cursor, Codex, Copilot & Antigravity

Codex acts as a specialized terminal interface for the agent-toolkit library, facilitating autonomous software engineering workflows through the GPT-5.2 model family. This skill manages CLI interactions, specifically wrapping 'codex exec' commands to handle sandbox isolation, reasoning effort tuning, and process resumption. By default, it suppresses verbose stderr thinking tokens, ensuring clear interaction while maintaining necessary access control through sandbox tiers like read-only or danger-full-access. It requires specific command orchestration for session state preservation, ensuring that model configuration and task constraints persist across resumes. This agent integration streamlines complex coding tasks by automating CLI flag assembly, verifying environmental requirements, and prompting for user input during critical decision points like high-impact write operations or sandbox configuration.

When to Use This Skill

  • β€’Refactoring existing codebases requiring deep architectural analysis
  • β€’Executing automated bug fixes with restricted filesystem write permissions
  • β€’Performing security audits on repository files in a read-only environment
  • β€’Iterative feature development that requires session state maintenance

How to Invoke This Skill

Example prompts that trigger this skill in Claude Code, Cursor, or Antigravity:

  • β€œRun the refactor using codex
  • β€œContinue the previous codex session with this change
  • β€œStart a new analysis on these files
  • β€œExecute the bug fix using high reasoning effort
  • β€œResume the last codex task

Pro Tips

  • πŸ’‘Always specify the reasoning effort (`xhigh`, `high`, `medium`, `low`) to balance speed and thoroughness, especially for complex or critical coding tasks.
  • πŸ’‘Utilize the `--sandbox` options carefully: `read-only` for analysis, `workspace-write` for modifications, and `danger-full-access` only when absolutely necessary for untrusted or sensitive operations.
  • πŸ’‘For iterative development and continuity, leverage the `resume --last` command to pick up exactly where your AI agent left off, maximizing efficiency without re-entering previous context or configurations.

What this skill does

  • β€’Orchestrates GPT-5.2 reasoning models with adjustable effort levels (xhigh to low)
  • β€’Manages sandbox environments ranging from restricted read-only to danger-full-access
  • β€’Handles session persistence through the resume mechanism for continuous development
  • β€’Automates stdout filtering to suppress internal reasoning metadata from user views
  • β€’Automates flag injection for complex directory-specific operations

When not to use it

  • βœ•Non-coding shell automation tasks that do not benefit from GPT-5.2 context
  • βœ•Scenarios where native CLI tools are already open and require high-frequency manual control

Example workflow

  1. Identify target repository and scope of changes
  2. Select model and reasoning effort based on task complexity
  3. Initialize codex exec with appropriate sandbox settings
  4. Process output while suppressing stderr tokens
  5. Confirm next steps via AskUserQuestion
  6. Resume session using the last-state pipe if further work is required

Prerequisites

  • –Codex CLI v0.57.0 or higher
  • –Active API configuration for GPT-5.2
  • –Git repository environment

Pitfalls & limitations

  • !Failing to suppress stderr manually if the agent forgets to pipe 2>/dev/null
  • !Overriding sandbox restrictions without explicit user authorization
  • !Losing context by starting new sessions instead of utilizing the resume command

FAQ

Why should I use the resume command instead of starting over?
Resuming preserves the configuration, reasoning effort, and session state from your previous interaction, saving time and maintaining context.
What does the xhigh reasoning effort actually do?
It forces the model to perform deeper problem analysis and architectural evaluation, which is ideal for complex refactoring or security-sensitive changes.
Can I see the thinking process of the model?
Yes, by default it is suppressed, but you can request to see stderr or debug tokens if you need to troubleshoot why the agent made a specific decision.
Is the sandbox mode mandatory?
Yes, it is a critical safety feature that ensures your local files are protected according to your defined permissions during execution.

How it compares

Unlike manual CLI usage where flags must be memorized and typed, this skill automates standard compliance for safety and consistency, ensuring the agent always requests permission for high-impact flags.

Source & trust

⭐ 2.0k starsπŸ“„ MITπŸ•’ Updated 2026-03-05
πŸ“„ Full skill instructions β€” original source: softaworks/agent-toolkit
# Codex Skill Guide

## Running a Task
1. Default to gpt-5.2 model. Ask the user (via AskUserQuestion) which reasoning effort to use (xhigh,high, medium, or low). User can override model if needed (see Model Options below).
2. Select the sandbox mode required for the task; default to --sandbox read-only unless edits or network access are necessary.
3. Assemble the command with the appropriate options:
- -m, --model <MODEL>
- --config model_reasoning_effort="<high|medium|low>"
- --sandbox <read-only|workspace-write|danger-full-access>
- --full-auto
- -C, --cd <DIR>
- --skip-git-repo-check
3. Always use --skip-git-repo-check.
4. When continuing a previous session, use codex exec --skip-git-repo-check resume --last via stdin. When resuming don't use any configuration flags unless explicitly requested by the user e.g. if he species the model or the reasoning effort when requesting to resume a session. Resume syntax: echo "your prompt here" | codex exec --skip-git-repo-check resume --last 2>/dev/null. All flags have to be inserted between exec and resume.
5. **IMPORTANT**: By default, append 2>/dev/null to all codex exec commands to suppress thinking tokens (stderr). Only show stderr if the user explicitly requests to see thinking tokens or if debugging is needed.
6. Run the command, capture stdout/stderr (filtered as appropriate), and summarize the outcome for the user.
7. **After Codex completes**, inform the user: "You can resume this Codex session at any time by saying 'codex resume' or asking me to continue with additional analysis or changes."

### Quick Reference
| Use case | Sandbox mode | Key flags |
| --- | --- | --- |
| Read-only review or analysis | read-only | --sandbox read-only 2>/dev/null |
| Apply local edits | workspace-write | --sandbox workspace-write --full-auto 2>/dev/null |
| Permit network or broad access | danger-full-access | --sandbox danger-full-access --full-auto 2>/dev/null |
| Resume recent session | Inherited from original | echo "prompt" \| codex exec --skip-git-repo-check resume --last 2>/dev/null (no flags allowed) |
| Run from another directory | Match task needs | -C <DIR> plus other flags 2>/dev/null |

## Model Options

| Model | Best for | Context window | Key features |
| --- | --- | --- | --- |
| gpt-5.2-max | **Max model**: Ultra-complex reasoning, deep problem analysis | 400K input / 128K output | 76.3% SWE-bench, adaptive reasoning, $1.25/$10.00 |
| gpt-5.2 ⭐ | **Flagship model**: Software engineering, agentic coding workflows | 400K input / 128K output | 76.3% SWE-bench, adaptive reasoning, $1.25/$10.00 |
| gpt-5.2-mini | Cost-efficient coding (4x more usage allowance) | 400K input / 128K output | Near SOTA performance, $0.25/$2.00 |
| gpt-5.1-thinking | Ultra-complex reasoning, deep problem analysis | 400K input / 128K output | Adaptive thinking depth, runs 2x slower on hardest tasks |

**GPT-5.2 Advantages**: 76.3% SWE-bench (vs 72.8% GPT-5), 30% faster on average tasks, better tool handling, reduced hallucinations, improved code quality. Knowledge cutoff: September 30, 2024.

**Reasoning Effort Levels**:
- xhigh - Ultra-complex tasks (deep problem analysis, complex reasoning, deep understanding of the problem)
- high - Complex tasks (refactoring, architecture, security analysis, performance optimization)
- medium - Standard tasks (refactoring, code organization, feature additions, bug fixes)
- low - Simple tasks (quick fixes, simple changes, code formatting, documentation)

**Cached Input Discount**: 90% off ($0.125/M tokens) for repeated context, cache lasts up to 24 hours.

## Following Up
- After every codex command, immediately use AskUserQuestion to confirm next steps, collect clarifications, or decide whether to resume with codex exec resume --last.
- When resuming, pipe the new prompt via stdin: echo "new prompt" | codex exec resume --last 2>/dev/null. The resumed session automatically uses the same model, reasoning effort, and sandbox mode from the original session.
- Restate the chosen model, reasoning effort, and sandbox mode when proposing follow-up actions.

## Error Handling
- Stop and report failures whenever codex --version or a codex exec command exits non-zero; request direction before retrying.
- Before you use high-impact flags (--full-auto, --sandbox danger-full-access, --skip-git-repo-check) ask the user for permission using AskUserQuestion unless it was already given.
- When output includes warnings or partial results, summarize them and ask how to adjust using AskUserQuestion.

## CLI Version

Requires Codex CLI v0.57.0 or later for GPT-5.2 model support. The CLI defaults to gpt-5.2 on macOS/Linux and gpt-5.2 on Windows. Check version: codex --version

Use /model slash command within a Codex session to switch models, or configure default in ~/.codex/config.toml.

How to Use This Skill Unit

Option A: Project-Specific (Recommended)

  1. Click "Download" above
  2. In your project, create the directory: .agent/skills/codex/
  3. Save the file as SKILL.md
  4. The agent will automatically discover the skill based on its description.

Option B: Global Installation (All Agents)

Save the file to these locations to make it available across all projects:

  • Claude Code: ~/.claude/skills/softaworks/agent-toolkit/codex/SKILL.md
  • Cursor: ~/.cursor/skills/softaworks/agent-toolkit/codex/SKILL.md
  • Antigravity: ~/.gemini/antigravity/skills/softaworks/agent-toolkit/codex/SKILL.md

πŸš€ Install with CLI:
npx skills add softaworks/agent-toolkit

Read the Master Guide: Mastering Agent Skills β†’

Recommended Rules

View more rules β†’

Recommended Workflows

View more workflows β†’

Recommended MCP Servers

View more MCP servers β†’

Take It Further

Maximize your productivity with these powerful resources

πŸ“‹

Define Your Standards

Set up coding standards to ensure this workflow produces consistent, high-quality results.

Browse Rules Library
πŸ“–

Master Workflows

Learn how to create custom workflows, use Turbo Mode, and build your automation library.

Complete Guide

How to use this Skill in Claude Code & Cursor

For Claude Code (CLI)

To use this skill in Claude Code, copy the rule content into your project's custom instructions or follow our Add-Skill CLI guide. This ensures Claude follows your standards during every code generation.

For Cursor & Windsurf

For Cursor or Windsurf, individual skills are best used in the "Rules for AI" section. This specific unit helps the agent avoid ai tools & agents issues, leading to cleaner, more efficient code.

Why the skill format matters: the standardized Agent Skills format lets your AI agent load detailed instructions only when they are relevant, keeping your prompt clean while improving results.

Source & attribution

This skill is categorized under AI Tools & Agents and is published by Softaworks, maintained in softaworks/agent-toolkit.

← Browse All Agent Skills
Sponsored AI assistant. Recommendations may be paid.