Your AI forgets.
Your project
shouldn’t.
StateEngine is the local-first state layer for AI-built projects — durable decisions, raw-log provenance, and agent memory that survive every session, every model swap, every clear.
- Dogfooded daily on its own repo
- 5,189 tests · 261 mutation checks
- Hash-chained ledger · fsync per transaction
- Local-first · no account, no cloud
What exists today
Not a pitch deck. A running system.
StateEngine runs its own project. Every primitive below is dogfooded daily — none of it is a roadmap bullet.
Decision ledger
Hash-chained decisions, rebuilt deterministically from an append-only event log.
Raw-log floor
Every human and model turn, projected from native transcripts and never edited.
Context packets
A deterministic handoff a fresh or cleared agent can start from cold.
Memory lanes
Candidate and ratified recall, event-sourced — suggest, promote, reject, retract.
Atlas
Bounded find across the project — returns pointers and provenance, never text.
Capability router
A policy you own, scoring every model on cost, intelligence, and taste.
MCP + tools
stdio and HTTP surfaces, so any compatible client gets the whole tool set.
Seat mesh
Several models working one project at once, coordinated through a shared floor.
How it works
The loop, not the prompt.
Context windows end. Projects shouldn’t. StateEngine keeps the truth between sessions so any model can pick up where any other left off.
Bring a messy project
Folders, chats, code, exports, half-remembered decisions. StateEngine organizes without destroying — raw history is sacred.
Work with any model
Claude Code, Codex, MCP clients, or your own API keys. Models are interchangeable seats; the project is the constant.
Every turn hits the floor
Raw logs project from native transcripts — visible messages only. Hidden packets never touch the floor. Provenance always.
Truth lanes update
Decisions get ratified, memories promoted, outcomes recorded with labeled verification strength. Canon rebuilds from the event log.
The next agent resumes clean
Any model, fresh session, full project context via a deterministic packet. Zero re-prompting.
$ node stateengine.mjs packet --project my-app --last ✓ packet assembled · authority-ranked · 3.1 KB focus: "checkout refactor" · 4 seats · 12 raw-log sources $ node stateengine.mjs decide \ --key api.retry-policy \ --statement "Exponential backoff, max 3 attempts" \ --actor-type agent --actor-id codex → proposal seq 261 · PENDING — agents can’t self-ratify $ node stateengine.mjs ratify --decision-id 261 \ --actor-type human --actor-id you ✓ RATIFIED · canonical from seq 261 · hash-chainedReal commands, abbreviated output. No cloud required.
Two halves
A harness on top of a truth layer.
Atlas · in the MCP tool set
Every index answers. Ours tells you how much to trust the answer.
grep was built for a human who will read the result and judge it. Atlas is built for a model that will act on it — so it returns pointers instead of text, states why it matched, and reports how stale it is. The failure it exists to prevent isn’t a miss. It’s an agent asserting something plausible.
It says why it matched
Not a similarity score you cannot calibrate — the field that produced the hit.
It grades its own answer
Exact match, forgiving match, or no match — and whether the scan was truncated.
It reports its own staleness
Per source: offset, sequence, anchor hash, commits behind. It will say "unknown".
$ atlas_query "raw log floor watcher"{ node_id: "stateengine:main:file:src/raw-log-watcher.mjs", kind: "file", source_hash: "26ac1a76be4c7285bbb4ac23…", matched_on: ["natural_key"], coverage: "observed", query_status: "exact-token-match", candidate_scan_truncated: false, stale: false, code_index.commits_behind: 2, status: "unknown",}| grep | vector search | Atlas | |
| Returns | lines of text | similar passages | pointers + provenance |
| Why it matched | you infer it | opaque distance | stated |
| Answer grade | none | uncalibrated score | exact / forgiving / none |
| Staleness | file mtime | usually unknown | per source, with evidence |
| Can say “I don’t know” | no | no | yes |
| Leak surface | the whole file | embedded chunks | none — text is never held |
It reports the byte it read to
Four append-only sources. Two heads sit flush at EOF, one is 10,072 bytes short, and one has had its prefix change underneath it — so it answers “unknown” rather than guessing.
It marks the edge of its own sight
The committed index, solid. The uncommitted working tree, drawn as a hole and labelled. A technical drawing that includes what it cannot see.
One millisecond to find, a hundred to be sure
The bright sliver is the SQLite lookup. Everything after it is proof — re-hashing the real files, then a rotating audit of pointers nobody asked about.
Fifteen kinds, one closed set
Every node is one of fifteen typed kinds. The typology is fixed by contract.
* example only · no known limit on volume
Coming soon
Get in at the ledger layer.
The alpha opens with the exact build we dogfood: the CLI and the MCP server, running against real projects. Windows-first, Node 20+, free while we harden it.
Full CLI: decision ledger, context packets, memory lanes, capability router
MCP server over stdio + HTTP, with the whole tool set — Atlas included
Raw-log capture for the CLIs you already run
A direct line to the people building it — your reports steer the queue
install command— published when the alpha opens
What the alpha includesRegistration opens soon
Small batches. Builders first.
We’re not collecting addresses yet. When invites are ready there will be a real form here, and it will say exactly what happens to what you type into it.
FAQ
Honest answers.
StateEngine exists so claims can be checked instead of trusted. We hold the marketing to the same standard: nothing here describes something that doesn’t run yet.
Yes — as a local-first CLI and MCP server, dogfooded daily on its own repo and its first outside projects. The decision ledger, raw-log floor, context packets, memory lanes, and capability router are running code, not roadmap. What’s coming soon is the public alpha and, later, the studio UI.
No. StateEngine is local-first: your project state lives on your machine as an append-only event log, fsynced per transaction, exportable whenever you want. No account, no cloud dependency, nothing leaves your disk unless you say so.
StateEngine is model-agnostic — state lives outside the context window, so you can swap models mid-project without losing anything. Today there are native raw-log adapters for Claude Code and Codex, a BYOK API lane, and an MCP server for compatible clients. No subscription-token bypass, no credential impersonation, ever.
Memory is one lane. The core is truth: a hash-chained decision ledger with human ratification, a raw-log floor with provenance, and an explicit authority model that ranks every byte an agent sees. A vector index can tell you what’s similar; StateEngine tells you what’s true, who decided it, and what proves it.
It stays yours, on your machine. Raw history is sacred: StateEngine archives and compresses rather than deletes, permanent destruction is always manual, and hidden context packets never enter raw logs. Canonical truth cannot be silently modified by a model.
The alpha is free. Beyond that we haven’t settled pricing, and we’d rather say so than promise a shape we might change. What we will commit to: the local core stays usable, and you can always export your project state.