diff --git a/.forge/skills/test-reasoning/SKILL.md b/.forge/skills/test-reasoning/SKILL.md
new file mode 100644
index 0000000000..248f35ea1e
--- /dev/null
+++ b/.forge/skills/test-reasoning/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: test-reasoning
+description: Validate that reasoning parameters are correctly serialized and sent to provider APIs. Use when the user asks to test reasoning serialization, run reasoning tests, verify reasoning config fields, or check that ReasoningConfig maps correctly to provider-specific JSON (OpenRouter, Anthropic, GitHub Copilot, Codex).
+---
+
+# Test Reasoning Serialization
+
+Validates that `ReasoningConfig` fields are correctly serialized into provider-specific JSON
+for OpenRouter, Anthropic, GitHub Copilot, and Codex.
+
+## Quick Start
+
+Run all tests with the bundled script:
+
+```bash
+./scripts/test-reasoning.sh
+```
+
+The script builds forge in debug mode, runs each provider/model combination, captures the
+outgoing HTTP request body via `FORGE_DEBUG_REQUESTS`, and asserts the correct JSON fields.
+
+## Running a Single Test Manually
+
+```bash
+FORGE_DEBUG_REQUESTS="forge.request.json" \
+FORGE_SESSION__PROVIDER_ID=<provider_id> \
+FORGE_SESSION__MODEL_ID=<model_id> \
+FORGE_REASONING__EFFORT=<effort> \
+target/debug/forge -p "Hello!"
+```
+
+Then inspect `.forge/forge.request.json` for the expected fields.
+
+## Test Coverage
+
+| Provider         | Model                        | Config fields                                     | Expected JSON field               |
+| ---------------- | ---------------------------- | ------------------------------------------------- | --------------------------------- |
+| `open_router`    | `openai/o4-mini`             | `effort: none\|minimal\|low\|medium\|high\|xhigh` | `reasoning.effort`                |
+| `open_router`    | `openai/o4-mini`             | `max_tokens: 4000`                                | `reasoning.max_tokens`            |
+| `open_router`    | `openai/o4-mini`             | `effort: high` + `exclude: true`                  | `reasoning.effort` + `.exclude`   |
+| `open_router`    | `openai/o4-mini`             | `enabled: true`                                   | `reasoning.enabled`               |
+| `open_router`    | `anthropic/claude-opus-4-5`  | `max_tokens: 4000`                                | `reasoning.max_tokens`            |
+| `open_router`    | `moonshotai/kimi-k2`         | `max_tokens: 4000`                                | `reasoning.max_tokens`            |
+| `open_router`    | `moonshotai/kimi-k2`         | `effort: high`                                    | `reasoning.effort`                |
+| `open_router`    | `minimax/minimax-m2`         | `max_tokens: 4000`                                | `reasoning.max_tokens`            |
+| `open_router`    | `minimax/minimax-m2`         | `effort: high`                                    | `reasoning.effort`                |
+| `anthropic`      | `claude-opus-4-6`            | `effort: low\|medium\|high\|max`                  | `output_config.effort`            |
+| `anthropic`      | `claude-3-7-sonnet-20250219` | `enabled: true` + `max_tokens: 8000`              | `thinking.type` + `budget_tokens` |
+| `github_copilot` | `o4-mini`                    | `effort: none\|minimal\|low\|medium\|high\|xhigh` | `reasoning_effort` (top-level)    |
+| `codex`          | `gpt-5.1-codex`              | `effort: none\|minimal\|low\|medium\|high\|xhigh` | `reasoning.effort` + `.summary`   |
+| `codex`          | `gpt-5.1-codex`              | `effort: medium` + `exclude: true`                | `reasoning.summary = "concise"`   |
+| all providers    | one model each               | `effort: invalid`                                 | non-zero exit, no request written |
+
+Tests for unconfigured providers are skipped automatically. Invalid-effort tests run regardless of credentials — the rejection happens at config parse time before any provider interaction.
+
+## References
+
+- [OpenAI Reasoning guide](https://developers.openai.com/api/docs/guides/reasoning)
+- [OpenAI Chat Completions API reference](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
+- [Anthropic Extended Thinking](https://platform.claude.com/docs/en/build-with-claude/effort)
+- [OpenRouter Reasoning Tokens](https://openrouter.ai/docs/guides/best-practices/reasoning-tokens)
diff --git a/.forge/skills/test-reasoning/scripts/test-reasoning.sh b/.forge/skills/test-reasoning/scripts/test-reasoning.sh
new file mode 100755
index 0000000000..2cad7ee712
--- /dev/null
+++ b/.forge/skills/test-reasoning/scripts/test-reasoning.sh
@@ -0,0 +1,423 @@
+#!/usr/bin/env bash
+# scripts/test-reasoning.sh
+#
+# Validates that reasoning parameters are correctly serialized for each
+# provider across all supported effort levels.
+#
+# Usage: ./scripts/test-reasoning.sh
+
+set -uo pipefail
+
+# ─── colors ───────────────────────────────────────────────────────────────────
+
+BOLD='\033[1m'
+RESET='\033[0m'
+GREEN='\033[32m'
+RED='\033[31m'
+YELLOW='\033[33m'
+CYAN='\033[36m'
+DIM='\033[2m'
+
+# ─── state ────────────────────────────────────────────────────────────────────
+
+PASS=0
+FAIL=0
+SKIP=0
+BINARY="target/debug/forge"
+WORK_DIR="$(mktemp -d)"
+SEQ=0
+RESULT_FILES=()
+CURRENT_RF=""
+
+cleanup() { rm -rf "$WORK_DIR"; }
+trap cleanup EXIT
+
+# ─── output helpers ───────────────────────────────────────────────────────────
+# Each helper writes a tagged line to stdout.  Within a background subshell,
+# stdout is redirected to a per-job result file; the main process reads it back
+# after wait to tally counts and emit colour output in the original order.
+
+log_header() { printf "HEADER\t%s\n" "$1"; }
+log_pass()   { printf "PASS\t%s\n"   "$1"; }
+log_fail()   { printf "FAIL\t%s\n"   "$1"; }
+log_skip()   { printf "SKIP\t%s\n"   "$1"; }
+
+# ─── json helpers ─────────────────────────────────────────────────────────────
+
+# json_get <file> <dot.separated.path>
+# Prints the JSON value at the given path, or "null" if absent/null.
+# Uses raw_decode to parse only the first JSON object in the file, which
+# correctly handles both single-document JSON and NDJSON (even when multiple
+# objects appear on the same line without a newline separator).
+json_get() {
+    python3 - "$1" "$2" <<'PY'
+import json, sys
+with open(sys.argv[1]) as f:
+    raw = f.read().strip()
+# raw_decode stops after the first complete JSON value regardless of trailing
+# content (extra objects, newlines, null bytes, etc.).
+decoder = json.JSONDecoder()
+d, _ = decoder.raw_decode(raw)
+keys = sys.argv[2].split('.')
+v = d
+for k in keys:
+    v = v.get(k) if isinstance(v, dict) else None
+    if v is None:
+        break
+print(json.dumps(v))
+PY
+}
+
+# assert_field <file> <dot.path> <expected_json_value> <label>
+assert_field() {
+    local file="$1" path="$2" expected="$3" label="$4"
+    local actual
+    actual="$(json_get "$file" "$path")"
+    if [ "$actual" = "$expected" ]; then
+        log_pass "$label  $path = $expected"
+    else
+        log_fail "$label  $path — expected $expected, got $actual"
+    fi
+}
+
+# ─── test runner ──────────────────────────────────────────────────────────────
+
+# run_test <outfile> <provider_id> <model_id> [KEY=VALUE ...]
+# Runs forge with FORGE_DEBUG_REQUESTS pointing to <outfile>.
+# Extra KEY=VALUE arguments are forwarded as additional env vars.
+# Returns 0 if the request file was written, 1 otherwise (e.g. auth missing).
+run_test() {
+    local out="$1" provider="$2" model="$3"
+    shift 3
+
+    env FORGE_DEBUG_REQUESTS="$out" \
+        FORGE_SESSION__PROVIDER_ID="$provider" \
+        FORGE_SESSION__MODEL_ID="$model" \
+        "$@" \
+        "$BINARY" -p "Hello!" >/dev/null 2>&1 || true
+
+    [ -f "$out" ]
+}
+
+# run_test_expect_failure <outfile> <provider_id> <model_id> [KEY=VALUE ...]
+# Like run_test, but expects forge to exit non-zero and NOT write the request file.
+# Invalid config values (e.g. unknown Effort variant) are rejected at startup,
+# before any provider interaction, so this check is independent of credentials.
+# Returns 0 if forge exited non-zero and wrote no file, 1 otherwise.
+run_test_expect_failure() {
+    local out="$1" provider="$2" model="$3"
+    shift 3
+
+    env FORGE_DEBUG_REQUESTS="$out" \
+        FORGE_SESSION__PROVIDER_ID="$provider" \
+        FORGE_SESSION__MODEL_ID="$model" \
+        "$@" \
+        "$BINARY" -p "Hello!" >/dev/null 2>&1
+    local status=$?
+
+    [ "$status" -ne 0 ] && [ ! -f "$out" ]
+}
+
+# ─── parallel job launcher ────────────────────────────────────────────────────
+
+# next_result_file — allocates the next ordered result file path, appends it to
+# RESULT_FILES, increments SEQ, and stores the path in CURRENT_RF.
+# Must be called in the main process (NOT inside $()) so that RESULT_FILES and
+# SEQ are updated in the parent shell.
+next_result_file() {
+    CURRENT_RF="$WORK_DIR/result-$(printf '%05d' "$SEQ").txt"
+    RESULT_FILES+=("$CURRENT_RF")
+    SEQ=$((SEQ + 1))
+}
+
+# ─── build ────────────────────────────────────────────────────────────────────
+
+printf "${BOLD}Reasoning Serialization Tests${RESET}\n"
+printf "${DIM}Building forge (debug)...${RESET}\n\n"
+if ! cargo build 2>&1 | grep -E "^error|Finished|^   Compiling forge_main"; then
+    printf "${RED}Build failed — aborting.${RESET}\n"
+    exit 1
+fi
+
+# ─── OpenRouter · openai/o4-mini — effort levels ─────────────────────────────
+# OpenRouter passes reasoning.effort straight through.
+# Valid effort values: none · minimal · low · medium · high · xhigh
+# Note: the default forge config sets reasoning.enabled=true; it always appears
+# alongside any explicit effort. max_tokens and exclude remain absent.
+# Ref: https://openrouter.ai/docs/guides/best-practices/reasoning-tokens
+
+for effort in none minimal low medium high xhigh; do
+    next_result_file
+    (
+        log_header "OpenRouter · openai/o4-mini · effort: $effort"
+        OUT="$WORK_DIR/openrouter-openai-effort-$effort.json"
+        if run_test "$OUT" open_router "openai/o4-mini" "FORGE_REASONING__EFFORT=$effort"; then
+            assert_field "$OUT" "reasoning.effort"     "\"$effort\"" "openrouter/openai"
+            assert_field "$OUT" "reasoning.max_tokens" "null"        "openrouter/openai"
+            assert_field "$OUT" "reasoning.exclude"    "null"        "openrouter/openai"
+        else
+            log_skip "open_router not configured — skipping"
+        fi
+    ) > "$CURRENT_RF" &
+done
+
+# ─── OpenRouter · openai/o4-mini — max_tokens ────────────────────────────────
+# When max_tokens is set, reasoning.max_tokens should appear.
+# Note: the default forge config also injects effort="medium" and enabled=true;
+# only max_tokens itself is verified here.
+
+next_result_file
+(
+    log_header "OpenRouter · openai/o4-mini · max_tokens: 4000"
+    OUT="$WORK_DIR/openrouter-openai-max-tokens.json"
+    if run_test "$OUT" open_router "openai/o4-mini" FORGE_REASONING__MAX_TOKENS=4000; then
+        assert_field "$OUT" "reasoning.max_tokens" "4000" "openrouter/openai"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── OpenRouter · openai/o4-mini — exclude ───────────────────────────────────
+# When exclude=true, reasoning runs internally but is omitted from the response.
+
+next_result_file
+(
+    log_header "OpenRouter · openai/o4-mini · effort: high + exclude: true"
+    OUT="$WORK_DIR/openrouter-openai-exclude.json"
+    if run_test "$OUT" open_router "openai/o4-mini" \
+            FORGE_REASONING__EFFORT=high FORGE_REASONING__EXCLUDE=true; then
+        assert_field "$OUT" "reasoning.effort"  '"high"' "openrouter/openai"
+        assert_field "$OUT" "reasoning.exclude" "true"   "openrouter/openai"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── OpenRouter · openai/o4-mini — enabled ───────────────────────────────────
+# enabled=true activates reasoning. The default config already sets enabled=true
+# and effort="medium"; this test confirms enabled is explicitly passed through.
+
+next_result_file
+(
+    log_header "OpenRouter · openai/o4-mini · enabled: true"
+    OUT="$WORK_DIR/openrouter-openai-enabled.json"
+    if run_test "$OUT" open_router "openai/o4-mini" FORGE_REASONING__ENABLED=true; then
+        assert_field "$OUT" "reasoning.enabled" "true" "openrouter/openai"
+        assert_field "$OUT" "reasoning.exclude" "null" "openrouter/openai"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── OpenRouter · anthropic/claude-opus-4-5 — max_tokens ─────────────────────
+# For Anthropic models via OpenRouter, max_tokens maps to budget_tokens.
+# Valid range: integer >= 1024
+# Note: default config injects effort="medium" and enabled=true alongside max_tokens.
+
+next_result_file
+(
+    log_header "OpenRouter · anthropic/claude-opus-4-5 · max_tokens: 4000"
+    OUT="$WORK_DIR/openrouter-anthropic-max-tokens.json"
+    if run_test "$OUT" open_router "anthropic/claude-opus-4-5" FORGE_REASONING__MAX_TOKENS=4000; then
+        assert_field "$OUT" "reasoning.max_tokens" "4000" "openrouter/anthropic"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── OpenRouter · moonshotai/kimi-k2 — max_tokens ────────────────────────────
+# Kimi K2 uses token-budget reasoning via OpenRouter (reasoning.max_tokens).
+# Valid range: integer >= 1024
+
+next_result_file
+(
+    log_header "OpenRouter · moonshotai/kimi-k2 · max_tokens: 4000"
+    OUT="$WORK_DIR/openrouter-kimi-max-tokens.json"
+    if run_test "$OUT" open_router "moonshotai/kimi-k2" FORGE_REASONING__MAX_TOKENS=4000; then
+        assert_field "$OUT" "reasoning.max_tokens" "4000" "openrouter/kimi-k2"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+next_result_file
+(
+    log_header "OpenRouter · moonshotai/kimi-k2 · effort: high"
+    OUT="$WORK_DIR/openrouter-kimi-effort-high.json"
+    if run_test "$OUT" open_router "moonshotai/kimi-k2" FORGE_REASONING__EFFORT=high; then
+        assert_field "$OUT" "reasoning.effort" '"high"' "openrouter/kimi-k2"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── OpenRouter · minimax/minimax-m2 — max_tokens ────────────────────────────
+# MiniMax M2 uses token-budget reasoning via OpenRouter; maps to thinking_budget.
+# Valid range: integer >= 1024
+
+next_result_file
+(
+    log_header "OpenRouter · minimax/minimax-m2 · max_tokens: 4000"
+    OUT="$WORK_DIR/openrouter-minimax-max-tokens.json"
+    if run_test "$OUT" open_router "minimax/minimax-m2" FORGE_REASONING__MAX_TOKENS=4000; then
+        assert_field "$OUT" "reasoning.max_tokens" "4000" "openrouter/minimax-m2"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+next_result_file
+(
+    log_header "OpenRouter · minimax/minimax-m2 · effort: high"
+    OUT="$WORK_DIR/openrouter-minimax-effort-high.json"
+    if run_test "$OUT" open_router "minimax/minimax-m2" FORGE_REASONING__EFFORT=high; then
+        assert_field "$OUT" "reasoning.effort" '"high"' "openrouter/minimax-m2"
+    else
+        log_skip "open_router not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── Anthropic · claude-opus-4-6 — effort levels ─────────────────────────────
+# Newer models use output_config.effort instead of the thinking object.
+# Valid effort values: low · medium · high · max  (max is opus-4-6 only)
+# Ref: https://platform.claude.com/docs/en/build-with-claude/effort
+
+for effort in low medium high max; do
+    next_result_file
+    (
+        log_header "Anthropic · claude-opus-4-6 · effort: $effort"
+        OUT="$WORK_DIR/anthropic-opus46-effort-$effort.json"
+        if run_test "$OUT" anthropic "claude-opus-4-6" "FORGE_REASONING__EFFORT=$effort"; then
+            assert_field "$OUT" "output_config.effort" "\"$effort\"" "anthropic/opus4.6"
+            assert_field "$OUT" "thinking"             "null"        "anthropic/opus4.6"
+        else
+            log_skip "anthropic not configured — skipping"
+        fi
+    ) > "$CURRENT_RF" &
+done
+
+# ─── Anthropic · claude-3-7-sonnet-20250219 — thinking object ────────────────
+# Older models use the thinking object with budget_tokens instead of effort.
+# budget_tokens must be > 1024 and < max_tokens.
+# Ref: https://platform.claude.com/docs/en/build-with-claude/effort
+
+next_result_file
+(
+    log_header "Anthropic · claude-3-7-sonnet-20250219 · enabled: true + max_tokens: 8000"
+    OUT="$WORK_DIR/anthropic-sonnet37-thinking.json"
+    if run_test "$OUT" anthropic "claude-3-7-sonnet-20250219" \
+            FORGE_REASONING__ENABLED=true FORGE_REASONING__MAX_TOKENS=8000; then
+        assert_field "$OUT" "thinking.type"          '"enabled"' "anthropic/sonnet3.7"
+        assert_field "$OUT" "thinking.budget_tokens" "8000"      "anthropic/sonnet3.7"
+        assert_field "$OUT" "output_config"          "null"      "anthropic/sonnet3.7"
+    else
+        log_skip "anthropic not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── GitHub Copilot · o4-mini — effort levels ────────────────────────────────
+# Chat Completions API serializes reasoning as a top-level reasoning_effort string.
+# Valid effort values: none · minimal · low · medium · high · xhigh
+# Ref: https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create
+
+for effort in none minimal low medium high xhigh; do
+    next_result_file
+    (
+        log_header "GitHub Copilot · o4-mini · effort: $effort"
+        OUT="$WORK_DIR/github-copilot-effort-$effort.json"
+        if run_test "$OUT" github_copilot "o4-mini" "FORGE_REASONING__EFFORT=$effort"; then
+            assert_field "$OUT" "reasoning_effort" "\"$effort\"" "github_copilot/o4-mini"
+            assert_field "$OUT" "reasoning"        "null"        "github_copilot/o4-mini"
+        else
+            log_skip "github_copilot not configured — skipping"
+        fi
+    ) > "$CURRENT_RF" &
+done
+
+# ─── Codex · gpt-5.1-codex — effort levels ───────────────────────────────────
+# Responses API uses a nested reasoning object with effort + summary fields.
+# Each effort value is passed through as-is; summary defaults to "auto".
+# Ref: https://developers.openai.com/api/docs/guides/reasoning
+
+for effort in none minimal low medium high xhigh; do
+    next_result_file
+    (
+        log_header "Codex · gpt-5.1-codex · effort: $effort"
+        OUT="$WORK_DIR/codex-effort-$effort.json"
+        if run_test "$OUT" codex "gpt-5.1-codex" "FORGE_REASONING__EFFORT=$effort"; then
+            assert_field "$OUT" "reasoning.effort"  "\"$effort\""  "codex/gpt-5.1-codex"
+            assert_field "$OUT" "reasoning.summary" '"auto"'       "codex/gpt-5.1-codex"
+            assert_field "$OUT" "reasoning_effort"  "null"         "codex/gpt-5.1-codex"
+        else
+            log_skip "codex not configured — skipping"
+        fi
+    ) > "$CURRENT_RF" &
+done
+
+# ─── Codex · gpt-5.1-codex — exclude ────────────────────────────────────────
+# When exclude=true the effort is passed through unchanged and summary="concise".
+
+next_result_file
+(
+    log_header "Codex · gpt-5.1-codex · effort: medium + exclude: true"
+    OUT="$WORK_DIR/codex-exclude.json"
+    if run_test "$OUT" codex "gpt-5.1-codex" \
+            FORGE_REASONING__EFFORT=medium FORGE_REASONING__EXCLUDE=true; then
+        assert_field "$OUT" "reasoning.effort"  '"medium"'    "codex/gpt-5.1-codex"
+        assert_field "$OUT" "reasoning.summary" '"concise"'   "codex/gpt-5.1-codex"
+    else
+        log_skip "codex not configured — skipping"
+    fi
+) > "$CURRENT_RF" &
+
+# ─── Invalid effort — config parse error (one per provider) ──────────────────
+# "invalid" is not a recognised Effort variant. Forge must reject it at config
+# parse time, exit non-zero, and never write a debug request file.
+# This check runs regardless of provider credentials.
+
+next_result_file
+(
+    log_header "Invalid effort · config parse error"
+    for entry in \
+        "open_router:openai/o4-mini" \
+        "anthropic:claude-opus-4-6" \
+        "github_copilot:o4-mini" \
+        "codex:gpt-5.1-codex"
+    do
+        provider="${entry%%:*}"
+        model="${entry##*:}"
+        OUT="$WORK_DIR/invalid-effort-${provider}.json"
+        if run_test_expect_failure "$OUT" "$provider" "$model" FORGE_REASONING__EFFORT=invalid; then
+            log_pass "$provider/$model  invalid effort → non-zero exit, no request written"
+        else
+            log_fail "$provider/$model  invalid effort was not rejected"
+        fi
+    done
+) > "$CURRENT_RF" &
+
+# ─── collect results ──────────────────────────────────────────────────────────
+
+wait  # wait for all background jobs to finish
+
+for f in "${RESULT_FILES[@]}"; do
+    [ -f "$f" ] || continue
+    while IFS=$'\t' read -r type msg; do
+        case "$type" in
+            HEADER) printf "\n${BOLD}${CYAN}▶  %s${RESET}\n" "$msg" ;;
+            PASS)   printf "  ${GREEN}✓${RESET}  %s\n" "$msg"; PASS=$((PASS + 1)) ;;
+            FAIL)   printf "  ${RED}✗${RESET}  %s\n" "$msg"; FAIL=$((FAIL + 1)) ;;
+            SKIP)   printf "  ${YELLOW}~${RESET}  %s\n" "$msg"; SKIP=$((SKIP + 1)) ;;
+        esac
+    done < "$f"
+done
+
+# ─── summary ──────────────────────────────────────────────────────────────────
+
+printf "\n${BOLD}─────────────────────────────────────────${RESET}\n"
+printf "${BOLD}Results:${RESET}  "
+printf "${GREEN}%d passed${RESET}  " "$PASS"
+[ "$FAIL" -gt 0 ] && printf "${RED}%d failed${RESET}  " "$FAIL" \
+                  || printf "${DIM}%d failed${RESET}  " "$FAIL"
+printf "${YELLOW}%d skipped${RESET}\n\n" "$SKIP"
+
+[ "$FAIL" -eq 0 ]
diff --git a/Cargo.lock b/Cargo.lock
index a8f0376ec9..afab7b0401 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1950,6 +1950,7 @@ dependencies = [
  "schemars 1.2.1",
  "serde",
  "serde_json",
+ "strum_macros 0.28.0",
  "thiserror 2.0.18",
  "tokio",
  "toml_edit",
diff --git a/crates/forge_api/src/api.rs b/crates/forge_api/src/api.rs
index e2a9e7773f..b13863b0b2 100644
--- a/crates/forge_api/src/api.rs
+++ b/crates/forge_api/src/api.rs
@@ -4,7 +4,7 @@ use anyhow::Result;
 use forge_app::dto::ToolsOverview;
 use forge_app::{User, UserUsage};
 use forge_config::ForgeConfig;
-use forge_domain::{AgentId, ModelId, ProviderModels};
+use forge_domain::{AgentId, Effort, ModelId, ProviderModels};
 use forge_stream::MpscStream;
 use futures::stream::BoxStream;
 use url::Url;
@@ -166,6 +166,12 @@ pub trait API: Sync + Send {
     /// suggestion generation).
     async fn set_suggest_config(&self, config: forge_domain::SuggestConfig) -> anyhow::Result<()>;
 
+    /// Gets the current reasoning effort setting.
+    async fn get_reasoning_effort(&self) -> anyhow::Result<Option<Effort>>;
+
+    /// Sets the reasoning effort level applied to all agents.
+    async fn set_reasoning_effort(&self, effort: Effort) -> anyhow::Result<()>;
+
     /// Refresh MCP caches by fetching fresh data
     async fn reload_mcp(&self) -> Result<()>;
 
diff --git a/crates/forge_api/src/forge_api.rs b/crates/forge_api/src/forge_api.rs
index ac0b9edf98..36df08a4c4 100644
--- a/crates/forge_api/src/forge_api.rs
+++ b/crates/forge_api/src/forge_api.rs
@@ -294,6 +294,14 @@ impl<A: Services, F: CommandInfra + EnvironmentInfra + SkillRepository + GrpcInf
         self.services.set_suggest_config(config).await
     }
 
+    async fn get_reasoning_effort(&self) -> anyhow::Result<Option<Effort>> {
+        self.services.get_reasoning_effort().await
+    }
+
+    async fn set_reasoning_effort(&self, effort: Effort) -> anyhow::Result<()> {
+        self.services.set_reasoning_effort(effort).await
+    }
+
     async fn reload_mcp(&self) -> Result<()> {
         self.services.mcp_service().reload_mcp().await
     }
diff --git a/crates/forge_app/src/agent.rs b/crates/forge_app/src/agent.rs
index 39bd10b78a..30ce87198a 100644
--- a/crates/forge_app/src/agent.rs
+++ b/crates/forge_app/src/agent.rs
@@ -2,8 +2,9 @@ use std::sync::Arc;
 
 use forge_config::ForgeConfig;
 use forge_domain::{
-    Agent, ChatCompletionMessage, Compact, Context, Conversation, MaxTokens, ModelId, ProviderId,
-    ResultStream, Temperature, ToolCallContext, ToolCallFull, ToolResult, TopK, TopP,
+    Agent, ChatCompletionMessage, Compact, Context, Conversation, Effort, MaxTokens, ModelId,
+    ProviderId, ReasoningConfig, ResultStream, Temperature, ToolCallContext, ToolCallFull,
+    ToolResult, TopK, TopP,
 };
 use merge::Merge;
 
@@ -142,6 +143,94 @@ impl AgentExt for Agent {
             agent.compact = merged_compact;
         }
 
+        // Apply workflow reasoning configuration to agents.
+        // Agent-level fields take priority; config fills in any unset fields.
+        if let Some(ref config_reasoning) = config.reasoning {
+            use forge_config::Effort as ConfigEffort;
+            let config_as_domain = ReasoningConfig {
+                effort: config_reasoning.effort.as_ref().map(|e| match e {
+                    ConfigEffort::None => Effort::None,
+                    ConfigEffort::Minimal => Effort::Minimal,
+                    ConfigEffort::Low => Effort::Low,
+                    ConfigEffort::Medium => Effort::Medium,
+                    ConfigEffort::High => Effort::High,
+                    ConfigEffort::XHigh => Effort::XHigh,
+                    ConfigEffort::Max => Effort::Max,
+                }),
+                max_tokens: config_reasoning.max_tokens,
+                exclude: config_reasoning.exclude,
+                enabled: config_reasoning.enabled,
+            };
+            // Start from the agent's own settings and fill unset fields from config.
+            let mut merged = agent.reasoning.clone().unwrap_or_default();
+            merged.merge(config_as_domain);
+            agent.reasoning = Some(merged);
+        }
+
         agent
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use forge_config::{Effort as ConfigEffort, ReasoningConfig as ConfigReasoningConfig};
+    use forge_domain::{AgentId, Effort, ModelId, ProviderId, ReasoningConfig};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    fn fixture_agent() -> Agent {
+        Agent::new(
+            AgentId::new("test"),
+            ProviderId::ANTHROPIC,
+            ModelId::new("claude-3-5-sonnet-20241022"),
+        )
+    }
+
+    /// When the agent has no reasoning config, the config's reasoning is
+    /// applied in full.
+    #[test]
+    fn test_reasoning_applied_from_config_when_agent_has_none() {
+        let config = ForgeConfig::default().reasoning(
+            ConfigReasoningConfig::default()
+                .enabled(true)
+                .effort(ConfigEffort::Medium),
+        );
+
+        let actual = fixture_agent().apply_config(&config).reasoning;
+
+        let expected = Some(
+            ReasoningConfig::default()
+                .enabled(true)
+                .effort(Effort::Medium),
+        );
+
+        assert_eq!(actual, expected);
+    }
+
+    /// When the agent already has reasoning fields set, those fields take
+    /// priority; config only fills in fields the agent left unset.
+    #[test]
+    fn test_reasoning_agent_fields_take_priority_over_config() {
+        let config = ForgeConfig::default().reasoning(
+            ConfigReasoningConfig::default()
+                .enabled(true)
+                .effort(ConfigEffort::Low)
+                .max_tokens(1024_usize),
+        );
+
+        // Agent overrides effort but leaves enabled and max_tokens unset.
+        let agent = fixture_agent().reasoning(ReasoningConfig::default().effort(Effort::High));
+
+        let actual = agent.apply_config(&config).reasoning;
+
+        let expected = Some(
+            ReasoningConfig::default()
+                .effort(Effort::High) // agent's value wins
+                .enabled(true) // filled in from config
+                .max_tokens(1024_usize), // filled in from config
+        );
+
+        assert_eq!(actual, expected);
+    }
+}
diff --git a/crates/forge_app/src/command_generator.rs b/crates/forge_app/src/command_generator.rs
index abf4b91c88..837db4d7c0 100644
--- a/crates/forge_app/src/command_generator.rs
+++ b/crates/forge_app/src/command_generator.rs
@@ -288,6 +288,14 @@ mod tests {
         async fn set_suggest_config(&self, _config: forge_domain::SuggestConfig) -> Result<()> {
             Ok(())
         }
+
+        async fn get_reasoning_effort(&self) -> Result<Option<forge_domain::Effort>> {
+            Ok(None)
+        }
+
+        async fn set_reasoning_effort(&self, _effort: forge_domain::Effort) -> Result<()> {
+            Ok(())
+        }
     }
 
     #[tokio::test]
diff --git a/crates/forge_app/src/dto/anthropic/request.rs b/crates/forge_app/src/dto/anthropic/request.rs
index 293a57961b..f6c34c6f7c 100644
--- a/crates/forge_app/src/dto/anthropic/request.rs
+++ b/crates/forge_app/src/dto/anthropic/request.rs
@@ -30,6 +30,8 @@ pub struct Request {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub thinking: Option<Thinking>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_config: Option<OutputConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub output_format: Option<OutputFormat>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub anthropic_version: Option<String>,
@@ -64,6 +66,26 @@ pub struct Thinking {
     pub budget_tokens: u64,
 }
 
+/// Effort level for Anthropic's `output_config` API.
+///
+/// Only the variants officially supported by Anthropic's `output_config.effort`
+/// field. Mutually exclusive with the `thinking` object.
+#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum OutputEffort {
+    Low,
+    Medium,
+    High,
+    Max,
+}
+
+/// Output configuration for newer Anthropic models that support effort-based
+/// reasoning (e.g. `claude-opus-4-6`).  Mutually exclusive with `thinking`.
+#[derive(Serialize, Debug, PartialEq, Eq)]
+pub struct OutputConfig {
+    pub effort: OutputEffort,
+}
+
 #[derive(Serialize, Debug, PartialEq)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum OutputFormat {
@@ -97,6 +119,59 @@ impl TryFrom<forge_domain::Context> for Request {
             })
             .collect::<Vec<_>>();
 
+        // Route reasoning config to the correct Anthropic serialization.
+        // All paths require enabled == Some(true); without it nothing is emitted.
+        //
+        // • enabled + max_tokens → thinking object (older models, e.g.
+        // claude-3-7-sonnet).   An explicit reasoning budget unambiguously
+        // selects the extended-thinking API.   effort (which may arrive from
+        // embedded defaults) is ignored in this branch.
+        //
+        // • enabled + effort, no max_tokens → output_config.effort (newer models, e.g.
+        //   claude-opus-4-6).  No token budget means the caller chose the effort-based
+        // API.
+        //
+        // • enabled only (no effort, no max_tokens) → thinking with a default budget.
+        let (thinking, output_config) = if let Some(reasoning) = request.reasoning {
+            if reasoning.enabled == Some(true) {
+                if let Some(budget) = reasoning.max_tokens {
+                    // Explicit budget → thinking object regardless of effort.
+                    (
+                        Some(Thinking {
+                            r#type: ThinkingType::Enabled,
+                            budget_tokens: budget as u64,
+                        }),
+                        None,
+                    )
+                } else if let Some(effort) = reasoning.effort {
+                    // Effort without budget → newer output_config API.
+                    let output_effort = match effort {
+                        forge_domain::Effort::Low => OutputEffort::Low,
+                        forge_domain::Effort::High => OutputEffort::High,
+                        forge_domain::Effort::Max => OutputEffort::Max,
+                        // Map unsupported variants to the nearest Anthropic-valid effort.
+                        forge_domain::Effort::None | forge_domain::Effort::Minimal => {
+                            OutputEffort::Low
+                        }
+                        forge_domain::Effort::Medium => OutputEffort::Medium,
+                        forge_domain::Effort::XHigh => OutputEffort::Max,
+                    };
+                    (None, Some(OutputConfig { effort: output_effort }))
+                } else {
+                    // Enabled-only → thinking with default budget.
+                    (
+                        Some(Thinking { r#type: ThinkingType::Enabled, budget_tokens: 10000 }),
+                        None,
+                    )
+                }
+            } else {
+                // enabled=false or enabled=None → no reasoning emitted.
+                (None, None)
+            }
+        } else {
+            (None, None)
+        };
+
         Ok(Self {
             messages: request
                 .messages
@@ -115,18 +190,8 @@ impl TryFrom<forge_domain::Context> for Request {
             top_k: request.top_k.map(|t| t.value() as u64),
             tool_choice: request.tool_choice.map(ToolChoice::from),
             stream: Some(request.stream.unwrap_or(true)),
-            thinking: request.reasoning.and_then(|reasoning| {
-                reasoning.enabled.and_then(|enabled| {
-                    if enabled {
-                        Some(Thinking {
-                            r#type: ThinkingType::Enabled,
-                            budget_tokens: reasoning.max_tokens.unwrap_or(10000) as u64,
-                        })
-                    } else {
-                        None
-                    }
-                })
-            }),
+            thinking,
+            output_config,
             output_format: request.response_format.and_then(|rf| match rf {
                 forge_domain::ResponseFormat::Text => {
                     // Anthropic doesn't have a "text" output format, so we skip it
@@ -519,6 +584,46 @@ mod tests {
             actual.thinking,
             Some(Thinking { r#type: ThinkingType::Enabled, budget_tokens: 8000 })
         );
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_max_tokens_takes_priority_over_effort() {
+        // When both max_tokens and effort are set, max_tokens triggers the thinking
+        // path because an explicit budget means the caller wants the older API.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::Low),
+            enabled: Some(true),
+            max_tokens: Some(8000),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking { r#type: ThinkingType::Enabled, budget_tokens: 8000 })
+        );
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_effort_without_budget_creates_output_config() {
+        // Effort with no max_tokens routes to output_config (newer model path).
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::Low),
+            enabled: Some(true),
+            max_tokens: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.output_config,
+            Some(OutputConfig { effort: OutputEffort::Low })
+        );
+        assert_eq!(actual.thinking, None);
     }
 
     #[test]
diff --git a/crates/forge_app/src/dto/openai/transformers/pipeline.rs b/crates/forge_app/src/dto/openai/transformers/pipeline.rs
index f119ae03a0..7b1c309c0e 100644
--- a/crates/forge_app/src/dto/openai/transformers/pipeline.rs
+++ b/crates/forge_app/src/dto/openai/transformers/pipeline.rs
@@ -54,8 +54,9 @@ impl Transformer for ProviderPipeline<'_> {
 
         let open_ai_compat = MakeOpenAiCompat.when(move |_| !supports_open_router_params(provider));
 
-        let set_reasoning_effort =
-            SetReasoningEffort.when(move |_| provider.id == ProviderId::REQUESTY);
+        let set_reasoning_effort = SetReasoningEffort.when(move |_| {
+            provider.id == ProviderId::REQUESTY || provider.id == ProviderId::GITHUB_COPILOT
+        });
 
         let github_copilot_reasoning =
             GitHubCopilotReasoning.when(move |_| provider.id == ProviderId::GITHUB_COPILOT);
diff --git a/crates/forge_app/src/dto/openai/transformers/set_reasoning_effort.rs b/crates/forge_app/src/dto/openai/transformers/set_reasoning_effort.rs
index d6f2a959ba..8cef9f7659 100644
--- a/crates/forge_app/src/dto/openai/transformers/set_reasoning_effort.rs
+++ b/crates/forge_app/src/dto/openai/transformers/set_reasoning_effort.rs
@@ -11,19 +11,15 @@ use crate::dto::openai::Request;
 /// # Transformation Rules
 ///
 /// - If `reasoning.enabled == Some(false)` → use "none" (disables reasoning)
-/// - If `reasoning.effort` is set (low/medium/high) → use that value
-/// - If `reasoning.max_tokens` is set (thinking budget) → convert to effort:
-///   - 0-1024 → "low"
-///   - 1025-8192 → "medium"
-///   - 8193+ → "high"
-/// - If `reasoning.enabled == Some(true)` but no other params → default to
-///   "medium"
+/// - If `reasoning.effort` is set → use that value directly
+/// - If `reasoning.enabled == Some(true)` but no effort → default to "medium"
 /// - Original `reasoning` field is removed after transformation
 ///
 /// # Note
 ///
-/// OpenAI-compatible APIs support: "low", "medium", "high", "max", "min",
-/// "none", or a budget number.
+/// Budget (`max_tokens`) is not converted to an effort level — effort and token
+/// budget are independent concerns.  Pass `effort` explicitly to control
+/// reasoning quality.
 pub struct SetReasoningEffort;
 
 impl Transformer for SetReasoningEffort {
@@ -38,12 +34,8 @@ impl Transformer for SetReasoningEffort {
             } else if let Some(effort) = reasoning.effort {
                 // Use the effort value directly
                 Some(effort.to_string())
-            } else if let Some(budget) = reasoning.max_tokens {
-                // Convert budget to effort using the From implementation
-                let effort: Effort = budget.into();
-                Some(effort.to_string())
             } else if reasoning.enabled == Some(true) {
-                // Default to "medium" if enabled but no effort or budget specified
+                // Default to "medium" if enabled but no effort specified
                 Some(Effort::Medium.to_string())
             } else {
                 None
@@ -172,7 +164,9 @@ mod tests {
     }
 
     #[test]
-    fn test_reasoning_with_budget_low() {
+    fn test_reasoning_with_budget_defaults_to_medium_effort() {
+        // max_tokens (budget) is independent from effort; when only budget is
+        // set and enabled=true, the transformer falls back to the default effort.
         let fixture = Request::default().reasoning(ReasoningConfig {
             enabled: Some(true),
             effort: None,
@@ -183,28 +177,13 @@ mod tests {
         let mut transformer = SetReasoningEffort;
         let actual = transformer.transform(fixture);
 
-        assert_eq!(actual.reasoning_effort, Some("low".to_string()));
-        assert_eq!(actual.reasoning, None);
-    }
-
-    #[test]
-    fn test_reasoning_with_budget_medium() {
-        let fixture = Request::default().reasoning(ReasoningConfig {
-            enabled: Some(true),
-            effort: None,
-            max_tokens: Some(5000),
-            exclude: None,
-        });
-
-        let mut transformer = SetReasoningEffort;
-        let actual = transformer.transform(fixture);
-
         assert_eq!(actual.reasoning_effort, Some("medium".to_string()));
         assert_eq!(actual.reasoning, None);
     }
 
     #[test]
-    fn test_reasoning_with_budget_high() {
+    fn test_reasoning_with_budget_high_defaults_to_medium_effort() {
+        // Even a large budget does not elevate the effort; use explicit effort instead.
         let fixture = Request::default().reasoning(ReasoningConfig {
             enabled: Some(true),
             effort: None,
@@ -215,7 +194,7 @@ mod tests {
         let mut transformer = SetReasoningEffort;
         let actual = transformer.transform(fixture);
 
-        assert_eq!(actual.reasoning_effort, Some("high".to_string()));
+        assert_eq!(actual.reasoning_effort, Some("medium".to_string()));
         assert_eq!(actual.reasoning, None);
     }
 
diff --git a/crates/forge_app/src/services.rs b/crates/forge_app/src/services.rs
index c11b4fafe4..9cf7a12c89 100644
--- a/crates/forge_app/src/services.rs
+++ b/crates/forge_app/src/services.rs
@@ -226,6 +226,12 @@ pub trait AppConfigService: Send + Sync {
     /// Sets the suggest configuration (provider and model for command
     /// suggestion generation).
     async fn set_suggest_config(&self, config: forge_domain::SuggestConfig) -> anyhow::Result<()>;
+
+    /// Gets the current reasoning effort setting.
+    async fn get_reasoning_effort(&self) -> anyhow::Result<Option<forge_domain::Effort>>;
+
+    /// Sets the reasoning effort level applied to all agents.
+    async fn set_reasoning_effort(&self, effort: forge_domain::Effort) -> anyhow::Result<()>;
 }
 
 #[async_trait::async_trait]
@@ -984,6 +990,14 @@ impl<I: Services> AppConfigService for I {
     async fn set_suggest_config(&self, config: forge_domain::SuggestConfig) -> anyhow::Result<()> {
         self.config_service().set_suggest_config(config).await
     }
+
+    async fn get_reasoning_effort(&self) -> anyhow::Result<Option<forge_domain::Effort>> {
+        self.config_service().get_reasoning_effort().await
+    }
+
+    async fn set_reasoning_effort(&self, effort: forge_domain::Effort) -> anyhow::Result<()> {
+        self.config_service().set_reasoning_effort(effort).await
+    }
 }
 
 #[async_trait::async_trait]
diff --git a/crates/forge_config/.forge.toml b/crates/forge_config/.forge.toml
index fa2331e690..e0e4268789 100644
--- a/crates/forge_config/.forge.toml
+++ b/crates/forge_config/.forge.toml
@@ -59,3 +59,7 @@ token_threshold = 100000
 [updates]
 auto_update = true
 frequency = "daily"
+
+[reasoning]
+enabled = true
+effort = "high"
diff --git a/crates/forge_config/Cargo.toml b/crates/forge_config/Cargo.toml
index 038d12f524..96c58b829a 100644
--- a/crates/forge_config/Cargo.toml
+++ b/crates/forge_config/Cargo.toml
@@ -16,6 +16,7 @@ toml_edit = { workspace = true }
 url.workspace = true
 fake = { version = "5.1.0", features = ["derive"] }
 schemars.workspace = true
+strum_macros.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
diff --git a/crates/forge_config/src/config.rs b/crates/forge_config/src/config.rs
index 6c550e4962..d152050a8d 100644
--- a/crates/forge_config/src/config.rs
+++ b/crates/forge_config/src/config.rs
@@ -7,7 +7,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::reader::ConfigReader;
 use crate::writer::ConfigWriter;
-use crate::{AutoDumpFormat, Compact, Decimal, HttpConfig, ModelConfig, RetryConfig, Update};
+use crate::{
+    AutoDumpFormat, Compact, Decimal, HttpConfig, ModelConfig, ReasoningConfig, RetryConfig, Update,
+};
 
 /// Top-level Forge configuration merged from all sources (defaults, file,
 /// environment).
@@ -159,6 +161,11 @@ pub struct ForgeConfig {
     /// all tool calls are disabled.
     #[serde(default)]
     pub tool_supported: bool,
+
+    /// Reasoning configuration applied to all agents; controls effort level,
+    /// token budget, and visibility of the model's thinking process.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub reasoning: Option<ReasoningConfig>,
 }
 
 impl ForgeConfig {
diff --git a/crates/forge_config/src/lib.rs b/crates/forge_config/src/lib.rs
index 6bcbdaa147..cc253277e4 100644
--- a/crates/forge_config/src/lib.rs
+++ b/crates/forge_config/src/lib.rs
@@ -8,6 +8,7 @@ mod legacy;
 mod model;
 mod percentage;
 mod reader;
+mod reasoning;
 mod retry;
 mod writer;
 
@@ -20,6 +21,7 @@ pub use http::*;
 pub use model::*;
 pub use percentage::*;
 pub use reader::*;
+pub use reasoning::*;
 pub use retry::*;
 pub use writer::*;
 
diff --git a/crates/forge_config/src/reasoning.rs b/crates/forge_config/src/reasoning.rs
new file mode 100644
index 0000000000..2542d89dc6
--- /dev/null
+++ b/crates/forge_config/src/reasoning.rs
@@ -0,0 +1,57 @@
+use derive_setters::Setters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use strum_macros::Display as StrumDisplay;
+
+/// Controls the reasoning behaviour of a model, including effort level, token
+/// budget, and visibility of the thinking process.
+#[derive(
+    Default, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, fake::Dummy, Setters,
+)]
+#[serde(rename_all = "snake_case")]
+#[setters(strip_option)]
+pub struct ReasoningConfig {
+    /// Controls the effort level of the model's reasoning.
+    /// Supported by openrouter and forge provider.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub effort: Option<Effort>,
+
+    /// Controls how many tokens the model can spend thinking.
+    /// Should be greater than 1024 but less than the overall max_tokens.
+    /// Supported by openrouter, anthropic, and forge provider.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_tokens: Option<usize>,
+
+    /// When true, the model thinks deeply but the reasoning is hidden from the
+    /// caller. Supported by openrouter and forge provider.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub exclude: Option<bool>,
+
+    /// Enables reasoning at the "medium" effort level with no exclusions.
+    /// Supported by openrouter, anthropic, and forge provider.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+
+/// Effort level for model reasoning.
+#[derive(
+    Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, fake::Dummy, StrumDisplay,
+)]
+#[serde(rename_all = "lowercase")]
+#[strum(serialize_all = "lowercase")]
+pub enum Effort {
+    /// No reasoning; skips the thinking step entirely.
+    None,
+    /// Minimal reasoning; fastest and cheapest.
+    Minimal,
+    /// Low reasoning effort.
+    Low,
+    /// Medium reasoning effort; the default for most providers.
+    Medium,
+    /// High reasoning effort.
+    High,
+    /// Extra-high reasoning effort (OpenAI / OpenRouter).
+    XHigh,
+    /// Maximum reasoning effort; only available on select Anthropic models.
+    Max,
+}
diff --git a/crates/forge_domain/src/agent.rs b/crates/forge_domain/src/agent.rs
index 2359a4626d..ab5113f981 100644
--- a/crates/forge_domain/src/agent.rs
+++ b/crates/forge_domain/src/agent.rs
@@ -5,7 +5,7 @@ use derive_setters::Setters;
 use merge::Merge;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use strum_macros::Display as StrumDisplay;
+use strum_macros::{Display as StrumDisplay, EnumString};
 
 use crate::{
     Compact, Error, EventContext, MaxTokens, ModelId, ProviderId, Result, SystemContext,
@@ -71,29 +71,24 @@ pub struct ReasoningConfig {
     pub enabled: Option<bool>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, StrumDisplay)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, StrumDisplay, EnumString)]
 #[serde(rename_all = "lowercase")]
-#[strum(serialize_all = "lowercase")]
+#[strum(serialize_all = "lowercase", ascii_case_insensitive)]
 pub enum Effort {
-    High,
-    Medium,
+    /// No reasoning; skips the thinking step entirely.
+    None,
+    /// Minimal reasoning; fastest and cheapest.
+    Minimal,
+    /// Low reasoning effort.
     Low,
-}
-
-/// Converts a thinking budget (max_tokens) to Effort
-/// - 0-1024 → Low
-/// - 1025-8192 → Medium
-/// - 8193+ → High
-impl From<usize> for Effort {
-    fn from(budget: usize) -> Self {
-        if budget <= 1024 {
-            Effort::Low
-        } else if budget <= 8192 {
-            Effort::Medium
-        } else {
-            Effort::High
-        }
-    }
+    /// Medium reasoning effort; the default for most providers.
+    Medium,
+    /// High reasoning effort.
+    High,
+    /// Extra-high reasoning effort (OpenAI / OpenRouter).
+    XHigh,
+    /// Maximum reasoning effort; only available on select Anthropic models.
+    Max,
 }
 
 /// Estimates the token count from a string representation
@@ -240,29 +235,3 @@ impl From<Agent> for ToolDefinition {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_effort_from_budget_low() {
-        assert_eq!(Effort::from(0), Effort::Low);
-        assert_eq!(Effort::from(1), Effort::Low);
-        assert_eq!(Effort::from(1024), Effort::Low);
-    }
-
-    #[test]
-    fn test_effort_from_budget_medium() {
-        assert_eq!(Effort::from(1025), Effort::Medium);
-        assert_eq!(Effort::from(5000), Effort::Medium);
-        assert_eq!(Effort::from(8192), Effort::Medium);
-    }
-
-    #[test]
-    fn test_effort_from_budget_high() {
-        assert_eq!(Effort::from(8193), Effort::High);
-        assert_eq!(Effort::from(10000), Effort::High);
-        assert_eq!(Effort::from(100000), Effort::High);
-    }
-}
diff --git a/crates/forge_domain/src/env.rs b/crates/forge_domain/src/env.rs
index a614ce0e27..fac789da27 100644
--- a/crates/forge_domain/src/env.rs
+++ b/crates/forge_domain/src/env.rs
@@ -5,7 +5,7 @@ use derive_more::Display;
 use derive_setters::Setters;
 use serde::{Deserialize, Serialize};
 
-use crate::{ModelId, ProviderId};
+use crate::{Effort, ModelId, ProviderId};
 
 /// Domain-level session configuration pairing a provider with a model.
 ///
@@ -35,6 +35,8 @@ pub enum ConfigOperation {
     SetCommitConfig(crate::CommitConfig),
     /// Set the shell-command suggestion configuration.
     SetSuggestConfig(crate::SuggestConfig),
+    /// Set the reasoning effort level for all agents.
+    SetReasoningEffort(Effort),
 }
 
 const VERSION: &str = match option_env!("APP_VERSION") {
diff --git a/crates/forge_infra/src/env.rs b/crates/forge_infra/src/env.rs
index c2b2d91f15..902198b447 100644
--- a/crates/forge_infra/src/env.rs
+++ b/crates/forge_infra/src/env.rs
@@ -67,6 +67,21 @@ fn apply_config_op(fc: &mut ForgeConfig, op: ConfigOperation) {
                 model_id: Some(suggest.model.to_string()),
             });
         }
+        ConfigOperation::SetReasoningEffort(effort) => {
+            let config_effort = match effort {
+                forge_domain::Effort::None => forge_config::Effort::None,
+                forge_domain::Effort::Minimal => forge_config::Effort::Minimal,
+                forge_domain::Effort::Low => forge_config::Effort::Low,
+                forge_domain::Effort::Medium => forge_config::Effort::Medium,
+                forge_domain::Effort::High => forge_config::Effort::High,
+                forge_domain::Effort::XHigh => forge_config::Effort::XHigh,
+                forge_domain::Effort::Max => forge_config::Effort::Max,
+            };
+            let reasoning = fc
+                .reasoning
+                .get_or_insert_with(forge_config::ReasoningConfig::default);
+            reasoning.effort = Some(config_effort);
+        }
     }
 }
 
diff --git a/crates/forge_main/src/built_in_commands.json b/crates/forge_main/src/built_in_commands.json
index 178676fd9b..ac3e697722 100644
--- a/crates/forge_main/src/built_in_commands.json
+++ b/crates/forge_main/src/built_in_commands.json
@@ -23,6 +23,14 @@
     "command": "model-reset",
     "description": "Reset session model to use global config [alias: mr]"
   },
+  {
+    "command": "reasoning-effort",
+    "description": "Set reasoning effort for the current session only [alias: re]"
+  },
+  {
+    "command": "config-reasoning-effort",
+    "description": "Set the reasoning effort level in global config [alias: cre]"
+  },
   {
     "command": "config-commit-model",
     "description": "Set the model used for commit message generation [alias: ccm]"
diff --git a/crates/forge_main/src/cli.rs b/crates/forge_main/src/cli.rs
index 622ad7011b..4cb6ff66f6 100644
--- a/crates/forge_main/src/cli.rs
+++ b/crates/forge_main/src/cli.rs
@@ -8,7 +8,7 @@
 use std::path::PathBuf;
 
 use clap::{Parser, Subcommand, ValueEnum};
-use forge_domain::{AgentId, ConversationId, ModelId, ProviderId};
+use forge_domain::{AgentId, ConversationId, Effort, ModelId, ProviderId};
 
 #[derive(Parser)]
 #[command(version = env!("CARGO_PKG_VERSION"))]
@@ -542,6 +542,11 @@ pub enum ConfigSetField {
         /// Model ID to use for command suggestion generation.
         model: ModelId,
     },
+    /// Set the reasoning effort level applied to all agents.
+    ReasoningEffort {
+        /// Effort level: none, minimal, low, medium, high, xhigh, max.
+        effort: Effort,
+    },
 }
 
 /// Type-safe subcommands for `forge config get`.
@@ -555,6 +560,8 @@ pub enum ConfigGetField {
     Commit,
     /// Get the command suggestion generation config.
     Suggest,
+    /// Get the reasoning effort level.
+    ReasoningEffort,
 }
 
 /// Command group for conversation management.
diff --git a/crates/forge_main/src/ui.rs b/crates/forge_main/src/ui.rs
index 7f0f251e22..f5954dbb91 100644
--- a/crates/forge_main/src/ui.rs
+++ b/crates/forge_main/src/ui.rs
@@ -1348,14 +1348,27 @@ impl<A: API + ConsoleWriter + 'static, F: Fn() -> A + Send + Sync> UI<A, F> {
             .map(|c| c.model.as_str().to_string())
             .unwrap_or_else(|| markers::EMPTY.to_string());
 
+        let reasoning_effort = self
+            .api
+            .get_reasoning_effort()
+            .await
+            .ok()
+            .flatten()
+            .map(|e| e.to_string())
+            .unwrap_or_else(|| markers::EMPTY.to_string());
+
         let info = Info::new()
-            .add_title("CONFIGURATION")
-            .add_key_value("Default Model", model)
-            .add_key_value("Default Provider", provider)
-            .add_key_value("Commit Provider", commit_provider)
-            .add_key_value("Commit Model", commit_model)
-            .add_key_value("Suggest Provider", suggest_provider)
-            .add_key_value("Suggest Model", suggest_model);
+            .add_title("SESSION")
+            .add_key_value("Model", model)
+            .add_key_value("Provider", provider)
+            .add_title("COMMIT")
+            .add_key_value("Model", commit_model)
+            .add_key_value("Provider", commit_provider)
+            .add_title("SUGGEST")
+            .add_key_value("Model", suggest_model)
+            .add_key_value("Provider", suggest_provider)
+            .add_title("REASONING")
+            .add_key_value("Effort", reasoning_effort);
 
         if porcelain {
             self.writeln(
@@ -3488,6 +3501,13 @@ impl<A: API + ConsoleWriter + 'static, F: Fn() -> A + Send + Sync> UI<A, F> {
                     format!("is now the suggest model for provider '{provider}'"),
                 ))?;
             }
+            ConfigSetField::ReasoningEffort { effort } => {
+                self.api.set_reasoning_effort(effort.clone()).await?;
+                self.writeln_title(
+                    TitleFormat::action(effort.to_string())
+                        .sub_title("is now the reasoning effort"),
+                )?;
+            }
         }
 
         Ok(())
@@ -3549,6 +3569,13 @@ impl<A: API + ConsoleWriter + 'static, F: Fn() -> A + Send + Sync> UI<A, F> {
                     None => self.writeln("Suggest: Not set")?,
                 }
             }
+            ConfigGetField::ReasoningEffort => {
+                let effort = self.api.get_reasoning_effort().await?;
+                match effort {
+                    Some(e) => self.writeln(e.to_string())?,
+                    None => self.writeln("ReasoningEffort: Not set")?,
+                }
+            }
         }
 
         Ok(())
diff --git a/crates/forge_repo/src/conversation/conversation_record.rs b/crates/forge_repo/src/conversation/conversation_record.rs
index c8d0a263b4..bee939e30f 100644
--- a/crates/forge_repo/src/conversation/conversation_record.rs
+++ b/crates/forge_repo/src/conversation/conversation_record.rs
@@ -647,17 +647,25 @@ impl From<ToolChoiceRecord> for forge_domain::ToolChoice {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub(super) enum EffortRecord {
-    High,
-    Medium,
+    None,
+    Minimal,
     Low,
+    Medium,
+    High,
+    XHigh,
+    Max,
 }
 
 impl From<&forge_domain::Effort> for EffortRecord {
     fn from(effort: &forge_domain::Effort) -> Self {
         match effort {
-            forge_domain::Effort::High => Self::High,
-            forge_domain::Effort::Medium => Self::Medium,
+            forge_domain::Effort::None => Self::None,
+            forge_domain::Effort::Minimal => Self::Minimal,
             forge_domain::Effort::Low => Self::Low,
+            forge_domain::Effort::Medium => Self::Medium,
+            forge_domain::Effort::High => Self::High,
+            forge_domain::Effort::XHigh => Self::XHigh,
+            forge_domain::Effort::Max => Self::Max,
         }
     }
 }
@@ -665,9 +673,13 @@ impl From<&forge_domain::Effort> for EffortRecord {
 impl From<EffortRecord> for forge_domain::Effort {
     fn from(record: EffortRecord) -> Self {
         match record {
-            EffortRecord::High => Self::High,
-            EffortRecord::Medium => Self::Medium,
+            EffortRecord::None => Self::None,
+            EffortRecord::Minimal => Self::Minimal,
             EffortRecord::Low => Self::Low,
+            EffortRecord::Medium => Self::Medium,
+            EffortRecord::High => Self::High,
+            EffortRecord::XHigh => Self::XHigh,
+            EffortRecord::Max => Self::Max,
         }
     }
 }
diff --git a/crates/forge_repo/src/provider/openai_responses/codex_transformer.rs b/crates/forge_repo/src/provider/openai_responses/codex_transformer.rs
index f45560c2c4..b11e606d31 100644
--- a/crates/forge_repo/src/provider/openai_responses/codex_transformer.rs
+++ b/crates/forge_repo/src/provider/openai_responses/codex_transformer.rs
@@ -11,8 +11,8 @@ use forge_domain::Transformer;
 /// - `max_output_tokens` is not supported and must be stripped.
 /// - `include` always contains `reasoning.encrypted_content` for stateless
 ///   reasoning continuity.
-/// - `text.verbosity` is forced to `Low` for concise output.
-/// - `reasoning.effort` is forced to `High` and `reasoning.summary` to `Auto`.
+/// - `reasoning.effort` and `reasoning.summary` are passed through as-is from
+///   the caller.
 pub struct CodexTransformer;
 
 impl Transformer for CodexTransformer {
@@ -28,11 +28,6 @@ impl Transformer for CodexTransformer {
             includes.push(oai::IncludeEnum::ReasoningEncryptedContent);
         }
 
-        if let Some(reasoning) = request.reasoning.as_mut() {
-            reasoning.effort = Some(oai::ReasoningEffort::High);
-            reasoning.summary = Some(oai::ReasoningSummary::Auto);
-        }
-
         request
     }
 }
@@ -121,7 +116,7 @@ mod tests {
     }
 
     #[test]
-    fn test_codex_transformer_sets_reasoning_effort_high_and_summary_auto() {
+    fn test_codex_transformer_preserves_reasoning_effort_and_summary() {
         let reasoning = oai::Reasoning {
             effort: Some(oai::ReasoningEffort::Low),
             summary: Some(oai::ReasoningSummary::Detailed),
@@ -134,11 +129,11 @@ mod tests {
 
         assert_eq!(
             actual.reasoning.as_ref().and_then(|r| r.effort.clone()),
-            Some(oai::ReasoningEffort::High)
+            Some(oai::ReasoningEffort::Low)
         );
         assert_eq!(
             actual.reasoning.as_ref().and_then(|r| r.summary),
-            Some(oai::ReasoningSummary::Auto)
+            Some(oai::ReasoningSummary::Detailed)
         );
     }
 
diff --git a/crates/forge_repo/src/provider/openai_responses/request.rs b/crates/forge_repo/src/provider/openai_responses/request.rs
index 07546c5933..2ada99c894 100644
--- a/crates/forge_repo/src/provider/openai_responses/request.rs
+++ b/crates/forge_repo/src/provider/openai_responses/request.rs
@@ -113,9 +113,13 @@ impl FromDomain<ReasoningConfig> for oai::Reasoning {
         // Map effort level
         if let Some(effort) = config.effort {
             let oai_effort = match effort {
-                Effort::High => oai::ReasoningEffort::High,
-                Effort::Medium => oai::ReasoningEffort::Medium,
+                Effort::None => oai::ReasoningEffort::None,
+                Effort::Minimal => oai::ReasoningEffort::Minimal,
                 Effort::Low => oai::ReasoningEffort::Low,
+                Effort::Medium => oai::ReasoningEffort::Medium,
+                Effort::High => oai::ReasoningEffort::High,
+                // XHigh and Max both map to the highest available OAI level.
+                Effort::XHigh | Effort::Max => oai::ReasoningEffort::Xhigh,
             };
             builder.effort(oai_effort);
         } else if config.enabled.unwrap_or(false) {
diff --git a/crates/forge_services/src/app_config.rs b/crates/forge_services/src/app_config.rs
index fb1e438e4b..4dfe26206d 100644
--- a/crates/forge_services/src/app_config.rs
+++ b/crates/forge_services/src/app_config.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use forge_app::{AppConfigService, EnvironmentInfra};
 use forge_domain::{
-    CommitConfig, ConfigOperation, ModelId, ProviderId, ProviderRepository, SuggestConfig,
+    CommitConfig, ConfigOperation, Effort, ModelId, ProviderId, ProviderRepository, SuggestConfig,
 };
 use tracing::debug;
 
@@ -128,6 +128,24 @@ impl<F: ProviderRepository + EnvironmentInfra + Send + Sync> AppConfigService
         self.update(ConfigOperation::SetSuggestConfig(suggest_config))
             .await
     }
+
+    async fn get_reasoning_effort(&self) -> anyhow::Result<Option<Effort>> {
+        let config = self.infra.get_config();
+        Ok(config.reasoning.and_then(|r| r.effort).map(|e| match e {
+            forge_config::Effort::None => Effort::None,
+            forge_config::Effort::Minimal => Effort::Minimal,
+            forge_config::Effort::Low => Effort::Low,
+            forge_config::Effort::Medium => Effort::Medium,
+            forge_config::Effort::High => Effort::High,
+            forge_config::Effort::XHigh => Effort::XHigh,
+            forge_config::Effort::Max => Effort::Max,
+        }))
+    }
+
+    async fn set_reasoning_effort(&self, effort: Effort) -> anyhow::Result<()> {
+        self.update(ConfigOperation::SetReasoningEffort(effort))
+            .await
+    }
 }
 
 #[cfg(test)]
@@ -277,6 +295,9 @@ mod tests {
                                     .model_id(suggest.model.to_string()),
                             );
                         }
+                        ConfigOperation::SetReasoningEffort(_) => {
+                            // No-op in tests
+                        }
                     }
                 }
                 Ok(())
diff --git a/forge.schema.json b/forge.schema.json
index 80ef5e8850..9ba1a41bba 100644
--- a/forge.schema.json
+++ b/forge.schema.json
@@ -206,6 +206,17 @@
       "default": 0,
       "minimum": 0
     },
+    "reasoning": {
+      "description": "Reasoning configuration applied to all agents; controls effort level,\ntoken budget, and visibility of the model's thinking process.",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/ReasoningConfig"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "restricted": {
       "description": "Whether restricted mode is active; when enabled, tool execution requires\nexplicit permission grants.",
       "type": "boolean",
@@ -395,6 +406,46 @@
         }
       }
     },
+    "Effort": {
+      "description": "Effort level for model reasoning.",
+      "oneOf": [
+        {
+          "description": "No reasoning; skips the thinking step entirely.",
+          "type": "string",
+          "const": "none"
+        },
+        {
+          "description": "Minimal reasoning; fastest and cheapest.",
+          "type": "string",
+          "const": "minimal"
+        },
+        {
+          "description": "Low reasoning effort.",
+          "type": "string",
+          "const": "low"
+        },
+        {
+          "description": "Medium reasoning effort; the default for most providers.",
+          "type": "string",
+          "const": "medium"
+        },
+        {
+          "description": "High reasoning effort.",
+          "type": "string",
+          "const": "high"
+        },
+        {
+          "description": "Extra-high reasoning effort (OpenAI / OpenRouter).",
+          "type": "string",
+          "const": "xhigh"
+        },
+        {
+          "description": "Maximum reasoning effort; only available on select Anthropic models.",
+          "type": "string",
+          "const": "max"
+        }
+      ]
+    },
     "HttpConfig": {
       "description": "HTTP client configuration.",
       "type": "object",
@@ -524,6 +575,46 @@
         }
       }
     },
+    "ReasoningConfig": {
+      "description": "Controls the reasoning behaviour of a model, including effort level, token\nbudget, and visibility of the thinking process.",
+      "type": "object",
+      "properties": {
+        "effort": {
+          "description": "Controls the effort level of the model's reasoning.\nSupported by openrouter and forge provider.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/Effort"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "enabled": {
+          "description": "Enables reasoning at the \"medium\" effort level with no exclusions.\nSupported by openrouter, anthropic, and forge provider.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "exclude": {
+          "description": "When true, the model thinks deeply but the reasoning is hidden from the\ncaller. Supported by openrouter and forge provider.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "max_tokens": {
+          "description": "Controls how many tokens the model can spend thinking.\nShould be greater than 1024 but less than the overall max_tokens.\nSupported by openrouter, anthropic, and forge provider.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint",
+          "minimum": 0
+        }
+      }
+    },
     "RetryConfig": {
       "description": "Configuration for retry mechanism.",
       "type": "object",
diff --git a/shell-plugin/forge.theme.zsh b/shell-plugin/forge.theme.zsh
index 065f275a0b..8081396174 100644
--- a/shell-plugin/forge.theme.zsh
+++ b/shell-plugin/forge.theme.zsh
@@ -17,6 +17,7 @@ function _forge_prompt_info() {
     forge_cmd+=(zsh rprompt)
     [[ -n "$_FORGE_SESSION_MODEL" ]] && local -x FORGE_SESSION__MODEL_ID="$_FORGE_SESSION_MODEL"
     [[ -n "$_FORGE_SESSION_PROVIDER" ]] && local -x FORGE_SESSION__PROVIDER_ID="$_FORGE_SESSION_PROVIDER"
+    [[ -n "$_FORGE_SESSION_REASONING_EFFORT" ]] && local -x FORGE_REASONING__EFFORT="$_FORGE_SESSION_REASONING_EFFORT"
     _FORGE_CONVERSATION_ID=$_FORGE_CONVERSATION_ID _FORGE_ACTIVE_AGENT=$_FORGE_ACTIVE_AGENT "${forge_cmd[@]}"
 }
 
diff --git a/shell-plugin/lib/actions/config.zsh b/shell-plugin/lib/actions/config.zsh
index a05a331b72..787d4e84b1 100644
--- a/shell-plugin/lib/actions/config.zsh
+++ b/shell-plugin/lib/actions/config.zsh
@@ -375,6 +375,82 @@ function _forge_action_model_reset() {
     _forge_log success "Session model reset to global config"
 }
 
+# Action handler: Select reasoning effort for the current session only.
+# Sets _FORGE_SESSION_REASONING_EFFORT in the shell environment so that
+# every subsequent forge invocation uses the selected value via the
+# FORGE_REASONING__EFFORT env var without modifying the permanent config.
+function _forge_action_reasoning_effort() {
+    local input_text="$1"
+    echo
+
+    local efforts
+    efforts=$'EFFORT\nnone\nminimal\nlow\nmedium\nhigh\nxhigh\nmax'
+
+    local current_effort
+    if [[ -n "$_FORGE_SESSION_REASONING_EFFORT" ]]; then
+        current_effort="$_FORGE_SESSION_REASONING_EFFORT"
+    else
+        current_effort=$($_FORGE_BIN config get reasoning-effort 2>/dev/null)
+    fi
+
+    local fzf_args=(
+        --prompt="Reasoning Effort ❯ "
+    )
+
+    if [[ -n "$input_text" ]]; then
+        fzf_args+=(--query="$input_text")
+    fi
+
+    if [[ -n "$current_effort" ]]; then
+        local index=$(_forge_find_index "$efforts" "$current_effort" 1)
+        fzf_args+=(--bind="start:pos($index)")
+    fi
+
+    local selected
+    selected=$(echo "$efforts" | _forge_fzf --header-lines=1 "${fzf_args[@]}")
+
+    if [[ -n "$selected" ]]; then
+        _FORGE_SESSION_REASONING_EFFORT="$selected"
+        _forge_log success "Session reasoning effort set to \033[1m${selected}\033[0m"
+    fi
+}
+
+# Action handler: Set reasoning effort in global config.
+# Calls `forge config set reasoning-effort <effort>` on selection,
+# writing the chosen effort level permanently to ~/forge/.forge.toml.
+function _forge_action_config_reasoning_effort() {
+    local input_text="$1"
+    (
+        echo
+
+        local efforts
+        efforts=$'EFFORT\nnone\nminimal\nlow\nmedium\nhigh\nxhigh\nmax'
+
+        local current_effort
+        current_effort=$($_FORGE_BIN config get reasoning-effort 2>/dev/null)
+
+        local fzf_args=(
+            --prompt="Config Reasoning Effort ❯ "
+        )
+
+        if [[ -n "$input_text" ]]; then
+            fzf_args+=(--query="$input_text")
+        fi
+
+        if [[ -n "$current_effort" ]]; then
+            local index=$(_forge_find_index "$efforts" "$current_effort" 1)
+            fzf_args+=(--bind="start:pos($index)")
+        fi
+
+        local selected
+        selected=$(echo "$efforts" | _forge_fzf --header-lines=1 "${fzf_args[@]}")
+
+        if [[ -n "$selected" ]]; then
+            _forge_exec config set reasoning-effort "$selected"
+        fi
+    )
+}
+
 # Action handler: Show config list
 function _forge_action_config() {
     echo
diff --git a/shell-plugin/lib/dispatcher.zsh b/shell-plugin/lib/dispatcher.zsh
index 43fcc89688..ac02fe28f3 100644
--- a/shell-plugin/lib/dispatcher.zsh
+++ b/shell-plugin/lib/dispatcher.zsh
@@ -178,6 +178,12 @@ function forge-accept-line() {
         model-reset|mr)
             _forge_action_model_reset
         ;;
+        reasoning-effort|re)
+            _forge_action_reasoning_effort "$input_text"
+        ;;
+        config-reasoning-effort|cre)
+            _forge_action_config_reasoning_effort "$input_text"
+        ;;
         config-commit-model|ccm)
             _forge_action_commit_model "$input_text"
         ;;
diff --git a/shell-plugin/lib/helpers.zsh b/shell-plugin/lib/helpers.zsh
index 03bcece244..01f0dbb679 100644
--- a/shell-plugin/lib/helpers.zsh
+++ b/shell-plugin/lib/helpers.zsh
@@ -25,6 +25,7 @@ function _forge_exec() {
     cmd+=("$@")
     [[ -n "$_FORGE_SESSION_MODEL" ]] && local -x FORGE_SESSION__MODEL_ID="$_FORGE_SESSION_MODEL"
     [[ -n "$_FORGE_SESSION_PROVIDER" ]] && local -x FORGE_SESSION__PROVIDER_ID="$_FORGE_SESSION_PROVIDER"
+    [[ -n "$_FORGE_SESSION_REASONING_EFFORT" ]] && local -x FORGE_REASONING__EFFORT="$_FORGE_SESSION_REASONING_EFFORT"
     "${cmd[@]}"
 }
 
@@ -41,6 +42,7 @@ function _forge_exec_interactive() {
     cmd+=("$@")
     [[ -n "$_FORGE_SESSION_MODEL" ]] && local -x FORGE_SESSION__MODEL_ID="$_FORGE_SESSION_MODEL"
     [[ -n "$_FORGE_SESSION_PROVIDER" ]] && local -x FORGE_SESSION__PROVIDER_ID="$_FORGE_SESSION_PROVIDER"
+    [[ -n "$_FORGE_SESSION_REASONING_EFFORT" ]] && local -x FORGE_REASONING__EFFORT="$_FORGE_SESSION_REASONING_EFFORT"
     "${cmd[@]}" </dev/tty >/dev/tty
 }