What it actually does
Most coding agents degrade over a long session — context churns, the cache invalidates, and cost climbs while quality drops. Reasonix is built specifically around prefix-cache stability so that leaving it running is a reasonable thing to do.
It ships as one Go binary with four ways in: terminal, desktop app, browser, or your editor over ACP. Plan mode, a permissions system, a workspace sandbox, and per-turn checkpoints keep a long autonomous run something you can still read and undo — which is the part that usually makes people nervous.
Configuration is declarative. Providers, agent behaviour, enabled tools, and plugins all live in `reasonix.toml`; DeepSeek ships as a preset but any OpenAI-compatible endpoint is a config entry rather than new code. You can optionally run two models together — an executor and a planner — in separate cache-stable sessions.
MCP servers contribute tools, prompts, and resources, and Extension Protocol v1 sidecars extend it further.
Who it's for
- 01
Engineering teams that want autonomous runs they can audit and roll back
- 02
Cost-conscious teams where prompt caching materially changes the monthly bill
- 03
Anyone standardising on DeepSeek or another OpenAI-compatible endpoint
- 04
Developers who want one engine reachable from terminal, editor, and browser
Where it earns its keep
- Long refactors that run for hours with checkpoints you can revert to
- Keeping model spend predictable on repetitive codebase-wide work
- Running a planner model and an executor model without them thrashing each other's cache
- Standardising agent config across a team in a single committed TOML file
- Sandboxed execution so an autonomous run cannot wander outside the workspace
Use it, or skip it
Reach for it when
- You want autonomy but need per-turn checkpoints to make it reversible
- Prefix caching is a real line item and you want it engineered for, not incidental
- A single binary with no runtime to install fits your deployment story
- You need the same agent reachable from several surfaces
Skip it when
- You are committed to a provider without OpenAI-compatible endpoints
- You want a GUI-first product; this is terminal-first with other surfaces layered on
- Your work is short, interactive, and conversational — cache stability buys you little there
- You need a mature ecosystem; the project is young and moving quickly
10 automations
Ideas, not tutorials. Each one is work a team does by hand today.
- 01Engineering
Overnight refactor runs
Queue a codebase-wide migration to run overnight with checkpoints, and review the diff as a single pull request in the morning.
- 02Finance
Cache-cost dashboard
Track token spend per run with and without prefix-cache stability, and report the monthly delta to finance.
- 03Engineering
Planner plus executor split
Use a stronger model to plan and a cheaper one to execute, keeping each in its own cache-stable session.
- 04Engineering
Sandboxed dependency upgrades
Run upgrades inside the workspace sandbox, execute the test suite, and only surface the ones that pass green.
- 05Operations
Config as team standard
Commit reasonix.toml so every engineer's agent has identical tools, permissions, and providers.
- 06Engineering
Editor-triggered reviews
Over ACP, trigger a review of the current branch from inside the editor and get inline comments back.
- 07Engineering
Documentation backfill
Point a long autonomous run at undocumented modules and let it produce docs, checkpointed so you can reject bad sections.
- 08Engineering
Test coverage sweep
Identify untested paths and generate tests over a long run, with per-turn checkpoints keeping the diff reviewable.
- 09Operations
MCP tool consolidation
Register your internal MCP servers once in config so every developer's agent can reach the same internal tools.
- 10Operations
Permission policy enforcement
Define which tools an agent may call without asking, and log every request that fell outside the policy.
Want one of these running by Friday?
LimeDock builds these as real workflows inside your stack — deployed to your cloud, wired into your Slack and CRM, with the code in your repo. You pay a build fee and your own API keys, nothing else.
Source
Repository stats were read from the GitHub API and reflect the last time we refreshed this entry. The editorial breakdown above is LimeDock’s own analysis — we are not affiliated with esengine.
https://github.com/esengine/DeepSeek-Reasonix