A new session starts warm
Open a fresh chat and the decision you reached last Tuesday is already there, with the reasoning behind it. No re-explaining the project.
How it fits
Where HeapFile fits in your AI setup
The tools you run cover one step each. HeapFile runs the length of the whole pass — and closes the loop at the end, so the next session starts where the last one stopped. It installs alongside what you already use, not instead of it.
Reading the picture
Three things the diagram is saying.
The brackets are short on purpose. A compression layer owns one step. A code graph owns one step. That focus is why they are good at it, and we are not asking you to drop either.
The bar is full width because it was built that way. Assembling the context, carrying where each fact came from, routing cheap work away from the expensive tier, and standing in front of the action are not four products stitched together. They are one layer, because each step needs what the step before it knows.
The arrow along the bottom is the part nobody else draws. It is also the one piece that cannot be added afterwards, because a fact is only worth carrying forward if you know which source and which revision it came from — and that has to be recorded as the work happens, not reconstructed later.
What changes for you
Five differences you notice in the first week.
One memory, every tool
What you worked out in one coding agent is available in the next one. Today each tool remembers separately, which means none of them really remembers.
Facts arrive with their receipts
Every answer says where it came from and whether that source has moved since. A stale fact comes back flagged as stale instead of stated confidently.
You stop paying twice
A question already answered is served from the previous answer rather than reasoned out again. Cheap work stays on a local model; the expensive tier is kept for work that needs it.
Nothing goes out without you
No message, file, or external action leaves on an agent's judgment. Each one needs your approval for that specific action, every time.
Keep what you already run
Install HeapFile as well as these, not instead of them.
Keep Headroom.
Tools like Headroom shrink what you send on a single call, and they have published the accuracy evaluations to back it. We decide what goes into the request; it makes sending that cheaper.
Keep Graphify.
Tools like Graphify answer "where is this called, what breaks if I change it" better than we do. We carry why the code is that way, who decided it, and what is still open on it.
Keep Obsidian.
Obsidian is where you think, and it should stay that way. Connect it and your notes become dated, sourced context your agent can actually use.
One number, with its limits
Cutting context is easy. Cutting it while the answer survives is the part that matters.
5 / 5correct, with HeapFile
−39.8%input tokens vs raw
0 / 5two rival compressors
On a fixed build-log task, HeapFile answered every exact check correctly while using 39.8% fewer input tokens than the raw context. Two third-party context compressors cut more tokens on the same task and got every check wrong.
Limits of this figure, stated rather than buried: five paired trials, one task, one small local model, single-turn. No confidence interval is warranted, and this is not a dollar-savings claim. A larger registered run is in progress and this page will be updated with it.
Who runs it beside their AI
One work memory, whatever the compute.
Bring your own compute. Keep one work memory.
Run Ollama, local OpenAI-compatible runtimes, or data-center inference while HeapFile carries the source links, prior decisions, and spend visibility around the models.
Every coding agent starts warmer.
Local git, project memory, MCP, and authorized developer-system connectors prepare scoped work packets before a model spends tokens rediscovering the repo.
Phone captures. Desktop completes.
Mobile captures notes, recall, and approvals while desktop remains the full local runtime for MCP, private files, browser-backed evidence, and heavy automation. See the mobile companion.
Turn content streams into reusable context.
YouTube, shorts, webinars, podcasts, and social collectors should become authorized add-ins with provenance, freshness, dedupe, and human review before model synthesis.
One layer, every job
HeapFile is the one-stop-shop for agent context.
Durable memory (Work Memory / Brain); evidence with provenance and freshness; prepare_work warmup packets; authorized connectors; HeapFile Link remote control and continuity; Team Brain; a cost governor and value reporting; local-model routing; Scout for bounded local topic learning; and approval/authorization gates. Full detail in /llms-full.txt.
Context, not model calls, is the scarce thing. Agents are getting cheaper and more numerous. A model-neutral, evidence-backed, permissioned, continuous context layer is the natural home for durable agent state — the way a database, not the app process, holds durable data.
Where HeapFile is going
From remembering the work to finishing it — as a verified loop.
Prompt engineering asks a model for an answer. Loop engineering gives it a goal and a check it cannot grade for itself, then runs the work until that check actually passes — and halts the moment it stops making real progress. No spinning, no plausible output that moves nothing. The anti-slop guarantee is in the code, not the pitch: a loop only continues while a machine-check improves, and stops honestly when it doesn't.
It runs on whatever model you already use — including a local model on your own machine, at no API cost — so you pay for progress, not attempts. Model-neutral and framework-neutral by design. Rolling out now.
- Give it a goal and a check. Tests passing, a metric threshold, a build going green — something the model cannot fake.
- HeapFile runs the loop. It reasons, re-checks, and carries the context across steps and sessions — cheaply, locally if you want.
- It stops when the check passes — or halts honestly. A loop that cannot make progress hands back what it learned instead of burning tokens looking busy.
Next step
Make the next AI session a continuation.
Open an account, then install the desktop runtime and register HeapFile as an MCP server in the client you already use. Comparisons on this page describe each tool's published documentation as of October 2026 and will go out of date; tell us if something here is wrong or stale and we will correct it.