Give every AI surface shared memory.
One endpoint. Every AI client. Context that follows you.
Every client and agent gets scoped context.
Shared memory cannot be a shared junk drawer.
Your AI tools need context that is current, relevant, and allowed for the task in front of them. Tenure provides beliefs with provenance, scope, supersession, and hard boundaries across projects, teams, users, and sessions.
- User-level memory buckets
- Similarity search
- Hidden drift
- Soft boundaries
- Persona leakage
- Context stuffing
- "Hope it remembers"
- Purpose-bound context
- Structured beliefs
- Provenance
- Hard scope isolation
- Persona opt-in
- Typed state
- Auditability
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.
The governance layer for shared AI memory.
Tenure does not send every memory to every agent. Each token defines eligible projects and whether user persona context is allowed. Every belief has an origin, a scope, a version, and a history. The record is written as the request happens.
Engineering beliefs stay in engineering sessions. Project A never bleeds into Project B. Hard structural boundaries, not probabilistic filters.
When you change a decision, the old one is retired, not deleted. It never gets suggested again, but the record stays for audit.
Every request is logged with identity, timestamp, and the query that triggered retrieval. Not reconstructed. Recorded as it happened.
Click any belief to see every session it was injected and the query that surfaced it each time. The record is complete.
See which beliefs were in context for every turn. Not inferred. Per-turn injection log, written at the time it happened.
Beliefs are superseded, not overwritten. The full chain of what was known and when is always recoverable.
Shared memory without shared everything.
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.
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
Observe before you commit.
Run with extraction on and injection off for a week or two. See what Tenure learned about how you work before it ever changes a single response. No risk. No behavior change. No surprises.
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.
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.
Give agents access only to what you want.
A Tenure token does more than authenticate a request. It declares what project an agent has access to and whether your preferences should be shared. Memory becomes purpose-bound instead of all-or-nothing.
Agents can work inside a project without inheriting unrelated memories or user-level behavior preferences.
User persona is an explicit context lane. Turn it on for personal copilots. Leave it off for task agents.
Every injection is recorded with the token, scope, query, belief, and request that caused it.
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.
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.
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.
Put shared AI memory in the request path.
Run Tenure locally for project-scoped memory, or use Team Mode when shared context needs identity, OAuth/OIDC, and org-wide policy enforcement.
// install from your existing tools
Prefer the terminal?
curl -fsSL https://raw.githubusercontent.com/tenurehq/tenure/main/scripts/install.sh | bash