Tenure
Show HN: LLM memory without context bleed; 100% precision vs. <10% vector search
Last verified:
What is Tenure?
Tenure is a local AI memory system for developers that runs entirely on localhost, providing persistent memory that follows users across every tool and session. Unlike RAG or memory wrappers, Tenure builds a structured belief store by extracting decisions, preferences, facts, questions, and blockers from conversations, then automatically injects relevant beliefs into context on every request without requiring tool calls or prompt engineering.
The system achieves 1.0 retrieval precision with sub-15ms latency by using alias-weighted BM25 retrieval with hard scope filtering. It maintains complete scope isolation where engineering beliefs stay in engineering sessions and project A never bleeds into project B. Users can observe what Tenure learned before committing by running with extraction on and injection off, then inspect and edit all captured beliefs through the VS Code side panel before enabling injection.
Tenure is designed for developers using VS Code, Windsurf, Continue, Open WebUI, LibreChat, Cline, OpenClaw, or any OpenAI-compatible client. It registers as a native LLM provider in VS Code, supports BYOK (Bring Your Own Key) for Anthropic, OpenAI, or any OpenAI-compatible endpoint, and provides a beliefs panel in the sidebar to inspect, edit, and pin memories directly inside the IDE. The platform is fully local, MIT licensed, requires no account, and keeps zero network calls to external services.
Tenure pricing
Pricing model: Freemium
Tenure is 100% free and MIT licensed. No paid plans, subscription tiers, or fees. The platform requires Docker for the local container but has no licensing costs. All features including structured beliefs, scope isolation, audit trails, VS Code integration, and multi-client support are included without restriction. No account needed, no telemetry, zero network calls to external services.
Tenure pros
- Runs entirely on localhost with zero cloud dependency
- 1.0 retrieval precision - only relevant beliefs injected
- Sub-15ms retrieval latency with no embedding model
- No RAG, no MCP, no prompt engineering required
- Automatic memory injection on every request without tool calls
- Structured beliefs instead of raw chat history
- Per-file and global scope isolation prevents project bleeding
- Observable mode: extraction on, injection off to see what learned
- VS Code side panel to inspect, edit, and pin beliefs
- Full audit trail with per-turn injection logs
- Belief provenance shows every session a belief was injected
- Persisted query context stored alongside injection events
- BYOK support for Anthropic, OpenAI, and OpenAI-compatible endpoints
- Native LLM provider registration in VS Code
- No account required, MIT licensed, zero telemetry
- Encrypted at rest storage with export/import capability
- Superession retires old decisions without deleting audit records
- Works across phone, tablet, laptop with same local belief store
- Zero plaintext keys - uses IDE's native secret store
- 30-second installation via one-click or terminal script
Tenure cons
- Requires Docker for local container installation
- Only works with OpenAI-compatible clients, not all LLM providers
- MCP-native tools may have better cross-platform support
- No cloud sync means manual export/import for device migration
- Limited to developers comfortable with localhost proxies
- Belief store grows locally, no centralized team memory
- Initial setup requires IDE extension installation or terminal script
- No built-in chat interface - relies on existing clients
- May conflict with existing proxy or network configurations
- Learning curve for understanding scope isolation concepts
Frequently asked questions about Tenure
How does Tenure achieve 1.0 retrieval precision?
Tenure uses alias-weighted BM25 retrieval with hard scope filtering instead of dumping entire chat history or loose vector clusters into context. It queries at the source with filters like scope, alias_match, and status, returning only 1 relevant result instead of 18 irrelevant ones. This eliminates tokens and latency from irrelevant beliefs in context.
What is the difference between extraction mode and injection mode?
Extraction mode (on) watches sessions silently and extracts decisions, preferences, facts, questions, and blockers into the structured belief store. Injection mode (on) automatically injects relevant beliefs into context on every request. Users can run extraction on with injection off for weeks to observe what Tenure learned before enabling injection, with zero risk or behavior change.
Why doesn't Tenure use MCP for memory retrieval?
MCP memory tools have a fundamental flaw where the model must decide to call them, meaning memory only works when the model recognizes it needs prior information. Tenure's proxy layer sits between client and provider, enriching every request automatically before it reaches the model with no tool call to trigger, no prompt engineering required, and memory injected on every single request.
How does scope isolation work in Tenure?
Scope isolation creates hard structural boundaries where engineering beliefs stay in engineering sessions and project A never bleeds into project B. Every scope is a structural boundary, not a probabilistic filter. This includes per-file beliefs (like userRepository.ts decisions) and global project beliefs (like TypeScript strict mode or Fastify over Express), keeping them properly scoped.
What is the installation process for Tenure?
Installation takes 30 seconds with one manual step. Install directly from VS Code, Windsurf, or Continue via one-click, or run the terminal script: curl -fsSL https://raw.githubusercontent.com/tenurehq/tenure/main/scripts/install.sh | bash. The extension securely spins up the local Docker daemon on port 5757, hooks up the proxy layer, and prints the bearer token. No terminal required for extension installation.
How does Tenure handle privacy and data security?
Tenure runs entirely on localhost with zero network calls home, no accounts required, and no telemetry. Beliefs are encrypted at rest. Users can export their entire memory as an encrypted archive and restore it anywhere. The platform is MIT licensed, requires no account, and users own their memory completely and forever.
What clients and tools does Tenure support?
Tenure works with VS Code (as native LLM provider), Windsurf, Continue, Open WebUI, Cline, LibreChat, OpenClaw, mobile chat clients, and any OpenAI-compatible client. It provides the same local belief store across IDE, phone, tablet, and laptop, capturing aha moments wherever they happen without copy-pasting or re-explanation.
How can I audit what Tenure injected into my conversation?
Tenure provides a full audit trail with per-turn injection logs showing exactly which beliefs were in context for every turn, not inferred but recorded as it happened. Click any belief to see every session it was injected and the exact query that surfaced it each time. The query context is persisted alongside the injection event at the time it happened, not reconstructed from logs.
What happens when I change a decision that Tenure has learned?
Tenure uses supersession where old decisions are retired but not deleted. When you change a decision, the old one is never suggested again, but the record stays for audit purposes. This maintains complete history while ensuring the model only acts on current decisions.
Can I pause Tenure's learning without losing existing memory?
Yes. Type !extract off in any session to pause Tenure's learning. Your existing memory still works and Tenure just stops taking notes. You can also type !extract on to resume. Additionally, you can type !inject off to disable injection while keeping extraction on, or !inject on to enable automatic injection into context.