# How to Build and Run DeepSeek-Reasonix: Complete Installation Guide

> Easily build and run DeepSeek-Reasonix with our CGO-free static binary. Follow our guide to configure the TOML file and get your DeepSeek API key for seamless operation.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: getting-started
- Published: 2026-06-23

---

**DeepSeek-Reasonix compiles into a CGO-free static binary via `make build` that runs on any major OS after you configure a TOML file and provide a DeepSeek API key.**

DeepSeek-Reasonix is an open-source AI coding assistant developed in the `esengine/DeepSeek-Reasonix` repository that drives one or two LLM models through a clean, interface-first architecture written in Go. The project produces a single static binary that encapsulates the CLI, agent coordinator, provider layer, and optional desktop UI. This guide walks you through building the binary from source and running your first interactive coding session.

## Architecture Overview

DeepSeek-Reasonix follows a modular layered architecture defined in the project specification. Understanding these layers helps troubleshoot build and runtime issues.

### Core Components

- **CLI Layer** ([`internal/cli/cli.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/cli.go)): Parses commands, assembles sessions, and delegates to the agent coordinator.
- **Provider Layer** ([`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go)): Implements the OpenAI-compatible wire protocol for services like DeepSeek, MiniMax, and Anthropic.
- **Tool Registry** ([`internal/tool/registry.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/tool/registry.go)): Registers built-in tools (file I/O, bash, grep) and external MCP plugins.
- **Permission & Sandbox** (`internal/permission/*` and `internal/sandbox/*`): Enforces per-call policies (allow/ask/deny) and filesystem confinement.
- **Desktop UI** (`desktop/*`): Optional Bubble Tea-based TUI that auto-detects terminal vs. graphical environments.
- **Configuration** (`internal/config/*`): TOML-based config system merged from flags → project → user → defaults.

## Building DeepSeek-Reasonix from Source

### Clone the Repository

Navigate to the `main-v2` directory which contains the active development branch:

```bash
git clone https://github.com/esengine/DeepSeek-Reasonix.git
cd DeepSeek-Reasonix/main-v2

```

### Compile the Static Binary

The `Makefile` wraps `go build` with `CGO_ENABLED=0` and injects version information via `ldflags`:

```bash
make build

```

This produces `./bin/reasonix` (the main binary) and `./bin/reasonix-plugin-example`.

### Cross-Platform Compilation

To build for multiple operating systems and architectures (Darwin, Linux, Windows on both `amd64` and `arm64`):

```bash
make cross

```

Outputs are placed in `./dist/reasonix-<os>-<arch>[.exe]`.

### Verify with Tests

Run the test suite to validate provider implementations, tool registries, and UI internals:

```bash
make test

```

### Install System-Wide

Move the binary to your system path (Linux/macOS example):

```bash
sudo install -Dm755 bin/reasonix /usr/local/bin/reasonix

```

## Configuring DeepSeek-Reasonix

### Initialize the Configuration

Run the first-start wizard to generate a minimal [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) in your project root:

```bash
reasonix setup

```

The generated file follows this structure:

```toml
default_model = "deepseek-flash"

[[providers]]
name        = "deepseek-flash"
kind        = "openai"
base_url    = "https://api.deepseek.com"
model       = "deepseek-v4-flash"
api_key_env = "DEEPSEEK_API_KEY"

```

### Configure API Authentication

Export your DeepSeek API key in your shell:

```bash
export DEEPSEEK_API_KEY=sk-your-key-here

```

Alternatively, allow the setup wizard to store the key in Reasonix's home `.env` file.

## Running DeepSeek-Reasonix

### Interactive Session Mode

Launch the TUI to start an interactive coding session. The binary auto-detects whether it is running in a terminal or graphical desktop environment:

```bash
reasonix

```

Inside the UI, execute `/init` to generate [`AGENTS.md`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/AGENTS.md) (project memory) before starting your workflow.

### One-Off Commands

Process single tasks without entering the interactive UI:

```bash

# Explain code via piping

echo "explain this code" | reasonix run

# Run a specific task with the default model

reasonix run "implement the TODOs in main.go"

# Use a specific model (e.g., DeepSeek-Pro)

reasonix run --model deepseek-pro "add unit tests for this function"

```

### Desktop Mode

When launched from a graphical environment, the same binary ([`cmd/reasonix/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix/main.go) entry point) loads the Bubble Tea panels defined in `desktop/*` to provide an enhanced desktop experience. No separate binary is required.

## Summary

- **Build**: Use `make build` in the `main-v2` directory to create a CGO-free static binary at `./bin/reasonix`.
- **Cross-compile**: Run `make cross` to generate distributables for all major OS/architecture combinations.
- **Configure**: Execute `reasonix setup` to generate [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) and set `DEEPSEEK_API_KEY`.
- **Architecture**: The codebase separates concerns across [`internal/cli/cli.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/cli.go), [`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go), and [`internal/tool/registry.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/tool/registry.go).
- **Run**: Start interactive mode with `reasonix` or pipe tasks to `reasonix run` for batch processing.

## Frequently Asked Questions

### What are the system requirements for building DeepSeek-Reasonix?

You need Go (version 1.21 or later) and Make installed. The build process sets `CGO_ENABLED=0`, meaning no C compiler dependencies are required, enabling clean cross-compilation for Linux, macOS, and Windows on both `amd64` and `arm64` architectures.

### Where is the main entry point in the source code?

The CLI entry point is located at [`cmd/reasonix/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix/main.go), which imports built-in components and delegates to [`internal/cli/cli.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/cli.go) for command-line parsing and session orchestration. This separation keeps the binary entry point distinct from the core application logic.

### How does DeepSeek-Reasonix handle tool permissions and sandboxing?

The application implements a policy engine in `internal/permission/*` that governs tool approvals (allow/ask/deny) and filesystem confinement through `internal/sandbox/*`. Every tool call passes through this security layer before accessing the host system.

### Can I use LLM providers other than DeepSeek?

Yes. The provider implementation in [`internal/provider/openai/openai.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/openai/openai.go) supports any OpenAI-compatible service. You can configure DeepSeek, MiniMax, Anthropic, or other compatible endpoints by adding new `[[providers]]` sections to your [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/reasonix.toml) configuration file.