the ghostie stack
Today's AI rents you a memory you can't read, sends your code to someone else's servers, and asks you to trust an answer it can't justify. The ghostie stack is built the other way: small, local-first tools that keep your context in a store you own, run their deterministic core on your own machine, and verify their own output.
what it is
Small tools that each do one thing well and snap together into a loop: understand the code, render what's known, remember it, act on it, prove the result. Small parts that compose, never one monolith.
A codebase enters, and TrailTracker builds its structural model.
Provider-agnostic memory you own: your context persists across sessions, agents, and devices, in a store you can read and carry.
shipped · publicBuilds a codebase's structural model on your own machine, the offline first step the rest of the loop reads from.
built · privateAn airgapped GUI that renders those models as navigable graphs and lets a human author ontologies on top.
shipped · publicThe act node: a behavior-preserving migration orchestrator. It freezes a behavioral contract, drives the candidate through Lockstep, and refuses rather than guess when it cannot verify.
shipped · publicRuns a program and its rewrite over an explicit corpus and issues replayable, tamper-evident evidence that they behave equivalently at the observable boundary, naming exactly what it could not prove.
shipped · publicThe shared contract and health checks every tool follows, so the pieces stay small, composable, and honest as the stack grows.
shippedhow the pieces compose
The whole loop runs end to end today on one example. Scaling it past that example is the ongoing work.
The loop runs end to end today on a first example, proven in public CI: Nightshift freezes the contract, hands the candidate to Lockstep, and gets back a replayable EQUIVALENT certificate. At this milestone the candidate is supplied, so what is proven is the wiring, not regeneration quality. General, agent-driven regeneration is the next step.
what it brings
Hosted AI will remember you, run your code, and hand you answers. What it won't do is let you own any of it: the memory is rented and opaque, locked to one vendor. This stack makes your context owned, inspectable, and portable, and holds the rest of the loop to the same standard.
Hosted assistants do remember you now. But that memory is rented: opaque, unexportable, locked to one vendor's product. The ghostie stack keeps your context in a store you own and can read, portable across sessions, across agents, and across devices. What one agent learns, the next already knows, whoever's model it is.
The deterministic core, TrailTracker, Ontoloom, and Lockstep, runs entirely local: zero external dependencies, no telemetry, working with the network unplugged. The memory layer talks to whatever model you choose, so the claim stays scoped and honest; the parts that have to be trustworthy are the parts that never phone home.
It doesn't ask you to trust its confidence. It runs deterministic analysis, issues self-verifying certificates, and makes a test fail before it trusts one. The output comes with evidence attached, and it stays honest about what it cannot prove instead of bluffing past it.
shipped
The repositories linked below are real. Clone them, read the tests, read the gate. The deterministic tools carry zero external dependencies and are gated in CI.
Behavioral-equivalence verification for code migration: runs the old and new programs over the same inputs, compares them at the observable boundary, and issues a deterministic, hash-chained certificate that includes what it could not prove.
An airgapped, dependency-free ontology & knowledge-graph builder with a visual browser GUI served on localhost, exporting Neo4j-compatible formats. No cloud, no telemetry, no packages.
The memory layer: provider-agnostic context you own, persisting across sessions, agents, and devices in a store you can read and carry, whichever vendor's model sits on top.
The stack's verification discipline, packaged for any project: one script is the gate, CI is a thin wrapper, and the gate dogfoods the product on a real workload with byte-stability and tamper checks. It is the working implementation of the discipline Auftragstaktik, the stack's standard, requires.
The act node: a behavior-preserving migration orchestrator. It freezes a behavioral contract from the program, drives a candidate through Lockstep, and refuses-and-flags rather than guess when it cannot verify. The one impure step, regeneration, is boxed by deterministic trust on both sides.
The stack's understand node: builds a codebase's structural model, fully offline. The mature private engine the rest of the loop reads from.
Honest status: the stack is modular and already useful before every component is complete. Lockstep, Ontoloom, gatekit, ghostie, and Nightshift are public and working; TrailTracker is the mature private engine underneath. The loop closes end to end on a first example today; what remains is scaling regeneration past it. The vision on this page is the direction, and these are the parts already standing.
who's building it
Systems and AI engineer. I was the founding engineer at a code-intelligence startup, hired pre-product. I helped build the engineering team and designed the parsing, classification, LLM-routing, and evaluation stack that carried it to production.
My lane is deterministic understanding and verification: code that has to be right, and provably so. I work in Rust when correctness matters (zero-dependency, forbid(unsafe), byte-stable), and across the stack when it doesn't. I'm most useful where AI throughput meets senior-engineer judgment, when someone has to make the machine's output trustworthy before it ships.
The ghostie stack is where that conviction lives. It's a bet that the durable form of AI tooling will be owned, persistent, and self-verifying, rather than rented, vendor-locked, and opaque.
work with me
I build deterministic infrastructure around probabilistic systems. If that's the problem your team is facing, let's talk.
jonathan.popham@gmail.com