How to Configure the Reasoning Language Display (auto, zh, en) in Reasonix

Reasonix controls visible reasoning text language via the agent.reasoning_language setting, which accepts auto, zh, or en and prepends a transient <reasoning-language> block to user turns without altering system prompts.

The DeepSeek-Reasonix repository provides a configurable reasoning language feature that lets you dictate whether the model's visible thinking process appears in Simplified Chinese, English, or automatic detection. This setting, configured under the [agent] section, affects only the displayed reasoning text and never changes the final answer language or code output. By injecting a small transient block rather than modifying system prompts, Reasonix maintains high cache-hit rates while giving users full control over the linguistic presentation of the model's thought process.

Understanding the Reasoning Language Modes

Reasonix supports three distinct modes for the reasoning_language parameter, each triggering different behavior in internal/agent/reasoning_language.go.

Mode	Behavior
auto	Automatically injects a <reasoning-language> block when the raw user prompt is clearly Chinese. English or ambiguous prompts receive no extra instruction.
zh	Forces visible reasoning to appear in Simplified Chinese for the entire turn.
en	Forces visible reasoning to appear in English for the entire turn.

The preference applies transiently by prepending the <reasoning-language> directive to the user turn immediately before the model call. This approach preserves the system prompt and tool schemas unchanged, ensuring consistent cache behavior across requests.

Configuration Methods

You can adjust the reasoning language through four interfaces, depending on your workflow context.

Desktop UI Configuration

Navigate to Settings → Models → Usage → Agent runtime → Thinking language in the Reasonix desktop application. The UI writes the selected value to your user-level configuration file at ~/.reasonix/config.toml.

CLI Commands

Use the reasonix config reasoning-language command to set the global preference or a project-local override.

# Set global preference to automatic detection

reasonix config reasoning-language auto

# Force Chinese reasoning output globally

reasonix config reasoning-language zh

# Set English for the current project only

reasonix config reasoning-language --local en

The --local flag writes the setting to ./reasonix.toml in your current working directory instead of the global user config.

Slash Commands During Sessions

While chatting in a Reasonix session, use the slash command to change the language dynamically. This updates the current chat controller and persists the setting to your user-level config.

/reasoning-language auto
/reasoning-language zh
/reasoning-language en

The slash command implementation resides in internal/cli/slash_registry.go, which registers the command and provides completion hints. Note that this method does not modify the project's reasonix.toml; use the CLI with --local for permanent project overrides.

TOML Configuration Files

Represent the setting explicitly in TOML format for version-controlled projects or shared configurations.

[agent]
reasoning_language = "auto"   # auto | zh | en

Reference the example configuration in reasonix.example.toml for additional [agent] section options.

Configuration Resolution Order

Reasonix resolves the reasoning_language setting using a hierarchical fallback mechanism:

./reasonix.toml   →   ~/.reasonix/config.toml   →   built-in defaults

Project-local settings take precedence over user preferences, allowing repository-specific language requirements without affecting global behavior. No dedicated command-line flag exists for single invocations because the preference belongs to the user or project context rather than individual executions.

Technical Implementation

The reasoning language feature spans multiple components in the DeepSeek-Reasonix codebase:

• internal/cli/reasoning_language.go: Implements the reasonix config reasoning-language CLI command, handling argument parsing and status messages.
• internal/agent/reasoning_language.go: Generates the transient <reasoning-language> blocks for all three modes and provides the WithReasoningLanguage helper function that injects these blocks into user turns.
• internal/cli/slash_registry.go: Registers the /reasoning-language slash command for runtime adjustment.
• docs/REASONING_LANGUAGE.md: Contains comprehensive user-facing documentation covering UI locations, CLI syntax, and configuration examples.

These components work together to provide the full stack for configuring Reasonix's visible reasoning language across desktop, CLI/TUI, and programmatic contexts.

Summary

• Reasonix uses agent.reasoning_language with values auto, zh, or en to control visible thinking text.
• The setting injects a transient <reasoning-language> block without modifying system prompts, preserving cache efficiency.
• Configure via Desktop UI, CLI (reasonix config reasoning-language), slash commands (/reasoning-language), or TOML files.
• Resolution follows the order: project reasonix.toml → user config.toml → defaults.
• Source implementations reside in internal/agent/reasoning_language.go and internal/cli/reasoning_language.go.

Frequently Asked Questions

Does changing the reasoning language affect the model's final output language?

No. The reasoning_language setting controls only the visible thinking process that the model emits before generating the final response. It does not constrain the language of the final answer, code blocks, or tool outputs. According to the implementation in internal/agent/reasoning_language.go, the directive applies transiently to the reasoning phase only.

What is the difference between auto mode and explicitly setting zh or en?

Auto mode analyzes the raw user prompt to detect Chinese text, injecting a <reasoning-language> block only when the input is clearly Chinese. English or ambiguous prompts receive no special instruction. Setting zh or en explicitly forces that language for the reasoning text regardless of input language, ensuring consistent thinking display across all turns.

Can I set different reasoning languages for different projects?

Yes. Use the --local flag with the CLI command to write the setting to the project's ./reasonix.toml file: reasonix config reasoning-language --local zh. Project-local configurations override user-level settings, allowing per-repository language preferences without affecting your global ~/.reasonix/config.toml.

Why doesn't Reasonix use a command-line flag for reasoning language?

The reasoning language preference belongs to the user or project context rather than a single invocation. Since the setting persists across sessions and affects how the agent interprets requests over time, it is managed through configuration files (reasonix.toml or config.toml) rather than ephemeral command-line flags. This design ensures consistent behavior across desktop, CLI, and TUI interfaces.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}