# How to Configure Reasoning Language Visibility (auto/zh/en) in DeepSeek-Reasonix

> Easily configure DeepSeek-Reasonix reasoning language visibility to auto zh or en using TOML CLI or the desktop UI Set your agent's thinking language for better control

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: how-to-guide
- Published: 2026-06-24

---

**DeepSeek-Reasonix exposes the `agent.reasoning_language` setting to control whether the model's visible "thinking" text appears in English (`en`), Simplified Chinese (`zh`), or follows the conversation language (`auto`), configurable via TOML files, CLI commands, or the desktop UI slash commands.**

DeepSeek-Reasonix allows you to customize the language of visible reasoning traces—the explanatory "thinking" text displayed alongside model responses—without affecting the final answer language or underlying model behavior. This guide explains how to configure reasoning language visibility using the `agent.reasoning_language` parameter found in [`internal/config/config.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/config/config.go), covering everything from persistent configuration files to runtime slash commands.

## Understanding the Reasoning Language Setting

The `agent.reasoning_language` parameter, defined in [`internal/config/config.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/config/config.go), accepts three distinct values that determine how the model presents its reasoning process:

- **`auto`** (default): The reasoning text follows the conversation language with no extra prompt injection
- **`zh`**: Explicitly requests visible reasoning in Simplified Chinese
- **`en`**: Explicitly requests visible reasoning in English

This setting exclusively affects the user-visible reasoning traces. It does not modify the final answer language, code identifiers, or hidden chain-of-thought processing occurring within the model.

## Configuration Methods

### Project-Level Configuration File

Create or edit [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) in your project root to enforce team-wide consistency. According to the configuration schema in [`internal/config/config.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/config/config.go), use the following TOML syntax:

```toml
[agent]
reasoning_language = "auto"   # Options: auto | zh | en

```

### User-Level Configuration File

For global preferences across all projects, edit `~/.reasonix/config.toml`. This file follows the same structure as the project-level configuration but resides in your home directory.

### Command-Line Interface

The `reasonix config reasoning-language` command, implemented in [`internal/cli/reasoning_language.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/reasoning_language.go), provides a convenient way to modify settings without editing files directly.

Set the value globally for your user account:

```bash
reasonix config reasoning-language zh

```

Override the setting locally for the current project only:

```bash
reasonix config reasoning-language en --local

```

Verify your current configuration:

```bash
reasonix show config | grep reasoning_language

# Output: reasoning_language = "en"

```

### Desktop Application

 Navigate to **Settings → Models → Usage → Agent runtime → Thinking language**. The desktop UI writes the same user-level config file (`~/.reasonix/config.toml`) under the hood, as documented in [`docs/REASONING_LANGUAGE.md`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/docs/REASONING_LANGUAGE.md).

### Runtime Slash Commands

While using the desktop app's chat interface, you can dynamically switch languages for the current session using slash commands:

```

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

```

These commands update both the user-level configuration and the current chat controller immediately.

## Configuration Resolution Order

When DeepSeek-Reasonix loads a session, it resolves `agent.reasoning_language` using a hierarchical precedence (first match wins):

1. [`./reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/./reasonix.toml) (project-local)
2. `~/.reasonix/config.toml` (user-level)
3. Built-in defaults (`auto`)

This architecture allows project-specific requirements to override individual user preferences, ensuring consistent behavior across team environments.

## Cache Performance Considerations

According to [`docs/REASONING_LANGUAGE.md`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/docs/REASONING_LANGUAGE.md), the `auto` setting provides optimal cache performance because it adds no extra instructions to the prompt.

When using `zh` or `en`, the system temporarily injects a `<reasoning-language>` block into the user turn. However, this injection does not modify:
- The system prompt
- Tool schemas
- The stable provider-visible prefix

This design preserves high prompt-cache hit rates while still allowing the preference to influence the next model call.

## Programmatic Access

For developers integrating with the internal Go API, access the current setting via the `Config` struct:

```go
cfg, err := config.Load()
if err != nil {
    // handle error
}
fmt.Println("Current reasoning language:", cfg.Agent.ReasoningLanguage)
// Output: auto | zh | en

```

The configuration loading logic resides in [`internal/config/config.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/config/config.go) (lines 332-779), where the `Agent.ReasoningLanguage` field is parsed and normalized.

## Summary

- **Set via TOML**: Configure `agent.reasoning_language` in [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) (project) or `~/.reasonix/config.toml` (user)
- **Set via CLI**: Use `reasonix config reasoning-language [value]` with optional `--local` flag for project-specific overrides
- **Set via Desktop**: Navigate to Settings → Models → Usage → Agent runtime → Thinking language
- **Set via Slash**: Use `/reasoning-language [auto|zh|en]` during chat sessions for immediate changes
- **Resolution**: Project config overrides user config, which overrides the `auto` default
- **Performance**: `auto` offers best cache efficiency; `zh`/`en` adds minimal temporary overhead without altering system prompts

## Frequently Asked Questions

### Does changing the reasoning language affect the final answer language?

No. The `agent.reasoning_language` setting only controls the visible "thinking" or reasoning trace displayed to the user. As implemented in the DeepSeek-Reasonix source code, it does not influence the language of the final model response, code identifiers, or any hidden internal reasoning processes.

### Why does my reasoning language setting reset between sessions?

Check for a project-local [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) file in your working directory. According to the resolution order implemented in [`internal/config/config.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/config/config.go), project-level configurations take precedence over user-level settings stored in `~/.reasonix/config.toml`. If the project file specifies a different value, it will override your user-level preference when working in that directory.

### Which configuration method should I use for team-wide consistency?

Use the project-level [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) file. Committing this file to your repository ensures all team members share the same reasoning language visibility settings when working in the project directory, as it takes precedence over individual user configurations.

### How does the reasoning language setting impact API costs or latency?

The `auto` setting provides the best cache efficiency because it injects no additional instructions into the prompt. When using `zh` or `en`, DeepSeek-Reasonix temporarily adds a `<reasoning-language>` block to the user turn, but this does not alter the system prompt or tool schemas, preserving cache hit rates while minimally increasing token count for that specific turn.