Reasonix

Introduction

Reasonix is an open-source (MIT), terminal-native AI coding agent purpose-built for DeepSeek’s API. Unlike generic agent frameworks that happen to support DeepSeek , Reasonix treats DeepSeek’s prefix-caching mechanics as a first-class engineering constraint that shapes every architectural decision. This approach makes it the most cost-effective coding agent available for the DeepSeek ecosystem — real-world usage shows 99.82% cache hit rates, reducing a 435M-token session from ~$61 to ~$12.

Installed via a single npm command, Reasonix provides a full terminal UI with file editing, shell access, MCP tool integration, plan mode, a skills/memory system, and per-workspace session persistence. It runs on macOS, Linux, and Windows with Node ≥ 22.

Key Features

• Cache-first loop — Context is partitioned into an immutable prefix (cached for the session), an append-only log (preserves prefix stability), and volatile scratch (reset each turn). The prefix is pinned once per session with no dynamic injection.
• 99.82% cache hit rate — Documented real-world data from a full day of coding on May 1, 2026: 435M input tokens at ~$12 on v4-flash versus ~$61 without cache optimization.

Tool-call repair engine — Automatically handles DeepSeek -specific failure modes: flattens deep schemas, scavenges tool calls from reasoning content, repairs truncated JSON, and suppresses duplicate tool calls.

• Cost-control presets — Three modes (flash, auto, pro) with turn-end auto-compaction, /pro single-turn arming, and failure-signal auto-escalation to v4-pro.
• Parallel tool dispatch — Tools declare parallelSafe: boolean; safe calls run concurrently via Promise.allSettled while mutating edits remain serial.

Full TUI — Ink -based terminal interface with file editing, shell commands, MCP integrations, plan mode, and a companion web dashboard.

• Skills and memory — Per-workspace session persistence, user-defined skills, hook system, permission management, and web search capability.
• Subcommands — reasonix code (default coding agent), reasonix chat (plain chat), reasonix run (one-shot), reasonix doctor (health check).

Architecture: The Three Pillars

Reasonix’s architecture rests on three design pillars, each solving a failure mode that generic agent frameworks don’t address.

Pillar 1: Cache-First Loop

DeepSeek’s automatic prefix caching activates only when the exact byte prefix of a request matches the previous one. Most agent loops are cache-hostile — they inject timestamps, reorder tool histories, rewrite context, or mutate session state mid-conversation, invalidating the cache prefix.

Reasonix partitions the context 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
└─────────────────────────────────────────────────────┘

Three invariants maintain cache stability: the prefix is computed once and pinned for the session, log entries are strictly append-only, and volatile reasoning state lives outside the cached prefix entirely.

Pillar 2: Tool-Call Repair

DeepSeek models occasionally emit malformed structured tool calls — deeply nested schemas, tool calls embedded in reasoning content, truncated JSON, or duplicate invocations. Reasonix handles them through four mechanisms:

• flatten — Schemas with >10 leaf parameters or depth >2 are auto-detected and presented in dot-notation; args are re-nested before execution.
• scavenge — Regex + JSON parser sweeps the model’s reasoning content for tool calls not emitted in the structured tool_calls field.
• truncation — Detects unbalanced JSON and either closes braces or requests a continuation completion.
• storm — Duplicate (tool, args) tuples within a sliding window are suppressed; the model gets a reflection turn instead of repeating itself.

Pillar 3: Cost Control

Three presets let users trade model tier for cost:

Three mechanisms enforce cost discipline: turn-end auto-compaction shrinks tool results exceeding 3000 tokens, /pro arms a single v4-pro turn then auto-disarms, and failure-signal auto-escalation promotes hard turns to v4-pro with a visible warning.

Installation & Setup

Requirements: Node.js ≥ 22, a paid DeepSeek API key.

npm install -g reasonix

Or run directly without installing:

npx reasonix code

On first run, Reasonix prompts for your DeepSeek API key and stores it locally. The tool is also available via the dsnix alias and runs on macOS, Linux, and Windows.

Commands & Usage

Inside the TUI, users can switch cost presets with /flash, /auto, and /pro commands, access plan mode, manage skills and memory, and monitor real-time token and cost meters.

How It Compares

The engineered prefix-cache support is what sets Reasonix apart. Aider supports DeepSeek (native API or OpenRouter) but its loop isn’t designed for prefix stability. Claude Code is DeepSeek-compatible via API proxy but optimized for Anthropic’s models. Cursor is a full IDE — a different category entirely.

Use Cases

• Cost-conscious DeepSeek users — Developers already on DeepSeek who want to maximize every API dollar through deliberate cache optimization.
• Large-session workflows — Long coding sessions with hundreds of turns where generic clients bleed budget on cache misses.
• Terminal-first developers — Engineers who prefer a CLI/TUI workflow over IDE plugins and want a full-featured coding agent without leaving the terminal.
• Teams evaluating DeepSeek — Organizations assessing DeepSeek as a primary coding model, using Reasonix as the reference agent harness.
• MCP-heavy workflows — Developers using Model Context Protocol servers who want tight integration with file editing, shell access, and web search.

Community

Reasonix is developed by esengine, a community project not affiliated with DeepSeek. The repository has accumulated ~6,500 GitHub stars, 1,338 commits, and 30+ contributors under the MIT license. The project reached #2 on Hacker News ’s front page with 324 points. Community engagement happens primarily through GitHub issues and a bilingual (English/Chinese) Discord server.

Further Reading

• Reasonix GitHub Repository — Source code, releases, and community discussions
• Official Documentation & Architecture — CLI reference, configuration guide, and three-pillars architecture
• npm Package — Install Reasonix via npm
• Hacker News Discussion — Community discussion (324 points, #2 on front page)

Conclusion

Reasonix fills a specific niche: the most cost-effective coding agent for DeepSeek’s API, built from the ground up around the provider’s caching mechanics. The cache-first loop delivers real-world savings that generic frameworks can’t match — 99.82% cache hit rates and 80% cost reduction are not theoretical benchmarks but reproducible outcomes of deliberate architecture. For developers committed to DeepSeek or evaluating it as a primary model, Reasonix is the current benchmark in DeepSeek-native agent design.