Reasonix

Introduction

Reasonix launched in April 2026 as a TypeScript CLI — a purpose-built, terminal-native AI coding agent for DeepSeek's API with prefix-caching engineered into its core loop. It grew quickly: 6,500 stars in its first month, #2 on Hacker News, and a dedicated community of contributors.

Then in June 2026, the project underwent a complete metamorphosis. Reasonix v1.0 is a full rewrite in Go — a single static binary with zero runtime dependencies, an MCP plugin system, a companion desktop app, and multi-model support for both DeepSeek and MiMo. The original TypeScript codebase is archived. This is a new product, built from lessons learned.

The numbers bear this out: 22,200+ GitHub stars, 1,119+ commits, 53 releases, and a community that has nearly quadrupled in three weeks. The core engineering thesis remains the same — cache-first architecture for maximum DeepSeek prefix-cache efficiency — but the delivery mechanism has fundamentally changed.

Key Features

Go Rewrite — Single Static Binary

The headline change. Reasonix v1.0 is compiled Go with no runtime dependencies:

• No Node.js required. The old npm-based install needed Node ≥ 22 and pulled in a non-trivial dependency tree. The Go binary is self-contained.
• Smaller footprint. The compiled binary is ~15–20 MB depending on platform and build flags.
• Cross-platform. Pre-built binaries for macOS (Intel + Apple Silicon), Linux (amd64 + arm64), and Windows (amd64).
• Fast startup. Go's compilation model means sub-second startup compared to Node.js module loading.

Prefix-Cache Engineered Loop

The cache-first architecture that defined the TypeScript version is preserved and improved. Context is partitioned into three regions:

┌─────────────────────────────────────────┐
│ IMMUTABLE PREFIX                        │ ← fixed for session
│   system + tool_specs + few_shots       │   cache hit candidate
├─────────────────────────────────────────┤
│ APPEND-ONLY LOG                         │ ← grows monotonically
│   [assistant₁][tool₁][assistant₂]...    │   preserves prefix of prior turns
├─────────────────────────────────────────┤
│ VOLATILE SCRATCH                        │ ← reset each turn
│   R1 thought, transient plan state      │   never sent upstream
└─────────────────────────────────────────┘

Real-world usage shows 99.82% cache hit rates, reducing a 435M-token session from ~$61 to ~$12 on DeepSeek v4-flash.

MCP Plugin System

Reasonix v1.0 introduces a first-class MCP plugin system:

• Plugin discovery. MCP servers can be registered in reasonix.toml and auto-discovered at startup.
• Plugin lifecycle. Start, stop, and restart plugins without restarting the agent.
• Protocol support. stdio, HTTP, and SSE transport.
• Plugin marketplace. Community MCP servers are discoverable through the Reasonix plugin index.

Desktop App & Bot Integrations

Beyond the CLI, Reasonix now ships a companion desktop application:

• Native desktop UI. Built with a lightweight Go-based GUI layer (not Electron).
• Bot integrations. Native connectors for Feishu , Lark , and WeChat — use Reasonix from within your team's messaging platform.
• Session sync. Desktop and CLI sessions share history and configuration.
• Notification support. Desktop notifications for permission prompts, tool completions, and cost alerts.

Multi-Model Support

While DeepSeek remains the primary target, Reasonix v1.0 adds support for MiMo, with a config-driven model selection system:

• Model profiles. Define model configurations in reasonix.toml with API endpoints, keys, and parameters.
• Per-session switching. Change models between sessions without restarting.
• Cost-aware routing. Route tasks to the most cost-effective model based on complexity.

Config-Driven Architecture (reasonix.toml)

All configuration is centralized in a single reasonix.toml file:

[general]
model = "deepseek-v4-flash"
api_key = "sk-..."         # or set via REASONIX_API_KEY env

[cache]
enabled = true
pin_prefix = true

[plugins]
discovery = true
auto_start = ["mcp-filesystem", "mcp-github"]

[desktop]
notifications = true
bot_integrations = ["feishu"]

[cost]
preset = "auto"            # flash | auto | pro
max_session_cost = 5.00    # USD

Architecture: From TypeScript CLI to Go Binary

The shift from TypeScript to Go is not a port — it is a re-architecture driven by concrete constraints:

Why Go?

The esengine team cited three reasons for the rewrite:

1. Distribution simplicity. A single static binary eliminates the "npm install" friction and Node.js version requirements. Users download one file and run it.
2. Performance. Go's compilation model and goroutine-based concurrency deliver faster startup, lower memory usage, and more predictable latency than Node.js for the agent loop.
3. Plugin architecture. Go's static compilation with plugin interfaces enables a cleaner MCP plugin lifecycle than Node.js subprocess management.

"The TypeScript version proved the concept. The Go version makes it a product." — esengine team, v1.0 release notes

Migration Guide: TypeScript → Go

For existing Reasonix users on the TypeScript version (v0.x), migrating to v1.0 requires a few steps:

1. Uninstall the npm package

npm uninstall -g reasonix
# or: yarn global remove reasonix

2. Download the Go binary

Download the latest release from GitHub Releases for your platform, or build from source:

git clone https://github.com/esengine/DeepSeek-Reasonix.git
cd DeepSeek-Reasonix
make build
sudo cp reasonix /usr/local/bin/

3. Initialize configuration

reasonix init

This creates a reasonix.toml file. The CLI prompts for your API key and preferred model.

4. Migrate environment variables

If you were using environment variables (DEEPSEEK_API_KEY, REASONIX_*), the Go version reads them automatically:

export REASONIX_API_KEY="sk-..."
export REASONIX_MODEL="deepseek-v4-flash"

5. Rebuild session cache

The Go version uses a new session storage format. Old TypeScript sessions are not forward-compatible. Run reasonix doctor to verify the migration and start fresh sessions.

What Breaks

• Old session files (.reasonix/sessions/*) — not compatible with Go version
• Custom skills written against the TypeScript API — need to be ported to the MCP plugin format
• npm-based workflows (npx reasonix, reasonix as a postinstall script) — use the binary instead
• Node.js version requirements — no longer relevant

Use Cases

• DeepSeek power users. Developers already on DeepSeek who want the most cost-effective, cache-optimized agent harness available.
• CI/CD environments. The single binary is ideal for Docker containers and CI pipelines — no Node.js install step needed.
• Team collaboration. Teams using Feishu, Lark, or WeChat can interact with Reasonix through the desktop app's bot integrations without leaving their messaging tool.
• Large-session workflows. Long coding sessions with hundreds of turns where cache hit rates directly translate to cost savings.
• MCP ecosystem adopters. Developers building or using MCP servers who want a host agent with first-class plugin lifecycle management.
• Cost-sensitive operations. Teams that need fine-grained cost control with configurable per-session budgets and model routing.

Pricing

Reasonix v1.0 is free and open source under the MIT license. The full source code is available on GitHub .

What you pay for:

• A paid API key for DeepSeek (or MiMo) — rates vary by provider
• API usage costs (token consumption)

What you don't pay for:

• No subscription fees
• No usage limits
• No premium tiers
• No enterprise licensing

Getting Started

Prerequisites

• A DeepSeek API key (or MiMo API key)
• Go 1.25+ (only if building from source)

Quick Start

# Option A: Download pre-built binary
# Visit https://github.com/esengine/DeepSeek-Reasonix/releases
# Download the binary for your platform, extract, and run:

./reasonix init
./reasonix code my-project

# Option B: Build from source
git clone https://github.com/esengine/DeepSeek-Reasonix.git
cd DeepSeek-Reasonix
make build
./reasonix code my-project

Configuration

Create a reasonix.toml in your project root or home directory:

[general]
model = "deepseek-v4-flash"
api_key = "sk-..."          # or set REASONIX_API_KEY

[cost]
preset = "flash"            # flash | auto | pro
max_session_cost = 5.00

Commands

Further Reading

• Reasonix GitHub Repository — Source code, releases, issues, and community
• Official Documentation & Architecture — CLI reference, reasonix.toml reference, and architecture deep-dive
• GitHub Releases — Download pre-built binaries for all platforms
• v1.0.0 Release Notes — Full changelog for the Go rewrite
• MCP Plugin Reference — Model Context Protocol specification and server directory
• Hacker News Discussion — Original community discussion (324 points, #2 on front page)