Reasonix vs HagiCode: Features and Comparison

HagiCode is a proposal-driven AI coding workbench that turns a request into a reviewable proposal, runs it through agent CLIs such as Claude Code, Codex and GitHub Copilot, and keeps the outcome as team knowledge.

Reasonix is an MIT-licensed open-source coding agent that runs on your machine, with a DeepSeek preset and support for any OpenAI-compatible model. HagiCode is a workbench that runs Reasonix through its ACP mode and adds sessions, proposals and commit tooling.

Install HagiCode Desktop

English2026-10-16

Short answer

Reasonix is an open-source coding agent that reads your project, edits files and runs commands and tests, with permission levels and rewind built in. You pick the model: DeepSeek ships as a preset and any OpenAI-compatible service is a config entry. HagiCode is a workbench that starts Reasonix as an executor and wraps it with parallel sessions, spec proposals, commits and history. It does not replace Reasonix and it does not provide models.

If you mainly want a terminal, desktop or editor agent with a cheap model and your own simple workflow, stay with Reasonix alone. Add HagiCode when you run several tasks at once or want each change to start from a written proposal.

Reasonix vs HagiCode at a glance

AspectReasonixHagiCode
What it is

Open-source coding agent: reads code, edits files, runs commands and tests in your project folder

AI programming workbench that runs agent CLIs, including Reasonix, as executors

Interface and platforms

Terminal UI, Studio desktop app, browser (reasonix web), VS Code, other editors over ACP; macOS, Linux, Windows

Desktop app (Windows, macOS, Linux), Docker Compose container, Microsoft Store edition

Pricing and licensing

MIT-licensed and free; you pay the model provider directly

Desktop and Container editions free; Store edition free base, optional one-time TurboEngine purchase

Model and provider access

DeepSeek preset; any OpenAI-compatible endpoint is a config entry; optional executor plus planner model

Hosts no models; uses the providers in your Reasonix config, or OmniRoute if you configure it

Parallel work

Subagent profiles within a session

Several sessions side by side, managed as named Agents

Spec and planning workflow

Plan mode: work starts only after you approve the plan

OpenSpec proposals: propose, validate, apply, archive

Git and commit handling

Per-turn file checkpoints let you rewind edits without touching git history

AI-written commit messages with repository locking; Git management in the UI

Asking you questions

Built-in ask tool with options

Shows each question in the conversation; one option per question, then continues the run

Setup effort

npm i -g reasonix or a desktop download, then reasonix setup to pick a model

Install Reasonix first, then HagiCode, then pick Reasonix as the Agent CLI

Best for

Developers who want a config-driven agent on a low-cost model, in terminal, desktop or editor

Running several Reasonix tasks across repos with specs, review and history in one place

What Reasonix does well

Config-driven, not hardcoded to one model

Providers, the agent, enabled tools and plugins are all declared in reasonix.toml. DeepSeek is a built-in preset, and any OpenAI-compatible endpoint is added as configuration rather than code.

You can optionally run an executor model and a planner model together, each in its own cache-stable session.

Autonomy you can dial and undo

Permission levels let you have it ask every time or let everyday actions run on their own, and your forbid rules always hold. Plan mode starts work only once you approve.

A file is saved before it changes, so you can rewind by conversation turn without touching git history. Only files changed by its edit tools are covered, not what a shell command did.

Cache-aware context handling

Startup injects a small, stable environment summary, and stale tool output is trimmed before summary compaction. The project describes this as cache-aware, which matters on providers that discount cached prompt prefixes.

Four ways in, one engine

Terminal, the Studio desktop app, a browser UI started with reasonix web, or an editor over ACP all run the same local engine. MCP servers and Extension Protocol sidecars add tools, prompts and events.

Reasonix ships on two lines: 2.x (Studio, in active development) and 1.x (stable, maintenance). Check which one you install.

When to choose Reasonix, and when to choose HagiCode

Stay with Reasonix when

  • Choose Reasonix alone if you want a config-driven agent and a cheap or self-chosen model, with DeepSeek as the easy start.
  • Choose Reasonix alone if you value permission levels, plan mode and per-turn rewind as your safety net.
  • Choose Reasonix alone if your editor already speaks ACP and you want the agent inside it.
  • Choose Reasonix alone if you work on one task at a time and keep your own notes.

Reach for HagiCode when

  • Choose HagiCode if you want several Reasonix sessions running at once, each with its own context and status.
  • Choose HagiCode if you want every change to begin with a written proposal and end with an archived record.
  • Choose HagiCode if one feature spans several repositories and you want them declared once.
  • Choose HagiCode if you want AI-written commits and a browser editor next to your sessions.
  • Choose HagiCode if you switch between agents and want one interface for Reasonix, Claude Code, Codex and others.

Using Reasonix together with HagiCode

HagiCode does not bundle or replace Reasonix. It finds the reasonix executable, checks its version, and starts it in ACP mode for each run, so your install, provider keys and reasonix.toml stay as they are.

Model choice goes through the references defined in your Reasonix configuration; an undefined model fails the turn with a clear error instead of silently falling back.

  • Install Reasonix (for example npm i -g reasonix, or brew install esengine/reasonix/reasonix on macOS) and run reasonix setup to configure a provider and model.
  • Install HagiCode Desktop for Windows, macOS or Linux.
  • In HagiCode, choose Reasonix as the Agent CLI and enter a model reference defined in your Reasonix configuration.
  • Open a repository and start a session or a proposal.
  • Expect output and tool calls to stream into the conversation; enableYolo is off by default and you can switch it on in HagiCode's Reasonix settings.
  • To go back, run reasonix in your terminal as before. Your configuration and sessions are not locked to HagiCode.

What HagiCode adds on top of any agent

Parallel sessions and Agents management

Every Reasonix run in HagiCode is its own session, so one can handle a bug while another builds a feature. Agents management shows the status of each, instead of several terminals.

OpenSpec proposals

Reasonix's plan mode approves a plan inside one session. HagiCode's propose, validate, apply, archive flow keeps that plan as a durable record. Free editions allow 3 concurrent proposals.

AI commit and Code Server

HagiCode writes the commit message from your diff and locks the repository while it commits. The embedded Code Server opens files Reasonix changed in a browser editor.

Monospecs and Vault

Monospecs lists your repositories in one file so Reasonix starts a proposal knowing the whole change surface. Vault keeps reference projects and notes that new proposals can use as context.

OmniRoute, tool-call view and TokenMonitor

Reasonix already takes any OpenAI-compatible endpoint, so OmniRoute fits as one more route you can select. Reasonix's tool calls use the same format as other agents, and an optional TokenMonitor status-bar item shows today's tokens and cost.

Interactive questions

When Reasonix asks a question, HagiCode shows it in the conversation, the session waits for a reply, and your answer continues the same run. Each question takes one of the options Reasonix offered, and each answer is stored with the session.

  • Questions asked at the same time can be answered in one submission;
  • A question unanswered after 30 minutes expires and can still be answered by a follow-up message;
  • Enabled per CLI by the interactive-control setting.

The bottom line

  • Reasonix is a free, MIT-licensed, config-driven agent; HagiCode is a workbench that runs it and does not replace it.
  • Stay with Reasonix alone if you want permission levels, rewind and your own model choice with a light workflow.
  • Add HagiCode for parallel sessions, proposals, commit assistance and multi-repo context around the same Reasonix install.
  • Your Reasonix configuration is untouched, so you can try HagiCode and return to the terminal at any time.

Frequently asked questions

Is Reasonix free?

Reasonix is MIT-licensed and free to install. You pay the model provider directly, so cost depends on the model and provider you configure. See the Reasonix repository for current details.

How do I install Reasonix?

Run npm i -g reasonix on any OS, or brew install esengine/reasonix/reasonix on macOS, then reasonix setup to pick a model. The Studio desktop app and 2.x CLI archives are on the GitHub releases page of esengine/DeepSeek-Reasonix.

Does Reasonix only work with DeepSeek?

No. DeepSeek is a built-in preset, but any OpenAI-compatible service can be added as a config entry in reasonix.toml.

Can I use Reasonix with HagiCode?

Yes. HagiCode lists Reasonix as an Agent CLI and runs it through reasonix acp. Install Reasonix and configure a provider, then select it in HagiCode.

Does HagiCode replace Reasonix?

No. HagiCode is the workbench around Reasonix, adding sessions, proposals, commits and history. It needs Reasonix installed and configured to run.

Reasonix vs HagiCode: which should I pick?

Pick Reasonix alone for a config-driven agent on the model you choose, one task at a time. Add HagiCode for parallel sessions, proposals and visual history around it.

Desktop

Localized AI code assistant, privacy protection, enhanced efficiency