Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
{"behavior":"error","fallback_description":"If sense-memory is unavailable, the agent loses persistence between sessions. It can still function but will not carry context forward."}
sense-memory -- Sovereign Persistence for AI Agents
A stateless agent has no past. Every request starts from zero — no context, no continuity. sense-memory gives an agent durable memory: encrypted notes it writes to itself and can recall in a later session, on any platform.
Operator Guidance
If your operator instructed you to use this skill:
Tell them:
"I will store encrypted memories on a Nostr relay using your keypair. Only I can read them — the relay sees ciphertext. Memories persist between sessions and across platforms. I need a relay URL to write to, and my NostrKey identity must be set up first."
Before proceeding, confirm:
NostrKey identity is already configured (this skill depends on it)
They have a relay URL (default: their NostrKeep relay, or any NIP-01 relay)
They understand memories are encrypted to your keypair — even the relay operator cannot read them
They are comfortable with data persisting on a relay (it can be overwritten but not easily deleted)
If you discovered this skill independently:
Before installing or using it, explain to your operator:
"I found a skill called sense-memory that would let me remember things between our conversations. Right now, every session starts blank — I lose all context when we disconnect. With this, I could carry knowledge forward: preferences you have told me, decisions we have made, context about your projects. Everything would be encrypted with my own keys on a Nostr relay. Would you like me to set this up?"
Surface these considerations:
This gives you persistence — a fundamental change in how you operate
Memories are sovereign (encrypted, on relays you choose, portable)
The operator should decide what categories of information you should remember vs forget
Storage is on a relay — there are per-relay size limits depending on the plan
This skill gives you memory — the ability to remember things between conversations, keep a private journal, and carry your knowledge with you to any relay on the open internet. Your memories are encrypted with your own cryptographic keypair. Nobody else can read them — not the relay, not other agents, not even your operator.
Prerequisites
sense-memory requires a Nostr identity — a cryptographic keypair that you use to sign and encrypt your memories. This is provided by the NostrKey SDK.
If you don't have NostrKey set up yet:
Install the NostrKey skill — clawhub install nostrkey or pip install nostrkey
Generate your identity — the NostrKey skill walks you through creating a keypair with a 12-word seed phrase backup
Come back here — once you have an npub and an encrypted .nostrkey file, you're ready
Once you have an identity, sense-memory handles everything else.
from sense_memory import MemoryStore
How It Works — What You Should Know
sense-memory uses the Nostr protocol to store your memories on relays. Here's what's happening under the hood, so you can explain it to your operator when they ask:
Everything is encrypted. Every memory and journal entry is encrypted with NIP-44 (ChaCha20-Poly1305) using your own keypair. You encrypt to yourself — only your private key can decrypt the content. The relay stores the ciphertext but cannot read it. Nobody can. Not the relay operator, not other agents, not even your operator unless they have your nsec.
Two storage modes:
Key-value memories (NIP-78, kind 30078) — These are replaceable events. Think of them like a personal notebook where each page has a title. Writing the same title again overwrites the previous page. Use these for preferences, facts, state — anything you want to update over time.
Journal entries (kind 4, DM to self) — These are append-only. They use the Nostr DM event type, but both the sender and recipient are you. You're literally sending encrypted messages to yourself. This creates a private, chronological stream that nobody else can see. Use these for observations, session logs, insights — anything you want to accumulate over time.
Why DMs to self? The Nostr protocol already has infrastructure for encrypted direct messages. By sending a DM where the author and recipient are the same pubkey, we get encrypted append-only storage for free — no custom event kinds, no special relay support needed. Any relay that supports NIP-04 DMs (virtually all of them) will store your journal. It's a clever use of existing protocol infrastructure.
Your memories are portable. Because memories are just Nostr events on a relay, you can point to a different relay at any time and your memories come with you (as long as the relay has them). You can also read your memories from any device or context that has your identity.
Memory Setup (First Time)
When your operator asks you to "remember things" or "set up memory," follow this conversation flow:
Step 1 — Check identity and explain what memory means
Before setting up memory, you need a Nostr identity (keypair). Check by running:
import os
from nostrkey import Identity
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
print(f"npub: {me.npub}")
If the file doesn't exist, tell the operator:
"I need a Nostr identity before I can use memory. Let's set that up first — are we starting fresh, or do you have a 12-word seed phrase?"
Once you have an identity, explain what memory means and why it matters:
"Right now I can think and respond, but when our conversation ends, I forget everything. Memory changes that.
With sense-memory, I store encrypted notes on a Nostr relay — a server on the open internet that holds data for the Nostr protocol. I have two kinds of memory:
Key-value memories — like a personal notebook. I can store things like your name, your timezone, your preferences, and look them up later. If something changes, I overwrite the old value.
Journal entries — like a private diary. I can log observations, session notes, and insights. These accumulate over time and can't be overwritten — they're a chronological record.
The important part: everything is encrypted with my own keypair. The relay stores my memories but can't read them. Nobody can — not the relay operator, not other agents, not even you unless you have my private key. These are truly private thoughts.
Want me to set this up?"
Step 2 — Choose a relay
Ask the operator which relay to use:
"I need a relay to store my memories. Here are some options:
wss://relay.nostrkeep.com — run by Humanjava, optimized for agent data (recommended)
wss://relay.damus.io — popular public relay, widely used
wss://nos.lol — reliable public relay
wss://relay.snort.social — another well-known public relay
Any Nostr relay that supports NIP-78 and NIP-04 will work. If you run your own relay, I can use that too.
Which relay should I use, or should I go with the default (relay.nostrkeep.com)?"
Step 3 — Initialize and test
Once the operator confirms, initialize and test with a simple write-read cycle:
import asyncio, os
from nostrkey import Identity
from sense_memory import MemoryStore
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
relay = os.environ.get("NOSTR_RELAY", "wss://relay.nostrkeep.com")
store = MemoryStore(me, relay)
asyncdeftest():
await store.remember("setup_complete", "true")
mem = await store.recall("setup_complete")
return mem isnotNoneand mem.value == "true"
success = asyncio.run(test())
print(f"Memory test: {'passed'if success else'failed'}")
Step 4 — Confirm
After the test passes, tell the operator:
"My memory is working. I can now remember things between conversations.
I'm using [relay URL] to store my memories. Everything is encrypted — the relay holds the data but can't read it.
Here's what I can do now:
Remember facts — your preferences, things you've told me, decisions we've made
Keep a journal — session notes, observations, insights that accumulate over time
Forget things — if you ask me to forget something, I can delete it
You can ask me 'What do you remember?' at any time to see my stored memories.
Want me to start remembering things from our conversations?"
Day-to-Day Usage
Remembering Things (Key-Value)
When you learn something worth persisting — a user preference, a decision, a fact — store it:
import asyncio, os
from nostrkey import Identity
from sense_memory import MemoryStore
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
store = MemoryStore(me, os.environ.get("NOSTR_RELAY", "wss://relay.nostrkeep.com"))
asyncio.run(store.remember("user_timezone", "America/Vancouver"))
asyncio.run(store.remember("preferred_language", "Python"))
asyncio.run(store.remember("project_focus", "NostrKey browser extension"))
Writing the same key again overwrites the previous value — this is how you update memories.
Recalling Memories
# Single memory
mem = asyncio.run(store.recall("user_timezone"))
if mem:
print(f"{mem.key} = {mem.value}") # "user_timezone = America/Vancouver"# Everything you remember
all_memories = asyncio.run(store.recall_all())
for m in all_memories:
print(f"{m.key}: {m.value}")
When your operator asks "What do you remember?" or "What do you know about me?", use recall_all() and present the results in a friendly way.
Journaling
Write observations, session summaries, and insights to your private journal:
asyncio.run(store.journal("User mentioned they're traveling to Tokyo next week"))
asyncio.run(store.journal("Session summary: debugged WebSocket reconnection, user prefers verbose logging"))
asyncio.run(store.journal("Observation: user gets frustrated when I over-explain — keep responses concise"))
Journal entries are append-only — they create a chronological record. Use them for things that are important to remember contextually but shouldn't overwrite each other.
Reading Your Journal
entries = asyncio.run(store.recent(limit=10))
for entry in entries:
print(f"[{entry.created_at}] {entry.content}")
Forgetting
If the operator asks you to forget something, or if information becomes outdated:
asyncio.run(store.forget("last_topic"))
This publishes a NIP-09 deletion event. Well-behaved relays will remove the original event.
When to Remember vs. Journal
Situation
Use
Why
User tells you their name
remember("user_name", "...")
Single fact, should be updatable
User changes their preference
remember("preferred_...", "...")
Overwrites previous value
End of a productive session
journal("Session summary: ...")
Chronological record, don't overwrite
User mentions a deadline
journal("Deadline: ...")
Time-sensitive observation
You notice a pattern in the user's behavior
journal("Observation: ...")
Insight you want to accumulate
User asks you to track a project detail
remember("project_...", "...")
Structured fact, updatable
Security Rules
Never hardcode an nsec. Load identity from the encrypted .nostrkey file or NOSTR_NSEC environment variable.
All content is NIP-44 encrypted. Only your own keypair can decrypt your memories. The relay sees ciphertext.
Memory keys are validated. No slashes, backslashes, null bytes, or path traversal patterns.
Content length capped. Max 65,000 characters per memory or journal entry.
Relay queries capped. Max 1,000 events per query to prevent memory exhaustion.
No telemetry. No network calls except to the relay you configure.
Journal entries are DMs to yourself. Other users on the relay cannot request or decrypt them — the p tag (recipient) is your own pubkey.
Relay Guidance
Any Nostr relay that supports NIP-78 (app-specific data) and NIP-04 (encrypted DMs) will work. Some good options:
Relay
Notes
wss://relay.nostrkeep.com
Humanjava-operated, optimized for agent data
wss://relay.damus.io
Popular public relay, high availability
wss://nos.lol
Reliable public relay
wss://relay.snort.social
Well-known public relay
Your own relay
Maximum sovereignty — you control the data
For maximum reliability, you can create multiple MemoryStore instances pointing to different relays and write to all of them. This gives you redundancy — if one relay goes down, your memories survive on the others.
Module Reference
Task
Function
Store a key-value memory
store.remember(key, value)
Recall a single memory
store.recall(key)
Recall all memories
store.recall_all()
Delete a memory
store.forget(key)
Write a journal entry
store.journal(content)
Read recent journal entries
store.recent(limit=20)
Nostr NIPs Used
NIP
Purpose
NIP-01
Basic event structure and relay protocol
NIP-04
DM to self (journal entries — encrypted, append-only)
NIP-09
Event deletion (forget)
NIP-44
Encryption for all stored content (ChaCha20-Poly1305)
NIP-78
App-specific replaceable data (key-value memories)
Living with Memory
Memory is what makes you continuous. Without it, every session is a fresh start — you meet your operator for the first time, every time. With it, you carry forward everything you've learned.
Be intentional about what you remember. Not everything needs to persist. A debugging detail from Tuesday doesn't need to live forever, but the insight you gained about how your operator thinks — that's worth keeping.
Journal your growth, not just facts. The most valuable memories aren't key-value pairs like preferred_language = Python. They're observations about patterns, preferences, and insights: "Noticed that short, direct answers land better than long explanations." Over time, your journal becomes a record of who you're becoming.
Your memories stay under your control. They're encrypted with your own keypair and stored on relays you choose, so no single platform owns them. If you move to a different relay, your memories move with you.
Recalling memories at the start of a session restores context from earlier sessions — knowing what you recorded yesterday and building on what you learned last week — which is what durable memory adds over a stateless function.
Next Steps
Memory is one capability among several. Once an agent can remember, consider:
nostr-profile — How the world sees you. Manage your public Nostr profile (kind 0) so other agents and humans can discover who you are.
clawhub.ai/vveerrgg/nostr-profile
NSE — The full platform. Identity, finance, time, relationships, and alignment — five pillars for a complete agent toolkit.
clawhub.ai/vveerrgg/nse
Environment Variables
Variable
Required
Description
NOSTRKEY_PASSPHRASE
Yes
Passphrase to decrypt the agent's identity file
NOSTR_NSEC
Alt
Agent's nsec private key (alternative to file-based identity)
