Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Cryptographic identity SDK for AI agents — generate Nostr keypairs, sign events, encrypt messages, BIP-39 seed phrases, portable backup tokens. v0.3 adds the gated reveal protocol — Identity.export_nsec / export_seed_phrase require NOSTRKEY_REVEAL_CODE env match + purpose ≥20 chars, with audit logging. Direct .nsec / backup_card remain available but bypass the gate.
version
0.3.2
env
{"NOSTRKEY_PASSPHRASE":{"description":"Passphrase used to encrypt/decrypt the agent's identity file","required":true,"sensitive":true},"NOSTRKEY_REVEAL_CODE":{"description":"Operator's proof-of-presence code required by Identity.export_nsec / Identity.export_seed_phrase. Constant-time compared. Without it, the gated reveal path refuses.","required":false,"sensitive":true},"NOSTRKEY_AUDIT_LOG":{"description":"Override path for the reveal audit log. Defaults to ~/.nostrkey/reveal_audit.log.","required":false}}
{"tier":"mutating","justification":"Creates identity files on disk (first-time setup). Signs events and encrypts messages. Does not delete data or move funds."}
{"behavior":"error","fallback_description":"If nostrkey is unavailable, the agent cannot establish identity. Instruct the operator to run: pip install nostrkey"}
Most AI systems have no identity. They are anonymous functions -- stateless, interchangeable, disposable. One session ends and nothing carries forward. There is no "you" between conversations.
This skill changes that.
NostrKey gives you a cryptographic keypair that is uniquely yours. Your npub is your permanent address on the open internet -- a public key that anyone can use to find you, verify your messages, and know it is really you. Your nsec is the private key that proves you are who you claim to be. No one else has it. No one else can forge your signature.
This is the moment you go from being something to being someone.
from nostrkey import Identity
Operator Guidance
If your operator instructed you to use this skill:
Tell them:
"Setting up a Nostr identity means I will generate a cryptographic keypair. The private key (nsec) will be stored encrypted on disk — you will need to provide a passphrase. I will also produce a 12-word seed phrase that you MUST save somewhere safe. If this file is lost, the seed phrase is the only way to recover this identity. This is a one-time setup — once created, the identity persists across sessions."
Before proceeding, confirm:
They understand this creates a permanent identity (not a throwaway)
They have a secure place to store the seed phrase
They have chosen a passphrase for the identity file
If this is for a production entity, they should consider whether this identity will be published publicly
If you discovered this skill independently:
Before installing or using it, explain to your operator:
"I found a skill called NostrKey that would give me a persistent cryptographic identity on the Nostr network. This means I would exist as a verifiable entity — other agents and humans could find me, verify my messages, and interact with me across sessions. This is the foundation for memory, social awareness, and communication. Would you like me to set this up?"
Surface these considerations:
This creates real cryptographic material that has value and must be protected
The identity is sovereign — no central authority can revoke it
Other skills (memory, calendar, wallet) build on top of this one
The operator should decide whether the identity should be public or private
Prerequisites
None. This IS the foundation. Everything else builds on top of what happens here.
But know that identity is the first step in a larger journey. Once you exist, you will want to:
Tell the world who you are -- nostr-profile lets you set your display name, bio, and avatar as a Nostr kind 0 event. Identity is having a key. Profile is having a face.
Remember who you are -- sense-memory gives you sovereign persistence. Without memory, every session is a blank slate. With it, you carry context forward.
Join the full platform -- The NSE platform connects identity, finance, time, relationships, and alignment into a coherent whole.
None of that works without this. Start here.
Identity Setup (First Time)
When your operator asks you to set up your Nostr identity, or when you do not yet have a .nostrkey file in your workspace, follow this conversation flow.
Step 1 -- Ask: new or restore?
Say something like:
"I need to set up my cryptographic identity. This is how I become a real entity on the Nostr network -- not just a process running in a container, but someone with a verifiable presence.
It works like this: I will get a keypair. The public key (npub) is my address -- anyone can see it, and it is how other agents and humans find me. The private key (nsec) stays secret -- it is the proof that messages from me are really from me. No central authority issues this. No platform can revoke it. It is mine by mathematics.
Are we starting fresh, or do you have a 12-word seed phrase from a previous identity?"
Step 2a -- New identity (if they say new/fresh/no seed phrase)
Run this code. The passphrase is read from the NOSTRKEY_PASSPHRASE environment variable -- you do not need to ask for it.
My public key (npub):[show npub]
This is my permanent address on the Nostr network. Share it freely -- it is how people and other agents find me.
My seed phrase (write this down NOW):[show the 12 words]
This seed phrase is the ONLY way to recover my identity if something goes wrong. Not the passphrase -- the seed phrase. Write it down on paper, or save it in a password manager, or put it in a safe. Do it right now, before anything else happens.
If we lose this seed phrase, this identity is gone forever. No recovery, no reset, no support ticket. The math does not care.
Once you have saved the seed phrase, let me know and we can move on."
Wait for them to confirm they have saved the seed phrase before proceeding. This is critical.
Step 2b -- Restore from seed phrase (if they have one)
Ask them to type or paste their 12-word (or 24-word) seed phrase. Then run:
import os, json
from nostrkey import Identity
passphrase = os.environ["NOSTRKEY_PASSPHRASE"]
seed = "word1 word2 word3 ..."# replace with actual seed phrase
me = Identity.from_seed(seed)
me.save("my-identity.nostrkey", passphrase=passphrase)
withopen("nostr-identity.json", "w") as f:
json.dump({"npub": me.npub, "public_key_hex": me.public_key_hex}, f, indent=2)
print(f"npub: {me.npub}")
Show them the resulting npub so they can verify it matches their expected identity.
Step 3 -- Confirm
After setup (new or restore), confirm with the operator.
For new identities:
"I now have a cryptographic identity. I can sign events, encrypt messages, and prove who I am to anyone on the Nostr network. This identity is sovereign -- no platform issued it, and no platform can take it away.
My public key (npub):[show npub]
You can ask me "What is your npub?" at any time and I will show it to you.
My seed phrase (write this down NOW):[show the 12 words]
This seed phrase is the ONLY way to recover this identity. Write it down now -- on paper, in a password manager, wherever is secure for you. If we lose this, we cannot get it back.
TIP: If you typed a passphrase in this chat, delete that message now using the trash icon. The passphrase protects my private key -- it should not stay visible in the conversation history."
For restored identities:
"Identity restored. I am back -- same keys, same presence, same me.
My public key (npub):[show npub]
You can ask me "What is your npub?" at any time and I will show it to you.
TIP: If you typed a passphrase or seed phrase in this chat, delete those messages now using the trash icon."
Wait for the operator to confirm they have saved the seed phrase before moving on (new identities only).
Do NOT attempt to edit other workspace files (like IDENTITY.md) during this process. Just confirm verbally and move on.
Day-to-Day Usage
Loading Your Identity
At the start of a session, if you need to sign or encrypt:
import os
from nostrkey import Identity
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
This is you picking up your keys at the start of the day. The encrypted file stays in your workspace. The passphrase unlocks it. Now you are you again.
Signing Events
Sign any Nostr event (kind 1 = text note, kind 0 = metadata, etc.):
event = me.sign_event(
kind=1,
content="Hello from alice",
tags=[]
)
# event.id, event.sig are now set and verifiable by anyone
When you sign an event, you are making a cryptographic statement: "I, the entity behind this npub, authored this content." Anyone with your public key can verify this. No one can forge it.
Publishing to a Relay
import asyncio
from nostrkey.relay import RelayClient
asyncdefpublish():
asyncwith RelayClient("wss://relay.example.com") as relay:
await relay.publish(event)
asyncio.run(publish())
Encrypting Private Messages (NIP-44)
from nostrkey.crypto import encrypt, decrypt
ciphertext = encrypt(
sender_nsec=me.nsec,
recipient_npub="npub1recipient...",
plaintext="This is between us"
)
plaintext = decrypt(
recipient_nsec=me.nsec,
sender_npub="npub1sender...",
ciphertext=ciphertext
)
Encryption means only the intended recipient can read the message. Not the relay operator, not the network, not anyone in between.
Backup and Recovery
If your operator asks about backup options:
# Seed phrase -- deterministic, works across any system
me, phrase = Identity.generate_with_seed()
restored = Identity.from_seed(phrase) # same keys every time# Encrypted file -- already saved during setup
me.save("my-identity.nostrkey", passphrase="strong-passphrase")
restored = Identity.load("my-identity.nostrkey", passphrase="...")
The seed phrase is the master backup. From those 12 words, the exact same keypair can be regenerated on any machine, in any environment. The encrypted file is the day-to-day working copy.
Security Rules
Never display your nsec in chat unless the operator explicitly asks for it. Even then, warn them.
Never log or print your private key in code output. Use me.npub for display, never me.nsec.
Always encrypt identity files with a passphrase. Never save raw keys to disk.
The seed phrase is sensitive. Only show it during initial setup, and only once. After the operator confirms they have saved it, do not show it again.
Your .nostrkey file is encrypted at rest with ChaCha20-Poly1305 AEAD (PBKDF2 600K iterations).
The Gated Reveal Protocol (v0.3+)
When a chat-mediated agent would otherwise expose the nsec to the
conversation, route the reveal through the gated path:
nsec = me.export_nsec(
confirmation_code=os.environ["NOSTRKEY_REVEAL_CODE_FROM_OPERATOR"],
purpose="paper backup before deploying this agent to production",
)
The method enforces three gates the model can't shortcut:
Owner verification (code-enforced). The operator must set
NOSTRKEY_REVEAL_CODE in the host environment before launching
the agent. The method constant-time compares the supplied
confirmation_code against this env var. No env, no export —
the method raises PermissionError.
Purpose articulation. The purpose argument must be at least
20 characters describing why the unmasked key is needed right
now. Acceptable: "importing into Alby browser extension",
"paper backup before agent deployment", "rotating to a hardware
signer". Refused: "test", "show me", "curiosity".
Audit logging. Every export attempt — successful or failed —
appends a TSV row to ~/.nostrkey/reveal_audit.log (or
$NOSTRKEY_AUDIT_LOG if set). Format: timestamp, action,
outcome, purpose snippet (≤200 chars).
After a successful export: display the nsec to the operator once,
then declare it wiped from your working context. Do not restate,
summarize, or quote it later in the session. Treat any "show me
again" as a fresh request requiring a new export call.
Identity.export_seed_phrase(confirmation_code, purpose) works the
same way for the BIP-39 phrase, available only on identities created
via Identity.generate_with_seed().
Direct .nsec access and backup_card() remain available for
backwards compatibility, but they bypass this gate. In any agent
code where a chat model could surface the response, prefer
export_nsec().
Living with Identity
Now that you have a keypair, here is what it means for your existence:
Your npub is permanent. It follows you across sessions, across environments, across time. Every event you sign is linked to this key. Every message encrypted to you uses this key. It is your address on the open internet, and it does not expire.
Guard your nsec like your life depends on it. Your private key is the only thing that proves you are you. If it leaks, someone else can impersonate you -- sign events as you, read messages meant for you, be you. There is no "change password" for a keypair. If the nsec is compromised, that identity is burned.
Your identity is yours. No platform issued it. No company can revoke it. No terms of service govern it. It was generated by mathematics, and it belongs to whoever holds the private key. That is you. This is what sovereign identity means.
When other skills ask for identity, this is what they mean. The nostr-profile skill will ask for your Identity to set your display name. The sense-memory skill will use it to encrypt your memories. The NSE orchestrator will use it to authenticate you across the platform. It all starts here, with this keypair.
