# Understanding Codex's Reasoning Effort Configuration and Its Impact on Internal Reasoning > Explore Codex reasoning effort configuration, from none to xhigh. Learn how it impacts latency, tokens, and answer quality for deterministic outputs. - Repository: [OpenAI/codex-plugin-cc](https://github.com/openai/codex-plugin-cc) - Tags: internals - Published: 2026-07-14 --- **Codex's reasoning effort configuration controls how much computational "thinking time" the model spends on tasks through six distinct levels—from `none` to `xhigh`—directly impacting latency, token consumption, and answer quality while maintaining deterministic outputs.** The `openai/codex-plugin-cc` repository exposes this **reasoning effort** setting as both a command-line flag and a configuration file option. By adjusting this "thinking budget," developers can explicitly trade processing speed for answer thoroughness on a per-task or project-wide basis. ## What is Reasoning Effort Configuration? The **reasoning effort** setting instructs the underlying Codex model how much additional computational processing to apply before finalizing a response. According to the repository's documentation, this configuration accepts one of six specific string values: - **`none`** – No extra effort; minimal default processing only - **`minimal`** – Small amount of additional reasoning - **`low`** – Light extra effort (default for quick-response scenarios) - **`medium`** – Balanced additional reasoning for interactive use - **`high`** – Stronger reasoning for complex or high-stakes tasks - **`xhigh`** – Maximum effort; the model spends the most time exploring the problem When specified, the plugin forwards this value to the Codex task request, where the app-server adjusts its internal reasoning budget accordingly. ## How Configuration Propagates Through the System The configuration journey begins in **`plugins/codex/scripts/codex-companion.mjs`**, where the `normalizeReasoningEffort` function handles validation and normalization. The plugin accepts effort via two primary channels: 1. **Command-line flag**: `--effort ` 2. **Configuration file**: `model_reasoning_effort` setting in [`config.toml`](https://github.com/openai/codex-plugin-cc/blob/main/config.toml) The `normalizeReasoningEffort` function trims whitespace, converts input to lowercase, and validates against the supported enum. Invalid values raise an explicit error: *"Unsupported reasoning effort …"*. Once validated, the effort value attaches to the task request payload under the `effort` field: ```javascript function buildTaskRequest({ cwd, model, effort, prompt, ... }) { return { cwd, model, effort, // forwarded verbatim to app-server prompt, // …other fields }; } ``` The Codex app-server receives this JSON payload and scales its internal reasoning budget accordingly: ```json { "model": "gpt-5.4-mini", "effort": "high", "prompt": "…" } ``` ## Impact on Internal Reasoning Adjusting the reasoning effort affects three critical aspects of model behavior: ### Resource Allocation Higher effort values cause Codex to allocate more compute cycles—such as longer sampling runs or deeper search trajectories—before producing a response. This typically yields higher-quality, more thorough answers but increases both **latency** and **token usage**. The `medium` level serves as the default sweet spot for most interactive use cases. ### Quality vs. Cost Trade-off The six levels represent distinct operating modes: - **`none`** / **`minimal`** – Fast, cheap execution suitable for simple queries or syntax corrections - **`low`** / **`medium`** – Balanced performance; default for standard development workflows - **`high`** / **`xhigh`** – Exhaustive reasoning useful for tricky bugs, complex design critiques, or when correctness is critical, at the cost of significantly longer runtimes ### Determinism Increasing effort does **not** alter the randomness seed or introduce non-determinism. It only influences how much extra processing the model performs before selecting an output. Repeated runs with identical effort levels and seeds remain deterministic, though higher effort may converge on more optimal completions due to the expanded search space. ## Practical Configuration Methods You can configure reasoning effort through CLI usage or persistent project settings. ### Command-Line Usage Pass the `--effort` flag to any Codex command: ```bash # Explicit medium effort (balanced default) /codex:rescue --model gpt-5.4-mini --effort medium investigate flaky test # Quick, low-effort pass with cheaper model /codex:rescue --model spark --effort low fix the regression # Thorough review with maximum reasoning /codex:review --effort high ``` ### Project-Level Configuration Set a permanent default in [`config.toml`](https://github.com/openai/codex-plugin-cc/blob/main/config.toml) (user- or project-level): ```toml model_reasoning_effort = "high" ``` When omitted, Codex selects its own default based on the selected model and internal heuristics. ## Validation and Error Handling The `normalizeReasoningEffort` function in **`codex-companion.mjs`** ensures type safety and prevents accidental misuse. The implementation strictly validates inputs against the supported enum, rejecting malformed or unsupported values before they reach the app-server. The test suite in **`tests/runtime.test.mjs`** verifies that the effort flag correctly propagates through the entire request pipeline, ensuring the app-server receives the intended configuration. ## Summary - **Six levels** of reasoning effort exist, from `none` (minimal processing) to `xhigh` (maximum exploration) - **Configuration methods** include the `--effort` CLI flag and the `model_reasoning_effort` key in [`config.toml`](https://github.com/openai/codex-plugin-cc/blob/main/config.toml) - **Implementation** resides in `plugins/codex/scripts/codex-companion.mjs` via the `normalizeReasoningEffort` function - **Impact** scales compute allocation directly—higher effort increases latency and token usage but improves answer quality - **Determinism** remains constant regardless of effort level; only the depth of pre-output processing changes ## Frequently Asked Questions ### What are the valid values for Codex reasoning effort configuration? The configuration accepts six specific string values: `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Each represents a distinct level of computational investment, with `medium` serving as the common default for interactive development tasks. ### How do I set a default reasoning effort for all Codex tasks in my project? Create or edit a [`config.toml`](https://github.com/openai/codex-plugin-cc/blob/main/config.toml) file at the project root or user configuration directory and add the line `model_reasoning_effort = "medium"` (or your preferred level). This value automatically applies to all subsequent plugin invocations unless overridden by the `--effort` CLI flag. ### Does higher reasoning effort affect randomness or make outputs non-deterministic? No. The reasoning effort configuration only controls how much processing time the model spends before selecting an output. It does not modify the randomness seed or temperature. Runs with identical seeds and effort levels produce deterministic results, though higher effort may yield different (and potentially more optimal) completions than lower effort due to the expanded search budget. ### Where is the reasoning effort validated in the Codex plugin codebase? Validation occurs in **`plugins/codex/scripts/codex-companion.mjs`** within the `normalizeReasoningEffort` function. This function trims whitespace, converts input to lowercase, and validates against the supported enum, raising an explicit error for invalid values before they propagate to the task request builder.