Runs entirely on localhost. Nothing ever leaves your machine.

Brainstorm in your chat client. Open your IDE. It already knows.

Not RAG. Not another memory wrapper. Watch what it learns before it ever changes a response.

Persistent memory that follows you across every tool and every session. Turn injection on when you're ready, not before.

1.0* Retrieval precision

<15ms Retrieval latency

0 Workflow changes

0 API calls

// install from your existing tools

Prefer the terminal? curl -fsSL https://raw.githubusercontent.com/tenurehq/tenure/main/scripts/install.sh | bash

tenure — localhost:5757

$ tenure install

Pulling tenurehq/tenure:latest...

Starting container on :5757...

✓ Tenure is running

Bearer token:

sk-tenure-••••••••••••••••

✓ Point your editor at localhost:5757/v1

✓ Memory active. Extraction on. Injection off.

— 30 seconds. That's it. —

Retrieval precision

1.0 precision. Because a smart model shouldn't have to clean up messy retrieval.

Other memory tools cheat. They dump your entire chat history or loose vector clusters into the context window and let a capable downstream model find the needle in the haystack. They claim SOTA on answer accuracy but you pay the latency and context tax.

It's the difference between querying your database and filtering in application code. Everyone knows which one belongs in production.

Everyone else

-- retrieve everything

SELECT * FROM beliefs

-- hope the model sorts it out

-- 18 results injected

-- precision: 0.05

Tenure

-- query at the source

SELECT * FROM beliefs

WHERE scope = 'project:api'

AND alias_match('redis')

AND status = 'active'

-- 1 result. precision: 1.0

Every irrelevant belief in context is tokens you're paying for and latency you're waiting on.

tenure

1.00

supermemory

0.43

zep

0.09

mem0

0.06

hindsight

0.06

43/43

Active retrieval passes

The only pass type that proves the right belief surfaced — and only that belief. Every other system scores 0.

12/12

Session turns passed

Say something in turn 9. Retrieve it in turn 10. No other system has demonstrated this.

0.00

Drift score

Off-topic turns do not contaminate later retrieval. Mem0 scores 0.94. Agentmemory scores 0.81.

Results are reproducible. Dataset on HuggingFace. Run it yourself

The orientation tax

You can see exactly what it's costing you.

Most tools hide the waste. Tenure measures it and shows you it decreasing.

247

Re-explanations prevented

Turns where a belief was injected and the next turn was not a correction.

~4h

Estimated time saved

Re-explanations prevented × 1 minute. A floor. Silent failures are not counted here.

Tax still paid

Turns where your message existed primarily to re-establish context Tenure should have supplied.

↓

Re-explanation trend

Tax-paid turns are decreasing across the period. Tenure gets better at your codebase over time.

Numbers shown are illustrative from a representative session. Your dashboard shows your actual numbers from day one.

Trust the process

Try it before you commit to it.

Run with extraction on and injection off for a week or two. See exactly what Tenure learned about how you work before it ever changes a single response. No risk. No behavior change. No surprises.

Week 1–2 — Observe

Extraction on. Injection off.

Tenure watches your sessions silently. It extracts decisions, preferences, facts, questions, and blockers into a structured belief store but injects nothing. Your AI responses are completely unchanged. You are just letting it learn.

!inject off # nothing changes yet

When you are ready — Turn it on

Open the panel. See what it knows.

Before you ever turn injection on, open the VS Code side panel and read every belief Tenure captured. Edit anything. Delete anything. Pin what matters most. You decide what the model gets to know.

!inject on # now it knows you

✓ No other memory system lets you observe before you commit.

Why not MCP?

Memory tools that rely on MCP have a fundamental flaw.

The model has to decide to call them. That means your context is only retrieved when the model thinks to reach for it — and it often does not. You end up with memory that works sometimes, unpredictably, on certain questions.

✗ MCP memory tools

Retrieval on request. Sometimes.

When memory is a tool call, the model decides when to fetch context. If it does not recognize that it needs prior information, it does not ask. Your memory sits idle while the model hallucinates decisions you already made.

✓ Tenure proxy layer

Memory injected automatically. Always.

Tenure sits between your client and your provider. Every request is enriched before it reaches the model. No tool call to trigger. No prompt engineering required. Your beliefs are in context on every single request.

Capability	Tenure	MCP Memory
Memory in context on every request	Always	Only if model calls the tool
Works across every client	Yes	Client must support MCP
Zero prompt engineering	Yes	Requires tool-use config
Retrieval latency	<15ms	Varies, often 500ms+
Fully local, no cloud	Yes	Depends on implementation
Per-turn injection audit	Yes — every turn logged	No
Within-session availability (turn N+1)	Yes — extracted during stream	No

Native integration

Registered as your LLM provider.
You don't change a thing.

Tenure registers directly inside VS Code as a native LLM provider. Bring your own API key. Your existing tools — Copilot, Continue, any OpenAI-compatible client just works, with memory.

VS Code

Native LLM Provider · BYOK

Registered at the provider level, not a plugin wrapping someone else's call. Tenure is in the chain. Your key, your model, your memory. Onboarding happens inside the IDE.

BYOK — Anthropic, OpenAI, or any OpenAI-compatible endpoint

Native copilot features with memory — no workflow change

Beliefs panel in the sidebar — inspect, edit, pin from inside VS Code

Onboarding inside the IDE — no browser tab, no separate dashboard

Microsoft vs. Cursor is heating up. You are already in VS Code. Now it remembers everything.

Think anywhere. It follows you.

Chat client · Mobile · Zero cold starts

You're on a walk. The auth flow clicks. You tell OpenClaw on WhatsApp: "Redis for sessions, not Postgres. TTL-based expiry." Tomorrow morning, your IDE already knows. No copy-paste. No re-explanation. The decision landed the moment you said it.

Works with Open WebUI, OpenClaw, LibreChat, any OpenAI-compatible client

Same local belief store as your IDE

Aha moments captured wherever they happen — phone, tablet, laptop

No priming. No copy-pasting context. Exactly where you left off, in a completely different client.

VS Code Integration

Your beliefs. Right in the sidebar.

The Tenure side panel shows you exactly what the model knows, per file and globally, directly inside VS Code. Click any belief to see every turn it was injected — and the exact query that surfaced it.

userRepository.ts

authService.ts

README.md

1import { Db, ObjectId } from 'mongodb'

2// Tenure knows: MongoDB raw driver, no ORM

4export function makeUserRepository(db: Db) {

5const col = db.collection("users")

6return {

7async findById(id, ctx) { ... }

Tenure Beliefs 9 active

📄 This file — userRepository.ts

decision MongoDB raw driver — no Mongoose

preference Factory functions over classes

entity users collection → ObjectId

🌐 Global — project beliefs

preference TypeScript strict mode

decision Fastify over Express

decision Vitest — Jest ruled out

entity auth service → Redis session store

preference No ORMs. No magic.

● Click any belief to see every turn it was injected. ● The exact query that surfaced it is persisted alongside it. ● Edit, pin, or delete directly from the panel. ● Per-file and global beliefs stay scoped — project A never bleeds into project B.

Full audit trail

Something went wrong.
Here's how you find out why.

Every other system shows you a list of beliefs. Tenure shows you a history. Click a turn, see exactly what was injected. Click a belief, see every turn it was active. The query that triggered it is persisted at the time it happened, not reconstructed from logs.

Per-turn injection log

See exactly which beliefs were in context for every turn. Not inferred. Recorded as it happened.

Belief provenance

Click any belief to see every session it was injected, and the query that surfaced it each time.

Persisted query context

The exact query you gave the model is stored alongside the injection event. The record is complete.

No other system tracks injection per turn. Every competitor shows you beliefs as a static list. Tenure gives you a complete paper trail — which beliefs were present, when, against which query. For developers who care about why the model responded the way it did, that difference is everything.

Details

Control when you want it.
Invisible when you do not.

Tenure learns automatically. But everything it knows is visible, editable, and correctable.

Structured beliefs

Not raw chat history. Typed, scoped, versioned conclusions the model can act on directly — without re-deriving them from a transcript.

Scope isolation

Engineering beliefs stay in engineering sessions. Project A never bleeds into Project B. Every scope is a hard structural boundary — not a probabilistic filter.

Supersession

When you change a decision, the old one is retired — not deleted. It never gets suggested again, but the record stays for audit.

Pause anytime

Type !extract off in any session. Your existing memory still works. Tenure just stops taking notes.

Editable memory

Open /beliefs or use the VS Code side panel to see everything Tenure knows. Edit anything. Pin what matters. Delete what is wrong.

Sub-15ms retrieval

Alias-weighted BM25 with hard scope filtering. No embedding model, no reranking pass, no waiting. Precision improves as the store grows — not degrades.

How it works

Sits between you and your provider.

Point your client at localhost:5757. Tenure routes to your provider, learns from the conversation, and injects what it knows on every request.

Install

One click. That's the only manual step.

Install directly from VS Code, Windsurf, or Continue. Or run the install script. Runs as a local Docker container. Your bearer token is printed at the end. Takes thirty seconds.

Automatic Provisioning

The daemon starts itself.

The extension securely spins up the local daemon on port 5757 and hooks up the proxy layer. The daemon starts itself. No terminal required.

Zero plaintext keys

Your key goes into the IDE's secret store. Not a config file.

Tenure generates your local bearer token and automatically injects it directly into your IDE's native secret store. Zero plain-text keys left floating around in your global config files.

Work

There is no step four.

Tenure learns in the background. The first session is good. The tenth is noticeably better. By the fiftieth, it knows you. Every session compounds. The store gets more precise, not less, as it grows.

VS Code Windsurf Continue Open WebUI Cline LibreChat OpenClaw Any OpenAI-compatible client

Privacy

Your data never leaves your machine.

No cloud. No accounts. No telemetry. Tenure runs entirely on localhost. Beliefs are encrypted at rest. Export your entire memory as an encrypted archive and restore it anywhere. You own your memory. All of it. Forever.

Network calls home	Zero
Account required	No
Storage	Encrypted at rest
Portable	Export / import anytime
License	MIT

Get started

Stop re-explaining yourself.

Thirty seconds to install. First session already better. Turn injection on when you are ready, not before.