Reasoning

Reasoning controls how much internal analysis Cosine asks the model to do before it answers, uses tools, or edits files.

In practice, higher reasoning usually means:

• more planning before acting
• better performance on ambiguous or multi-step tasks
• slower responses
• more token usage

Lower reasoning usually means:

• faster responses
• less internal analysis
• better fit for routine or well-scoped work

What reasoning changes

Reasoning affects how the model approaches your task, not just how much text it writes back.

With higher reasoning, Cosine is more likely to:

• pause longer before the first answer
• compare multiple approaches before choosing one
• catch edge cases before editing code
• spend more effort planning large refactors or debugging sessions

With lower reasoning, Cosine is more likely to:

• answer quickly
• move straight into tool use
• work best on direct, local, low-ambiguity tasks

Choose a reasoning level

Use the current task to decide how much reasoning you want.

Level	Best for	What to expect
none	Straightforward lookups, quick summaries, very simple edits	Fastest behavior, with little or no extra internal reasoning
low	Small bug fixes, targeted searches, routine code changes	Fast and direct
medium	Most day-to-day coding tasks	Balanced speed and depth
high	Debugging tricky issues, design work, careful refactors	Slower, more deliberate, better at edge cases
xhigh	Deep analysis on supported GPT/Codex models	Highest fixed reasoning depth, usually the slowest option
adaptive	Supported Claude 4.6 models when you want the model to choose how much thinking it needs	Flexible depth that expands or contracts with the task

When to use each

Use none

Choose none when you want the quickest possible pass and the task is simple enough that extra thinking would not help much.

Examples:

• “List the TODOs in this repo”
• “Find where this function is defined”
• “Rename this variable in one file”

Use low

Choose low for tasks that are still simple, but where Cosine may need a small amount of planning before acting.

Examples:

• small UI copy updates
• one-file bug fixes
• quick code reviews

Use medium

medium is the best default for most sessions.

Use it when:

• you are not sure how complex the task will become
• the task may touch a few files
• you want good quality without noticeably slowing everything down

Use high

Choose high when the cost of a shallow answer is larger than the cost of waiting.

Examples:

• debugging a flaky test or production bug
• designing a migration or API change
• reviewing a plan before making edits
• refactoring code with a lot of edge cases

Use xhigh

Choose xhigh only when you are using a model that supports it and the task genuinely needs the deepest fixed reasoning budget.

Examples:

• correctness-heavy algorithm work
• difficult architecture trade-offs
• large, risky changes where you want the model to think longer before acting

Not every model supports xhigh. In the CLI interface, Cosine only shows it when the current model supports it.

Use adaptive

adaptive is available for supported Claude 4.6 models in CLI2.

Choose it when:

• your task may start simple but become complex
• you want Claude to spend more time thinking only when needed
• you do not want to manually switch between low, medium, and high as the session evolves

This is often a good fit for open-ended debugging, exploratory refactors, or feature work where the difficulty is not obvious at the start.

Model-specific behavior

Not every model supports every reasoning level.

In the CLI:

• GPT and Codex models may offer xhigh
• Supported Claude 4.6 models may offer adaptive
• other models may offer a smaller set of levels

The reasoning menu in the TUI only shows the options that make sense for the current model.

Set reasoning in the TUI

1. Press Ctrl+P or / to open the commands menu.
2. Choose Reasoning Effort.
3. Select the level you want for the current session.

If you also want to make it your default, save it as a config value instead of setting it only for one session.

Set reasoning from the command line

Use the --reasoning flag when starting a session:

cos start --reasoning low

Examples:

# Quick repository inspection
cos start --reasoning none --prompt "List all TODO comments"

# Balanced default
cos start --reasoning medium

# More careful debugging
cos start --reasoning high --prompt "Find the root cause of this flaky test"

# Deep analysis on supported GPT/Codex models
cos start --reasoning xhigh --model gpt-5.4 --prompt "Evaluate the trade-offs in this design"

# Adaptive thinking on supported Claude 4.6 models
cos start --reasoning adaptive --model claude-sonnet-4-6-1m --prompt "Investigate why this refactor regressed performance"

Set a default reasoning level

You can set a default in your config:

[inference]
reasoning_level = "medium"

This is useful when you tend to prefer one style of work:

• low if you want a snappier assistant by default
• medium if you want a good general-purpose default
• high if you usually use Cosine for harder engineering work

Reasoning and visible thinking blocks

Reasoning level and visible thinking are related, but not the same thing.

• Reasoning level changes how the model works.
• Thinking visibility only changes whether reasoning blocks are shown in the timeline.

If you hide thinking blocks, the model can still reason internally. You are only changing the display.

Practical advice

• Start with medium unless you have a reason not to.
• Drop to low or none for repetitive, well-defined tasks.
• Raise to high when the task is risky, ambiguous, or spread across several files.
• Use adaptive on supported Claude 4.6 models when task complexity is likely to vary during the same session.
• Use xhigh sparingly. It is best when the extra delay is worth the extra care.

See also

• Commands — Overview of CLI commands
• Flags — --reasoning reference
• Configuration — Set default reasoning in config
• Timeline — How reasoning blocks appear in the conversation view