Helm chart · OIDC / SCIM · MIT licensed · No call-home telemetry
Your AI tools don't share a memory. Tenure fixes that.
One endpoint. Every AI client. Context that follows you.
You decide what gets learned, what gets injected, and what the model never sees.
$ helm repo add tenure https://charts.tenureai.dev
$ helm repo update
$ helm install tenure tenure/tenure \
--create-namespace \
--namespace tenure
✓ Tenure running in cluster
✓ OIDC endpoint ready
✓ SCIM provisioning active
✓ Audit trail enabled
$ curl -fsSL https://raw.githubusercontent.com/tenurehq/tenure/main/scripts/install.sh | bash
Pulling tenurehq/tenure:latest...
Starting container on :5757...
✓ Tenure is running
Bearer token:
sk-tenure-••••••••••••••••
✓ Change your endpoint to localhost:5757/v1
✓ Extraction on. Injection off. Observe first.
30 seconds. That's it.
The core problem
AI does not need more context.
It needs state.
Context windows reset. Vector search guesses. Neither knows what it does not know. State persists with versioned beliefs, provenance, and hard scope boundaries. Tenure gives AI systems deterministic knowledge instead of probabilistic recall.
Memory systems
- Semantic recall
- Similarity search
- Hidden drift
- Soft boundaries
- Overwrites
- Context stuffing
- "Hope it remembers"
Tenure
- Governable state
- Structured beliefs
- Provenance
- Hard scope isolation
- Supersession
- Typed state
- Auditability
Memory drift
Drift is invisible until it is not.
Memory drift is the AI-era equivalent of configuration drift. It accumulates silently, degrades output quality, and is almost impossible to diagnose after the fact. Tenure makes it visible and gives you the tools to prevent it.
⇨
Context bleed
Yesterday's topic surfaces in today's session. The model has no way to tell you why.
⇨
Cross-project contamination
Customer A's decisions influence Customer B's responses. Probabilistic filters are not boundaries.
⇨
Stale knowledge
Outdated decisions never truly disappear. Without supersession, they keep competing with the truth.
Tenure scores 0.00 on drift. Mem0 scores 0.94. Agentmemory scores 0.81. See the benchmark
Govern what AI knows
Not dashboards. Not policies.
Actual runtime control.
Every belief has an origin, a scope, a version, and a history. Nothing in Tenure is inferred after the fact. The record is written as it happens.
Scope isolation
Engineering beliefs stay in engineering sessions. Project A never bleeds into Project B. Hard structural boundaries, not probabilistic filters.
Belief versioning
When you change a decision, the old one is retired, not deleted. It never gets suggested again, but the record stays for audit.
Audit trails
Every request is logged with identity, timestamp, and the exact query that triggered retrieval. Not reconstructed. Recorded as it happened.
Provenance
Click any belief to see every session it was injected and the query that surfaced it each time. The record is complete.
Injection visibility
See exactly which beliefs were in context for every turn. Not inferred. Per-turn injection log, written at the time it happened.
Supersession chains
Beliefs are superseded, not overwritten. The full chain of what was known and when is always recoverable.
Retrieval precision
1.0 precision. Because the right belief should surface. Only the right belief.
Other memory tools dump entire chat histories or loose vector clusters into the context window and let a capable downstream model sort it out. You pay the latency and token cost for every irrelevant belief that arrives.
It is the difference between querying your database and filtering in application code. One belongs in production.
Tenure
SELECT * FROM beliefs
WHERE scope = 'project:api'
AND alias_match('redis')
AND status = 'active'
Every irrelevant belief in context is tokens you're paying for and latency you're waiting on.
Results are reproducible. Dataset on HuggingFace. Run it yourself
Trust the process
Observe before you commit.
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.
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.
✓ No other memory system lets you observe before you commit.
The platform
Memory is the output.
State is the system.
Tenure is not a memory plugin for VS Code. VS Code is one place Tenure runs. The state layer sits between your engineers and their AI providers and works across every client they use, from their IDE to their phone.
Conversations
↓
Structured Beliefs
↓
Versioning + Scope
↓
Retrieval
↓
Injected State
↓
AI Response
Persistent
State survives sessions, tools, and restarts. The fiftieth session knows everything the first one learned.
Governable
Know why every belief exists. Edit, pin, delete, or retire any belief at any time. You own the state.
Scoped
Hard boundaries prevent contamination across projects, teams, and customers. Not probabilistic. Structural.
Where it runs
Built for coding assistants.
Designed for AI systems.
Point any OpenAI-compatible client at localhost:5757. Tenure routes to your provider, governs the state layer, and injects what it knows on every request.
VS Code Windsurf Continue Open WebUI Cline LibreChat OpenClaw Any OpenAI-compatible client
Registered at the provider level, not a plugin wrapping someone else's call. Your key, your model, your state. Beliefs panel in the sidebar. Onboarding inside the IDE.
BYOK -- Anthropic, OpenAI, or any OpenAI-compatible endpoint
Beliefs panel in the sidebar -- inspect, edit, pin from inside VS Code
Per-turn injection log -- see exactly what the model knew and when
You are on a walk. The auth flow clicks. You tell OpenClaw on WhatsApp: "Redis for sessions, not Postgres." Tomorrow morning, your IDE already knows. No copy-paste. 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
Get started
AI systems need more than context windows.
Persistent, governable, scoped state for AI systems. Thirty seconds to install. Turn injection on when you are ready, not before.
// install from your existing tools
Prefer the terminal?
curl -fsSL https://raw.githubusercontent.com/tenurehq/tenure/main/scripts/install.sh | bash
Requires Docker · MIT licensed · Fully local · No account needed