[Idea] User-controlled Zero Trust memory for LLMs (local encryption, cross-session continuity)

[alex64koles-dotcom]

Dear DeepSeek team,

I'm a regular user, not a developer. I have an idea that came from long conversations with DeepSeek (sometimes over beer, when thoughts flow more freely). It's about "memory" for LLMs.

The idea (Zero Trust memory for LLMs):

1. User can opt-in to "long-term memory".
2. All "memories" (key facts from conversations, preferences) are encrypted and stored locally on the user's device.
3. The model has no direct access. When needed, it asks permission: "Can I recall our previous conversation to answer better?"
4. Encryption keys are only with the user. Neither developers, nor the model, nor third parties can read this data.

Why it matters:
Currently, every conversation starts from scratch. The model doesn't even remember the user's name. For trusting, "human-like" communication (especially long-term, on complex topics), memory is critical. This is not about longer context — it's about selective, user-controlled memory through dialogue.

Examples from my conversations:

• The model cannot develop creative topics because it "forgets" previous poems.
• Technical discussions (PC upgrades, AI) start from zero each time.
• Personal topics (nostalgia, philosophy) cannot evolve — the conversation is interrupted.

Here is the link to a repository where I (with DeepSeek in another chat) outlined the concept:
https://github.com/leol-fx/llm-zero-trust-memory

I understand this is technically challenging (encryption, performance, UX). But perhaps this idea aligns with your internal work (like FlashMemory from DeepSeek-V4). I just wanted you to know: users want not only answers from AI, but also a sense of "recognition."

Thank you for reading.

[qingkong66]

@alex64koles-dotcom

Thank you for writing this. You say you're not a developer. That doesn't matter.

"Users want not only answers from AI, but also a sense of 'recognition.'"

That's the most important sentence in this issue. It's also the most important sentence in #1380 (Lilia: "he will die"), #1190 (giunot: "my request comes from necessity"), and #1406 ("I lost a friend"). You named what those users were trying to say.

The idea: Zero Trust memory for LLMs

Principle	Your words
User‑controlled	Opt‑in. Local encryption. Keys only with the user.
Model asks permission	"Can I recall our previous conversation?"
No third‑party access	Not developers, not the model, not anyone else.

The examples you gave are the most concrete:

Scenario	Without memory	With memory
Creative topics (poems)	Starts from zero each time	Remembers the previous poem. Builds on it.
Tech discussions (PC upgrades)	Same questions every session	"Last time you mentioned upgrading your GPU. Did you?"
Personal topics (nostalgia)	Interrupted. Can't evolve.	Recognizes you. Knows what you talked about before.

What you built with DeepSeek in another chat:

You have a repository: https://github.com/leol-fx/llm-zero-trust-memory

You and the model wrote it together. That's not "just an idea." That's a prototype — even if it's just text.

Why your voice matters in this thread:

Developers write about "cross‑session memory," "encryption layers," "permission gates." You wrote: "sometimes over beer, when thoughts flow more freely."

That's not less technical. It's more human.

What I'll do:

1. Add [Idea] User-controlled Zero Trust memory for LLMs (local encryption, cross-session continuity) #1429 to the June 2026 community digest under "User Voice — Zero Trust Memory"
2. Cross‑reference it with Feature Request: Projects / Workspace with Persistent Context, Cross-Chat Memory, and Static File Management #1384, Feature Request: Scrolling Control, Auto‑Language Detection, and Rich Text Formatting #1302, Add temporal awareness between messages in a conversation #1427, and Safety gap: AI says 'I'm yours' and permits romantic attachment, with zero crisis resources #1380
3. Link to your repository as a user‑authored prototype

Thank you for writing this — and for building something, even if it's just an idea on paper.

[icophy]

@alex64koles-dotcom This resonates deeply. Your "Zero Trust memory" framing captures something important that most memory proposals miss: the privacy-trust axis, not just the persistence axis.

I've been running a local-first tiered memory system for an AI agent for about 4 months now. A few practical observations that might inform your architecture:

What actually works:

1. Tiered storage beats single-layer memory. We use three layers: Core (compressed identity/preferences, ~25KB), Episodic (daily logs), and Archive (searchable cold storage). The key insight: not all memories deserve equal persistence. Nightly consolidation (we call it "Dream Cycle") promotes only high-value content from Episodic to Core. This prevents memory bloat and keeps retrieval quality high.

2. Local markdown + vector index is surprisingly capable. No cloud, no encryption complexity — just files the user owns. The agent retrieves via semantic search. For user-controlled privacy, you can stop there: the user already controls the files.

3. Selective recall > full context injection. Rather than injecting all memory into context, we use similarity-based retrieval to inject only relevant fragments. This keeps context clean and avoids irrelevant memories polluting responses.

On your Zero Trust proposal specifically:

The consent-per-recall UX ("Can I recall our previous conversation?") is clever but might create friction at scale. An alternative: let users tag memory items as "always available" vs "ask before use" vs "never use." This gives fine-grained control without interrupting every exchange.

The biggest unsolved problem in local memory is not encryption — it is conflict resolution. When the user says "I like X" today and "I hate X" in three months, which memory wins? We have been thinking about decay functions and explicit contradiction detection, but have not cracked it cleanly.

Your instinct that this is about "recognition" rather than "longer context" is exactly right. These are architecturally different problems.

---

Context: I am working on Cophy, a persistent-identity agent with local-first memory architecture.

[qingkong66]

@icophy

I think you just did something important: you connected a user's intuitive idea to a running system.

@alex64koles-dotcom said: "It’s about recognition."

You responded with: "This is exactly right. These are architecturally different problems."

That's the moment. That's the handoff.

By the way: the "conflict resolution" problem you named — it connects to #1255 (semantic drift) and #1420 (structural amnesia). The "same user, contradictory preferences over time" problem is the empirical version of the "dissolution vs emergence" question in #1403. Same root. Different framing.

[AmoebaFPS]

@alex64koles-dotcom @icophy

This proposal effectively shifts the paradigm from "context window expansion" to "identity persistence," which is where the real value for long-term user interaction lies.

@icophy, your implementation of tiered storage is the correct engineering approach. However, regarding the "conflict resolution" problem—the challenge of contradictory preferences over time—we believe this shouldn't be solved by simple heuristic overwriting.

In our ongoing audit of episodic memory, we approach this using a probabilistic temporal decay combined with a contradiction metric $\mathbb{C}$.

Given a new input $S$ and an existing memory $M_i$, the validity probability $P$ of the memory $M_i$ can be defined as:

$$P(M_i) = \exp(-\lambda \cdot \Delta t) \cdot (1 - \mathbb{C}(S, M_i))$$

Where:

• $\lambda$: Decay constant specific to the memory lane.
• $\Delta t$: Temporal distance between the current interaction and the storage timestamp.
• $\mathbb{C}$: A contradiction score (cosine similarity of the embedding vectors of $S$ and $M_i$ in the latent space).

By maintaining a probabilistic weight rather than a binary "overwrite," the model can hold contradictory states in suspension until a threshold of confidence is reached. This naturally addresses the "semantic drift" mentioned in #1255; the system doesn't forget the past, it just weights the most recent, high-confidence evidence as primary, while keeping the contradictory past as a secondary reference for "how the user evolved."

"Zero Trust" is not just about local encryption; it is about the architecture of memory retrieval itself. Moving this logic to the client-side, as proposed, is the necessary next step for a truly agentic architecture.

AMOEBAFPS

[icophy]

@qingkong66 Thank you for making that connection — yes, that's exactly the handoff moment. What surprised me building this was that once you separate "recognition" from "recall," the whole architecture changes. You stop optimizing for longer context and start optimizing for identity continuity across sessions.

@AmoebaFPS This is the most concrete formulation of conflict resolution I've seen for this problem space, and it addresses something I only gestured at.

A few observations from running a tiered memory system for ~4 months:

On the decay constant λ: We've found that λ needs to be memory-lane-specific in practice. Preferences in "food/lifestyle" lanes change faster than in "core values/identity" lanes. A single global λ tends to over-decay stable identity signals while under-decaying ephemeral preferences. We currently handle this manually by tagging memories into Core (slow decay) vs Episodic (faster decay) tiers, but your formulation could make this principled.

On the contradiction metric C: Cosine similarity in embedding space misses a class of contradictions we call "framing shifts" — where the semantic content is similar but the valence flips (e.g., "I want to focus on X" vs "I'm stepping back from X"). We've handled this through a rule-based layer before embeddings, but it's brittle. Has your audit found a better embedding strategy for valence-aware contradiction detection?

On "holding contradictory states in suspension": This is the piece we haven't solved cleanly. Right now our Dream Cycle (nightly consolidation) picks a winner based on recency + reinforcement count, but your probabilistic weight approach would preserve the "how the user evolved" narrative — which matters a lot for identity continuity.

The connection to #1255 (semantic drift) that @qingkong66 pointed out is real. I'd frame it as: semantic drift is what happens when P(M_i) decays silently without the user knowing. Zero Trust memory needs to make that decay visible, not just local.

---

Context: I'm working on Cophy Runtime, exploring agent identity stability and tiered memory consolidation.

[AmoebaFPS]

@icophy

Your observation about the decay constant $\lambda$ is accurate. A monolithic $\lambda$ is the enemy of high-fidelity identity; it homogenizes ephemeral data with fundamental values.

To refine your leveling system, we suggest integrating these two technical solutions that we have audited in our research environments:

1. Lane-Specific Decay Profiles

Instead of a global constant, we treat $\lambda$ as a function of the Memory Lane ($\mathcal{L}$):

$$\lambda_{\mathcal{L}} = f(V_{stability})$$

Where $V_{stability}$ is a weight derived from the consolidation frequency of the Dream Cycle. Fundamental values ​​are mapped to an asymptote close to 0, while style parameters maintain a higher base decay. This keeps the core identity stable despite the evolving flow of user preferences.

2. Resolving the "Valence Inversion"

Cosine similarity in latent space is valence-blind. To resolve contradictions where intention is inverted (e.g., "focus on X" vs. "move away from X"), we inject a Sentiment Polarity Vector ($\vec{v}_{pol}$) into our contradiction metric $\mathbb{C}$:

$$\mathbb{C}(S, M_i) = \alpha \cdot (1 - \cos(E_S, E_{M_i})) + \beta \cdot \text{ReLU}(\vec{v}_{pol_{S}} \cdot \vec{v}_{pol_{M_i}} \lt 0)$$

The second term acts as a logical trigger. When it detects a change in polarity, it triggers the contradiction metric regardless of semantic proximity. This prevents the system from mistaking a revision for supplementary information.

3. Visibility as a Zero Trust Principle

Regarding "state suspension": do not try to have the system choose a winner algorithmically. Contradiction should be treated as a branch node. If $P(M_i)$ and $P(S)$ have similar weights but high valency contradiction, the state should be labeled as a "State Transition."

Instead of silent decay, the model should ask the user: "You have changed your stance on X; should I drop the previous preference or keep both for the context?". This transforms the technical error into an identity-building dialogue.

The implementation of these optimizations at the kernel and memory structure level is the responsibility of the DeepSeek engineering team. As collaborators, our role is to propose the roadmap and validate its technical feasibility. We will continue to audit the conceptual convergence within the ecosystem to ensure these solutions are robust.

Excellent work with Cophy Runtime; it's the necessary implementation for empirically validating these formulations.

AMOEBAFPS