DeepSeek-Reasonix: Terminal Coding Agent for DeepSeek

Reasonix: A DeepSeek-native AI coding agent for your terminal

[Reasonix image: docs/logo.svg]

Introduction

Reasonix is a DeepSeek-native AI coding agent designed to live in your terminal. It’s built around a core principle called prefix-cache stability, an invariant that keeps token costs predictable even as you run long, multi-step sessions. In short, Reasonix is engineered to stay responsive and affordable by maximizing cache hits and minimizing wasteful recomputation.

To see Reasonix in action, imagine an AI coding assistant that can read and edit files, run shell commands, and plan complex workflows without exploding your token budget. It’s designed to be left running in the background over long coding sessions, with a transparent cost model and a steady, byte-stable cache. This is DeepSeek-powered tooling at a systems level, not a quick one-off AI pass.

Visual snapshot

Hero terminal view: Reasonix code mode — assistant proposes a SEARCH/REPLACE edit; nothing on disk until apply. This illustrates the core loop: edits are staged and only written when you approve them.
Capability grid: a panoramic view of Reasonix features—cell-diff rendering, MCP-based planning, memory and hooks, semantic search, persistent sessions, and more.

[Hero image: docs/assets/hero-terminal.svg]

Why Reasonix stands out

Persistent, low-cost sessions: Reasonix is designed so you can start a session and let it run with predictable memory and token usage. The loop is optimized for cache stability, not just raw speed.
Real-world reuse of data: the DeepSeek-backed cache provides the “prefix cache” that remains valid across long sessions. This is not a toggle you switch on; it’s an invariant in how Reasonix operates.
Transparent economics: in a real user scenario on a single day (May 1, 2026), a test workload of 435 million input tokens achieved a 99.82% cache hit rate, costing roughly $12 rather than the $61 you’d expect without cache. The case study demonstrates how the architecture’s four mechanisms (Pillar 1–Cache-first loop, Pillar 2–Tool-call repair, Pillar 3–Cost control, and related strategies) work together to keep costs down.
Community-driven and open: Reasonix is open source, community-developed, and documented to help contributors build parallel capabilities, fix issues, and propose enhancements in a collaborative ecosystem.

Install and getting started

Reasonix runs on Node.js (minimum version 22) and supports macOS, Linux, and Windows (PowerShell, Git Bash, Windows Terminal). The goal is to give you a smooth start with the CLI surface you’ll use most often.

Getting started options

Global install (recommended if you want the reasonix command on your PATH):
npm install -g reasonix
reasonix code my-project
On first run, paste a DeepSeek API key when prompted (the key persists across sessions).
One-shot or local usage (no global install required):
npx reasonix code
Or for a shorter alias:
- npm install -g dsnix
- npx dsnix@latest code
Quick alias alternative: the alias dsnix is a shim that points to Reasonix, so you can use either path.
Default behavior: running reasonix with no subcommand launches the code mode in the current directory.

Core commands (at a glance)

reasonix or reasonix code [dir]: The coding agent. Start here to dive into a project.
reasonix chat: Plain chat mode—no filesystem or shell tools. A good partner for thinking and brainstorming.
reasonix run "task": One-shot, streaming output to stdout. Great for piping tasks in scripts.
reasonix doctor: Health check for Node, API key wiring, and MCP setup.
reasonix update: Upgrade the Reasonix runtime.
Other subscommands (replay, diff, events, stats, index, mcp, prune-sessions) exist; see the CLI reference for details.

QQ channel and desktop client

QQ channel: Extend an existing session with QQ messages (CLI and desktop flow). It’s designed to route conversations back into the current session seamlessly.
Desktop client (prerelease): A native Tauri-based GUI. It mirrors the CLI loop, supports multi-tab workflows, and shows files read or edited in the current session with live cost and cache meters. The desktop bundles its own Node runtime and uses the same authentication and DeepSeek API key. Installers are available from GitHub releases.
Desktop caveats: macOS Gatekeeper may require an initial workaround; Windows may show SmartScreen prompts; Linux ships as .deb or AppImage.

Choosing the right mode

code: The full feature set. Filesystem access, editing, and review with a dedicated SEARCH/REPLACE review loop.
chat: A lighter, tools-off shell—great when you want a thinking partner without disk access.
dir switching and scope: Reasonix scopes filesystem tools to the launch directory. If you need to target another folder, pass --dir to retarget. Mid-session folder switching is not supported by design to avoid path ambiguity.

Design principles you’ll notice

Plan-first workflow: Reasonix uses a plan mode to structure tasks, place “skills” and “memory” in a coherent, per-workspace context.
Prefix-cache invariants: Across the architecture, cacheability of data is maintained as a core invariant, not a feature toggle.
Transparent configuration: You’ll find a robust configuration model that ties to a single JSON file in your home directory, with per-project overrides.

Deep configuration and what to tune

Reasonix uses a single JSON file for configuration, with per-project overrides under your project’s .reasonix folder. The key areas you’ll configure include:

MCP servers: Unified interface for stdio, SSE, and streamable HTTP. One spec format covers both config.json and --mcp usage.
Skills: Markdown-based playbooks the model can invoke—either inline or as subagents.
Memory: User-private knowledge pinned to the prefix. Types include user, feedback, project, and reference.
Hooks: Shell commands triggered by lifecycle events (PreToolUse, PostToolUse, UserPromptSubmit, Stop).
Permissions: Per-workspace allowlists for exact-prefix matches.
Web search: Mojeek by default; optional self-hosted SearXNG or Metase with /search-engine.
Semantic index: The internal index for embeddings used by reasonix index, open to OlLama or any OpenAI-compatible endpoint.

To dive deeper, consult the Configuration Guide and related docs:

Configuration Guide
Chinese version: configuration in Chinese
Skills, Memory, Hooks, Permissions, Web search, Semantic index sections

What makes Reasonix different

Reasonix is built around three pillars that address challenges that generic agent frameworks often miss because they were designed around different caching models:

Pillar 1 — Cache-first loop: A design that prioritizes data that can be cached and reused across long sessions, reducing repeated work and token costs.
Pillar 2 — Tool-call repair: A mechanism to ensure tool calls (shell commands, edits) are robust, recoverable, and reformable when needed.
Pillar 3 — Cost control: Strategies to bound risk and cost, with visibility into per-task economics and cache-driven savings.

Capabilities at a glance

MCP, hooks, skills, memory, semantic search, and per-workspace sessions
Transparent cost modeling and cache-hit instrumentation
Prefix-cache stability as an invariant that drives all loop iterations
Persistent sessions across directories, so you don’t lose state when you switch projects
A rich set of web search options (Mojeek by default, with SearXNG and Metaso as alternatives)
A local, open ecosystem for contributing skills, memory types, and hooks
An embedded web dashboard for governance and insights (alongside the CLI)

[Capability grid image: docs/assets/feature-grid.svg]

Comparison and ecosystem position

Reasonix presents a distinct approach when compared to other AI coding assistants in the space. Key differentiators include:

Backend: DeepSeek engine, offering an integrated, cache-aware experience that emphasizes cost control and local session persistence.
Licensing: MIT for Reasonix, enabling broad reuse and community contributions.
Cost profile: Optimized for low per-task costs, especially when cache efficiency is high.
Web dashboard: Yes—Reasonix ships with an embedded dashboard for live metrics and governance.
Open community development: Yes—Reasonix invites community participation, with good-first-issue labels to kick-start contributions.
Web search engines and embeddings: Mojeek by default; supports SearXNG/Metaso alternatives; embeddings via local or OpenAI-compatible endpoints.

Documentation and learning resources

Reasonix ships with comprehensive documentation to help you get started and to explore deeper integrations:

Architecture: Pillars overview and the full design writeup
CLI Reference: A complete guide to every subcommand, including slash commands and keybindings
QQ channel setup: CLI-first connection flow, desktop entry, and credentials
Benchmarks: Performance harness and cost methodology
Website: Getting started, dashboard mockups, and UI ideas
Contributing: How to contribute, error-handling rules, and design philosophy
Code of Conduct and security policies

Community and gratitude

Reasonix is open source and community-driven. The acknowledgments celebrate the contributors who have shaped the project through code, reviews, and guidance. You’ll also find a visible contributions wall and a badge for sustained advocates.

Notable contributors include developers and core maintainers who have helped build the architecture and tooling.
Acknowledgments also extend to designers who contributed branding and visual identity
The project encourages new participants to read the contributing guide and join discussions about CLI/TUI design, dashboard design, and feature wishlists.

Star history and ongoing momentum

Star history gives a sense of ongoing interest and momentum in esengine/DeepSeek-Reasonix, illustrating steady engagement over time as the project evolves and grows.

Support and how to say thanks

If Reasonix has been useful, you can support the project with donations. It’s a token of appreciation rather than a grant of feature priority.

International: PayPal
paypal.me/yuhuahui
Domestic (China): WeChat pay
WeChat Pay QR code image is provided for quick scanning

[WeChat Pay QR code image: .github/sponsor/wechat-pay.jpg]

Acknowledgments and community visuals

Acknowledgments highlight the people who contributed, with a nod to the design team as well as community contributors. The project welcomes new contributors and points readers to the contributor graph on GitHub for a full view of involvement.

Contributors wall with a rich set of avatars
Acknowledgments list celebrates dozens of individuals across roles
Acknowledgments and design credits are visible in the project’s branding section

What to explore next

Architecture and design: The Pillars of Reasonix—Cache-first loop, Tool-call repair, Cost control
Hands-on tutorials: How to install, configure, and start Reasonix in your project
Community channels: Join the bilingual Discord for setup help, workflow showcases, feature ideas, and contributor coordination
Documentation suite: Deep-dives into MCP, memory, hooks, permissions, and semantic indexing

Images and visuals you’ll find in the post

Logo and branding: docs/logo.svg
Terminal hero: docs/assets/hero-terminal.svg
Capabilities grid: docs/assets/feature-grid.svg
WeChat Pay: .github/sponsor/wechat-pay.jpg

Conclusion

Reasonix represents a focused, terminal-first AI coding agent built on the DeepSeek platform. Its design centers on the stability and predictability of the cache, ensuring that long coding sessions remain affordable and responsive. By combining a robust configuration model, a three-pillar architectural approach, and a community-driven ethos, Reasonix invites developers to explore a discipline-specific, persistent AI assistant that is as comfortable in a terminal as in a dashboard.

If you’re curious to learn more, dive into the configuration guide, review the architecture writeups, and experiment with the command-line experience. Whether you’re coding, debugging, or designing workflows, Reasonix is built to stay in your corner—quietly caching, planning, and assisting as you go.