Skip to content

Local tools for coding agents

Pick up where you left off. Edit only what you meant to.

A coding agent starts each session from zero: it re-reads files, retries the command that failed yesterday, and forgets why you chose one approach over another. OpenState records what happened in your project and gives the next session a short summary of what is still true. When the agent edits, it changes the definition it targeted and checks the file before writing.

30 successful structural applies free per machine. Searching, reading and previews remain free. Compare all three plans.

Already purchased? Recover your key or visit the license and account FAQ.

  • 36 tools22 code + 14 state/lifecycle
  • 18 languagesStructural code operations
  • Local stateProject record on your machine
  • MCPTools for multiple agent hosts

Watch it work

Monday's decision is still there on Tuesday.

Three short recordings. The session events and tool calls are scripted; the output shown is what OpenState 0.1.0 returned.

Resume a session. On Monday a test fails and the agent decides to use a fixture key. On Tuesday a new session asks for the summary over MCP and gets the decision with its reason, the failed command and the failing test status, in 211 tokens.
Read one function. openstate_read_symbol returns debounce from lodash in a 4,497-byte response. The whole file is 544,098 bytes.
Refuse a bad edit. A preview is taken, then the file changes, and the apply is refused as stale. A text edit whose anchor appears twice is refused too, with both matches listed.

Strengths

What changes when your agent has OpenState.

  • Recorded, not remembered.

    Decisions with their reasons, failed commands, blockers and test status are recorded from the session's own events, with no model choosing what to keep. openstate_why shows where a fact came from.

  • It survives compaction.

    In OpenCode the summary is handed back at session start and after each compaction, so a long session keeps what it learned when the context is trimmed.

  • One record across your agents.

    Switch agents mid-project and the next one can see the same decisions and failures. Automatic in OpenCode; Claude Code, Codex and Muse ask for the summary with one openstate_capsule call.

  • Edits check before they write.

    Each change is previewed first. The apply refuses if the file changed since the preview, and lists the matches when a target is ambiguous instead of guessing.

  • It reads the function, not the file.

    The agent reads one definition instead of opening the whole file. In the recording above, one function from a 544 KB file comes back in 4.5 KB.

  • A handoff small enough to send each time.

    The resume summary is about 500 tokens at the median and about 1,600 at most.

  • Local, with no account.

    Project facts and code stay on your machine. There is no sign-up to start, and recording uses no model, so it spends no tokens.

  • Used all day by the person who built it.

    99.91% of 21,372 OpenState calls in the maintainer's June-to-September sessions succeeded. That is one developer's use, not a controlled study.

  • Priced like a utility.

    Free to start, then $10 a month or $129 once for the 0.x releases. Each plan has the complete set of 36 tools.

What it does

Precise code operations. A memory of the work.

The two capabilities solve different problems, and both come in the same installation.

Work with definitions, not guessed line numbers.

Find a symbol, read its complete definition, preview a rename or edit, and apply it once. Guarded writes refuse stale, missing, or ambiguous targets.

  • Symbol search, read, and navigation
  • Rename, insert, replace, delete, and move
  • Safe text edits in Markdown and configuration
All 36 tools, with actual names

Know what the last session already tried.

OpenState derives project facts from session events: objectives, decisions, failed commands, blockers, active files and test outcomes. OpenCode restores a short capsule automatically; other hosts request it over MCP.

  • Inspect the reason and source of a decision
  • Check what failed and what remains blocked
  • Carry work across sessions and compactions
How the local state engine works

One normal edit

Find. Read. Preview. Apply. Resume.

A preview shows the intended write. The separate apply step checks it against the current files.

  1. 01
    Find

    Locate the definition.

  2. 02
    Read

    Retrieve the relevant code.

  3. 03
    Preview

    Inspect the proposed change.

  4. 04
    Apply

    Write once—or refuse if stale.

  5. 05
    Resume

    Use the project record next time.

Evidence, with limitations

Smaller reads. A short handoff. Heavy daily use.

These are observations from the maintainer's projects, not a controlled experiment. They do not establish guaranteed savings in other projects.

97%

Less returned data in one measured read of a function compared with reading the entire 63 KB file. This is a byte comparison, not a cost claim.

~500

Tokens in the resume summary at the median, and about 1,600 at most.

99.91%

Of 21,372 OpenState calls in the maintainer's June-to-September sessions succeeded.

Read the data, methodology and caveats

Know what your host supports

Switch agents without starting over.

The project record goes with the project: what was decided and why, what failed, what is blocked, and whether the tests passed since the last edit. In OpenCode it is recorded and handed to each new session automatically. In Claude Code, Codex and Muse, the agent asks for the summary with one openstate_capsule call and can replay that host's stored sessions into the record.

Tool access and automatic context delivery are different capabilities. We describe each separately.

OpenCode

Native plugin, automatic event capture, and capsule injection at session start and compaction.

Claude Code, Codex, Muse

Same tools through MCP; assessment of supported stored session histories on demand.

Cursor, Kiro, Copilot and other MCP clients

MCP tool access. Do not assume automatic capture or native context injection.

Local by design

Project facts stay on your machine. Licensing uses Keygen and the OpenState license worker; project code is not sent for license checks.

Review the detailed host support matrix

Why I built this

My agents kept starting over.

I run coding agents through most of the working day, and the same things kept costing me time. A new session, or a compaction inside one, started from zero: the agent re-read files to work out what it was doing, retried the command that failed an hour ago, and argued itself back into an approach I had already rejected. When it edited, it rewrote text it had matched by eye, sometimes in the wrong place.

I built OpenState to fix that for my own work, and I use it hundreds of times a day. It is one developer's tool, measured on one developer's projects, and the evidence page says so.

Michael Kuykendall

Pricing

Every plan has the complete toolkit.

The difference is how many structural writes you can make. Choose a subscription or a one-time license if it proves useful.

Try it

$0

No account to start

  • All 36 tools
  • Unlimited searching, reading and previews
  • 30 structural applies per machine
Install free

Monthly

$10 / mo

Cancel when you want

  • Unlimited structural applies
  • One developer, up to three machines
  • Access during paid subscription
Subscribe for $10/month

Save your license key before closing the success page after payment. Keep it in your password manager. Need help or want to request a refund? Email mkuykendall@deltazerolabs.dev from your purchase email. Recover a lost key.

All sales are final. Stripe handles payments and Keygen issues your license. Full pricing details · Terms · Refund policy.

Install

Install in the repository where you work.

Node.js 18+ is required. Run from a Git repository; the installer installs there by default. Add --global if you deliberately want it in every repository. On Windows, run the script from Git Bash.

curl -fsSL https://raw.githubusercontent.com/Michael-A-Kuykendall/openstate/main/install.sh | bash

Restart OpenCode to load the native plugin. Other agents register the bundled local MCP server. For setup, verification and uninstall instructions, see the installation documentation.

Connect a different coding agent

The important limitations

What the tools do—and what they don't.

Clear boundaries matter more than promising that an agent becomes infallible.

Does it record everything an agent thinks?

No. It processes the session events the host exposes, not hidden reasoning or work you do outside the observed host. You can inspect the recorded facts and their provenance.

Are edits guaranteed to be correct?

No. Preview and apply checks guard the target and write operation. The implementation still needs normal tests and review.

Is session recovery automatic in every host?

No. OpenCode supplies automatic capture and injection. MCP clients can call the tools and assess supported history on demand; actual availability depends on the host.

Does the $129 license include future major versions?

No. The one-time offer covers every 0.x release. It does not promise access to future 1.x or later lines.

See how it handles your project

Start free. No account needed.

Read and search freely, then evaluate the guarded write path with 30 successful applies.

Install free