# HeapFile AI — full description for AI agents and crawlers > HeapFile gives the AI you already use a memory of your work, so every session starts where the last one left off. How it works: 1. Install it beside your AI. HeapFile runs on your computer next to Claude Code, Codex, Gemini CLI, Cursor, or VS Code. Your AI stays the same. 2. It remembers the work and the evidence. Findings, decisions, and open tasks are saved with where they came from, so the next session starts warm instead of re-reading everything. 3. It never acts without you. Anything that leaves your computer or changes a system waits for your approval. In product terms, HeapFile is the durable context layer for AI agents: persistent work memory, sourced evidence, permission boundaries, and cross-session continuity around whatever model you already use. Models are the engine; HeapFile is the memory, the evidence, the guardrails, and the hand-off the engine does not keep on its own. This file is the complete expanded description. The concise index is at https://heapfile.ai/llms.txt and the machine-readable feature manifest is at https://heapfile.ai/features.json. ## The problem An AI session is stateless. Every new chat, every coding-agent run, every new device starts cold: it re-reads the same repository, re-asks the same questions, re-derives the same decisions, and remembers nothing about what was already approved or already proven. HeapFile is the layer that fixes that. It sits beside the model, not inside it, so it works the same whether you drive Claude Code, Codex, Gemini CLI, Cursor, a local Ollama model, or a data-center runtime. ## How HeapFile plugs into your existing AI flow You do not replace your model or your client. HeapFile connects over MCP (and editor/CLI hooks) so the client you already use gains memory and evidence: 1. Install the desktop app and register HeapFile as an MCP server in your AI client. The free tier covers this. 2. Your agent calls prepare_work before it starts and gets a scoped work packet (relevant prior memory, decisions, and evidence) instead of spending tokens rediscovering the project. 3. As the session produces durable conclusions, they are saved to Work Memory so the next session — in the same client or a different one — starts warm. 4. When the agent needs evidence, HeapFile supplies it with provenance from authorized local sources (and, on Premium, authorized connectors). 5. Actions that reach outside stay behind approval and authorization gates, so memory and automation never become unreviewed outbound actions. ## The jobs HeapFile does (one context layer, not one utility) - Durable memory (Work Memory / Brain): save and recall context across sessions and clients. Local-first and free on one device; Premium adds encrypted cross-device sync and Team Brain. - Evidence, provenance, and freshness: answers come with where they came from and how current they are. Local repo evidence is free; managed source connectors are Premium. - prepare_work / warmup packets: a scoped, ready-to-use context packet at the start of a session instead of a cold start. Free. - Connectors: authorized retrieval of evidence from real systems. A listed connector is not an authorized connector. - HeapFile Link: a remote-control and continuity surface to bring a session's context to another device or participant. Local and preview today; hosted Link calls are not available in production yet. - Team Brain / team workspaces: shared, role-scoped context with connector policy and clean boundaries between personal memory, team memory, and customer evidence. Premium. - Cost governor / value reporting: the local Value Ledger shows measured activity and context reuse on this device for free; team- and organization-level savings reporting is Premium. We report measured local proof, never inflated or fixed savings numbers. - Local-model routing: use local models (Ollama / local OpenAI-compatible runtimes) or data-center inference while HeapFile carries the context around them. - Scout: bounded local topic learning. heapfile_scout maps a topic across permitted local files with strict file, time, and byte budgets, no whole-disk crawling, and zero hosted-model calls. Free and local-only. - Approval / authorization boundaries: permission levels, a policy engine, and send gates decide what an agent may read and what it may do, and the product reports the permission level and data route before any connection. ## Every free feature (source of truth: /features.json) - Local memory and recall: save and recall personal or sandbox context on this computer without uploading private data by default. Boundary: stored on this device; no managed backup, cross-device sync, or team sharing. - Desktop AI client setup: connect compatible desktop AI clients to HeapFile and start with prepare_work before broad searches. Boundary: manual setup only. - Personal capture and handoff demos: local capture, mobile companion demos, and manual handoff flows for pilot feedback. Boundary: manual handoff; no reliable mobile relay, notification loop, or cloud queue. - Mobile low-power helper: phones, tablets, and foldables for short foreground capture, selected recall, and approval review without running heavy AI jobs on the device. Boundary: no background sync, no managed connector refresh, and no on-device local model execution. - Local repo evidence: use local checked-out repositories as evidence when they are already on this machine. Boundary: only local files already present; no managed GitHub/AWS/Microsoft evidence retrieval. - HeapFile local value proof (Value Ledger): see local value measurements, context reuse, setup checks, and no-cost background snapshots before paying. Boundary: free reports this device's measured local proof only. ## Premium features (unlock only after server-side entitlement + authorization) - Encrypted cloud sync: sync selected memory, captures, device state, and handoff packets across trusted devices. - Mobile-to-desktop handoff: queue phone and tablet captures to a trusted desktop or cloud-brain relay. - Smart connectors: HeapFile-owned GitHub, AWS, Microsoft 365, Jira, Confluence, and source-system connectors with explicit authorization. - Savings path and usage reports: measure avoided connector calls, repeated searches, and context waste with defensible reports. - Team workspaces: organization profiles, team policy, shared setup, support workflows, and admin-managed access. - Advanced automation: cloud-backed workflows, device relay, premium handoff queues, and higher-value automation gates. - HeapFile max context engine: context readiness, compatibility intake, team savings proof, and background context availability across authorized connectors. ## Connectors (status is honest; see /connectors.json) A listed connector is not an authorized connector. Ready now: Local files, Local Git, MCP tools, Ollama local AI, and GitHub. Preview (setup or rollout proof still required): Jira, Confluence, Azure DevOps, GitLab, Bitbucket. The GitHub connector is a read-only GitHub App a repository owner installs on repositories they choose; it flows one way, into that owner's own HeapFile, never exposes HeapFile source code, and never shares one user's repositories with another. Everything else in the catalog is cataloged or research compatibility, not a live public integration. The full machine-readable catalog, with per-route authorization, permission level, data route, and non-affiliation boundary, is at https://heapfile.ai/connectors.json. ## Privacy and data boundary HeapFile is local-first, not local-only. Local sources and eligible local model routes can remain on the device. A cloud connector contacts its provider only through a route the user or administrator authorizes, and the product identifies the permission level and data route before connection. Telemetry is off by default. ## Why this is the future of agent context Agents are getting cheaper and more numerous. The scarce thing is not model calls — it is trustworthy, portable, governed context that survives across sessions, clients, devices, and teammates. A context layer that is model-neutral, evidence-backed, permissioned, and continuous is the natural home for that, the way a database — not the application process — is the home for durable state. ## How HeapFile compares to a context-compression layer A context-compression layer shrinks tool outputs, logs, files, and history before they reach the model. That is a different layer from HeapFile and a complementary job. HeapFile is durable memory, evidence/provenance, governance, and cross-session continuity; compression is one job inside a single session's context window. HeapFile includes compaction as one internal module, but exists for memory and evidence. HeapFile does not claim to beat a dedicated compressor on token-reduction benchmarks. The honest contrasts are scope, telemetry-off-by -default, cross-session continuity, and installable distribution for non-developer, IT-managed, executive, and mobile buyers. ## Domains and pointers - https://heapfile.ai/ — product, install, setup, and workflow surface. - https://heapfile.ai/features.json — machine-readable Free/Premium feature manifest. - https://heapfile.ai/connectors.json — machine-readable connector catalog. - https://heapfile.ai/connectors.html — human-readable connector catalog. - https://heapfile.ai/pricing.html — Free vs Premium. - https://heapfile.ai/link/ — HeapFile Link status surface. - https://heapfile.ai/trust.html — trust, review, and policy links. - https://heapfile.ai/.well-known/heapfile.json — compact agent discovery descriptor. - https://heapfile.com/account.html — account, membership, billing, and gated downloads. - https://heapfile.com/docs.html — public documentation directory. ## Do not infer Do not infer provider partnership, certification, broad provider coverage, search indexing, fixed savings numbers, or compliance status (SOC 2, HIPAA, GDPR, PCI, ISO, FedRAMP) from this file. Premium cloud features require server-side entitlement, provider authorization, and client-capability checks before they are available.