How to change reasoning effort in OpenCode

opencode run --variant low "your prompt"

curl -fsSL https://tokenminning.ai/install.sh | sh
tokenmin opencode

Quick answer — change reasoning effort

1. Open project or global config — opencode.json in the repo, or ~/.config/opencode/opencode.json.
2. Set effort on the model under provider.<id>.models.<model-id>.options.
3. Optionally override on a single agent under agent.<name>.options.
4. Reload OpenCode (restart TUI or new session).
5. Confirm with opencode models <provider> and a test prompt.

File: opencode.json at project root (or global path above).

Scopes: global model default → provider model options → per-agent model + options (agent wins).

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-sonnet-4-5",
  "provider": {
    "openai": {
      "models": {
        "gpt-5": {
          "options": {
            "reasoningEffort": "low"
          }
        }
      }
    },
    "anthropic": {
      "models": {
        "claude-sonnet-4-5-20250929": {
          "options": {
            "thinking": {
              "type": "enabled",
              "budgetTokens": 8000
            }
          }
        }
      }
    }
  },
  "agent": {
    "plan": {
      "model": "anthropic/claude-haiku-4-5"
    },
    "build": {
      "model": "anthropic/claude-sonnet-4-5",
      "options": {
        "reasoningEffort": "medium"
      }
    }
  }
}

One-off without editing config:

opencode run --variant low "Summarize this diff"
opencode run -m openai/gpt-5 --variant high "Design the migration plan"

Verified against OpenCode Models  and CLI  (August 2026).

Check your OpenCode version and schema

Before you change reasoning effort, confirm which OpenCode release and config schema you run. Reasoning keys live in opencode.json (project root or ~/.config/opencode/opencode.json), but v2 compaction and some agent fields differ from stable docs at opencode.ai/docs.

Run opencode --version. If your team tracks v2 docs, validate keys against v2 models  before copying examples from stable guides. Wrong schema version usually means silent defaults — effort looks unchanged even after you edit opencode.json.

How do I change reasoning effort in OpenCode?

Edit opencode.json and set provider model options, or per-agent options. The agent block overrides global model options for that agent only — so you can run low effort on Plan and higher effort on Build without touching other agents.

Use opencode models or opencode models <provider> to list exact provider/model strings for your install.

Where does the reasoning effort setting go?

Project opencode.json overrides global config for team standards. See Config precedence .

OpenAI and OpenAI-compatible providers

For GPT-5 family and other reasoning models on the openai provider (or OpenAI-compatible custom providers), use reasoningEffort:

{
  "provider": {
    "openai": {
      "models": {
        "gpt-5": {
          "options": {
            "reasoningEffort": "high",
            "textVerbosity": "low",
            "reasoningSummary": "auto"
          }
        }
      }
    }
  }
}

Typical reasoningEffort values (OpenAI models in OpenCode — verify on your model):

OpenCode also ships built-in variants per provider. For OpenAI, variant names map to effort levels (none, minimal, low, medium, high, xhigh). Cycle variants in the TUI with the variant_cycle keybind, or pass --variant to opencode run.

Custom OpenAI-compatible endpoints (local vLLM, corporate gateway) only honor keys the upstream server implements — unsupported options are ignored or error at request time.

Anthropic thinking budgets

Anthropic extended thinking uses a thinking object, not reasoningEffort:

{
  "provider": {
    "anthropic": {
      "models": {
        "claude-sonnet-4-5-20250929": {
          "options": {
            "thinking": {
              "type": "enabled",
              "budgetTokens": 16000
            }
          }
        }
      }
    }
  }
}

OpenCode built-in Anthropic variants:

Lower budgetTokens to cap thinking output tokens. Disable thinking by choosing a non-thinking model ID or the lowest variant your workflow allows.

Google and other built-in providers

Google models in OpenCode expose variant-style effort:

Define custom variants under provider.<id>.models.<model>.variants to bundle options without duplicating model entries (Models: custom variants ).

OpenRouter and custom providers

When OpenCode routes through OpenRouter or a custom provider block, reasoning keys pass through in options if the upstream model supports them:

{
  "provider": {
    "openrouter": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "thinking": {
              "type": "enabled",
              "budgetTokens": 8000
            }
          }
        }
      }
    }
  }
}

For Anthropic models via OpenRouter, prefer the thinking object when the model expects extended thinking — match the provider’s API shape. Wrong keys do not change effort; OpenCode sends them, but the gateway may strip or ignore unknown fields.

Custom provider template — see Providers:

{
  "provider": {
    "local": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Local gateway",
      "options": {
        "baseURL": "http://localhost:8000/v1",
        "apiKey": "local"
      },
      "models": {
        "my-reasoning-model": {
          "options": {
            "reasoningEffort": "low"
          }
        }
      }
    }
  }
}

Change effort for one model without affecting others

Use per-model options under provider.*.models, not the top-level model key alone:

{
  "model": "anthropic/claude-sonnet-4-5",
  "provider": {
    "anthropic": {
      "models": {
        "claude-sonnet-4-5-20250929": {
          "options": { "thinking": { "type": "enabled", "budgetTokens": 16000 } }
        },
        "claude-haiku-4-5": {}
      }
    }
  },
  "agent": {
    "plan": { "model": "anthropic/claude-haiku-4-5" },
    "build": { "model": "anthropic/claude-sonnet-4-5-20250929" }
  }
}

Only agents (or CLI invocations) that reference the thinking model pay thinking overhead. Plan on Haiku stays cheap; Build keeps higher effort.

What is the default reasoning effort in OpenCode?

When you do not set options or variants, OpenCode uses the provider’s default for that model — often the high thinking variant on Anthropic thinking models and medium–high effort on OpenAI reasoning models. There is no separate global “reasoning effort” knob outside provider/model config.

To minimize defaults:

1. Set explicit options or pick a low / none variant.
2. Assign non-thinking models to Plan and @explore.
3. Avoid thinking model IDs in the global "model" default.

How to disable or minimize reasoning

Picking claude-haiku for Plan is usually more reliable than forcing low thinking on a Sonnet thinking variant.

Which providers and models expose reasoning controls?

Run opencode models --verbose after opencode models --refresh to see which models your providers expose.

Configurations that do NOT work (and why)

If effort changes seem ignored, confirm the exact model string in opencode models matches your config key, then check provider billing for thinking/output token spikes.

When reasoning is worth it

Use Plan with cheap models; raise effort only on Build after you approve the approach. See Agents.

Subagents and parallel thinking

@general, @scout, and Task-delegated subagents spawn sessions with their own model choices. Restrict with permission.task; prefer read-only @explore for search. Each parallel subagent can run thinking models independently — multiply overhead fast. Details: Agents.

Troubleshooting

High output on simple tasks — Thinking default on Plan. Switch Plan to Haiku; lower reasoningEffort or budgetTokens.

Effort change ignored — Options must match provider + model ID. Check Providers merge order and run opencode models <provider>.

Stats spike after model change — New conversation when switching models; cache behavior resets. See Token usage.

Related

• OpenCode hub
• Providers — custom providers and options passthrough
• Context — context fill vs thinking tokens
• Token usage
• Model routing
• OpenCode: Models