Reasonix: DeepSeek-Native AI Coding Agent for the Terminal
esengine/DeepSeek-Reasonix
Reasonix is a terminal-based AI coding agent built specifically around DeepSeek's prefix-cache mechanism, shipped as a single Go binary with a desktop app and VS Code extension. Reach for it if you run DeepSeek models for long coding sessions and want token costs to stay flat instead of climbing; skip it if you need a mature ecosystem of third-party plugins, since Extension Protocol v1 is still young.
What is Reasonix?
Reasonix is a DeepSeek-native AI coding agent that runs in your terminal, packaged as a single static Go binary with no CGO dependency. It reads its provider, tool, and plugin configuration from a reasonix.toml file rather than hardcoding a model, and it can also run through a desktop app or a VS Code extension that shares the same local engine.
Key Capabilities of Reasonix
- ✓Config-driven setup: providers, the agent, enabled tools, and plugins all live in reasonix.toml — no model is hardcoded into the binary.
- ✓Multi-model composition: DeepSeek is the default preset, but any OpenAI-compatible endpoint drops in as a config entry, and you can run an executor model and a planner model side by side in separate cache-stable sessions.
- ✓Plugin surface via MCP servers and Extension Protocol v1: MCP servers add tools, prompts, and resources, while Extension Protocol v1 sidecars can intercept runtime events, add Providers, and ship structured UI.
- ✓Cache-aware context handling: a small stable environment summary is injected at startup, and stale tool output gets snipped or pruned before the session goes through summary compaction.
- ✓Single static binary distribution: built with CGO_ENABLED=0, cross-compiled to six targets (darwin, linux, windows × amd64, arm64) from one make command.
- ✓A documented tool schema contract, meant to make regression review of the built-in tools straightforward.
How to Install Reasonix
Documented install has four paths that all point at the same local engine. For the CLI/TUI: `npm i -g reasonix` on any OS, or `brew install esengine/reasonix/reasonix` on macOS; prebuilt archives for darwin/linux/windows on amd64/arm64 plus SHA256SUMS are attached to every GitHub release. For the desktop app: download a signed installer from the official download page — a `.dmg`/`.zip` on macOS, `.exe`/portable `.zip` on Windows (code-signed via SignPath.io), or `.deb`/`.tar.gz` on Linux. For VS Code: install the `SivanLiu.reasonix-agent` extension from the Marketplace (or Open VSX for VSCodium/Theia) after the CLI is set up, since the extension launches the local `reasonix acp` backend rather than bundling it. To build from source: `git clone` the repo, then `make build` for a single binary or `make cross` for all six targets.
Using Reasonix: CLI, Desktop, and VS Code
Once installed, `reasonix setup` walks you through configuring a provider and model, `reasonix` on its own drops into an interactive TUI session, and `reasonix run "implement the TODOs in main.go"` fires a one-off task from the shell. Inside an interactive session, `/init` has Reasonix generate project instructions. The desktop app skips the CLI commands entirely — install it, launch it, and configure a provider and model directly in the app window. The VS Code extension starts the same local engine in the background and adds chat, editor context, tool-call approvals, and workspace sessions on top; deeper CLI flags and config are covered in the project's CLI reference and Guide docs rather than the README itself.
Who Benefits from Reasonix?
Reasonix is aimed at developers who already use DeepSeek models and run coding sessions long enough that prefix-cache invalidation would otherwise reset pricing on every turn. It also suits anyone who wants one agent binary across three surfaces — terminal, desktop, VS Code — instead of separate tools per environment. Teams standardized on a different provider's API can still use it through the OpenAI-compatible config path, but the caching design is built with DeepSeek specifically in mind.
Strengths
- ✓Config lives in one reasonix.toml file — no recompiling or hardcoded model strings to change providers.
- ✓Single static Go binary (CGO_ENABLED=0) means no runtime dependency chain to install beyond a TOML parser.
- ✓The same local engine backs the CLI, desktop app, and VS Code extension, so switching surfaces doesn't mean switching agents.
- ✓Windows installers are code-signed through SignPath.io rather than shipped unsigned.
- ✓Release archives ship with SHA256SUMS for verification.
Considerations for Using Reasonix
- △Extension Protocol v1 and the plugin package format are new enough that the README points to migration docs (Migrating from 0.x), suggesting the plugin API isn't stable long-term yet.
- △The VS Code extension is a separate project (SivanCola/reasonix-vscode) that depends on the CLI being installed and running first — it's not a self-contained editor plugin.
- △The README doesn't state a current version number, release cadence, or benchmark numbers beyond GitHub stars and forks, so judging maturity requires reading the docs folder directly.
- △Non-DeepSeek providers work through an OpenAI-compatible config entry, but the caching behavior the tool is built around is tuned for DeepSeek's prefix cache specifically, not verified for other providers.
Other AI Coding Tools to Consider
Frequently Asked Questions about Reasonix
Reasonix ships DeepSeek as its default preset, and any OpenAI-compatible endpoint can be added as a config entry in reasonix.toml — Reasonix also supports running an executor model and a planner model together in separate sessions.
Reasonix keeps a small, stable environment summary at startup and prunes or snips stale tool output before summary compaction, which is designed to keep DeepSeek's prefix cache intact across a long session rather than invalidating it on every turn.
Reasonix runs on macOS, Windows, and Linux as a CLI/TUI binary (amd64 and arm64), plus a desktop app for all three OSes and a VS Code extension that also works in VSCodium and Eclipse Theia.
Reasonix is released under the MIT license on GitHub, with prebuilt release archives and SHA256SUMS published alongside the source — it's fully open source.
Reasonix takes plugins through two paths: MCP servers that contribute tools, prompts, and resources, and Extension Protocol v1 sidecars that can intercept runtime events, add Providers, and ship structured UI as versioned packages.
Reasonix has a VS Code extension (SivanLiu.reasonix-agent, also on Open VSX for VSCodium and Eclipse Theia) that starts the local reasonix acp backend and adds chat, editor context, tool-call approvals, and workspace sessions.
The problem it solves
Long AI coding sessions burn through tokens fast when every turn re-sends the full context and busts the model provider's prompt cache. DeepSeek's API specifically prices around a prefix cache that only pays off if the agent keeps the front of the context stable turn to turn — most generic coding agents weren't built with that constraint in mind, so costs creep up the longer a session runs. Reasonix's context handling (a small stable environment summary at startup, pruning stale tool output before compaction) is built around keeping that prefix intact instead of invalidating it every request.
Best use cases
- •Running a long DeepSeek coding session in a terminal without the token bill climbing every turn, thanks to prefix-cache-aware context handling.
- •Wiring an existing OpenAI-compatible model endpoint into the same agent instead of adopting a DeepSeek-only tool.
- •Working from VS Code with the reasonix-agent extension for editor context, tool-call approvals, and model selection while the CLI backend runs underneath.
- •Splitting planning and execution across two models (a planner and an executor) that each keep their own cache-stable session.
- •Extending the agent with a custom MCP server or an Extension Protocol v1 sidecar to add project-specific tools.