Stop explaining your project to every new chat.

Only someone holding your message. Your text is locked in this page, in your browser, with a key that is made here. We store the locked copy and never the key. Treat the message like a password: anyone you give it to can read your cache and write to it.

Your notes are on the ledger, not on our server, and the key is in your message. To get them back without us: download the recovery script (one file, kept on this site rather than on our server) and run node dig.mjs "your line here". It asks the chain directly, unlocks the notes on your own machine, and never sends your key anywhere. It is a single file with nothing to install. We check it against a real cache every time we change anything.

On an immutable ledger, using blockchain technology. Everything is encrypted in your browser before it leaves, and only the encrypted copy is written to the ledger. It does not live on any one server, so your notes are safe from server downtime: if ours went down tomorrow, your cache would still be there and still yours to open.

Throw away the message and it is as good as gone: without the key nobody can ever read it, including us. The encrypted copy itself stays on the ledger, because a ledger that could lose things could lose yours. As with any notes tool, leave passwords and card numbers out.

In the message as written, yes, for a moment. The key rides in the address so the chat gets plain text back; the server unlocks that one request and keeps neither the key nor the text. If you would rather the key never left your chat, use private mode below: the server hands over the locked copy only and the chat unlocks it itself.

Good. A careful assistant checks before it acts on something it fetched from the web, and some check more often than others. Your message already says the notes are yours. If a chat still asks, answer "yes, that is my file, go ahead" and it carries on. Nothing is wrong with your cache.

Reading works in any chat that can open a web address. Saving works two ways. A chat that can run code saves the new version itself when you say bury my cache. A chat that cannot will hand you the updated notes instead: paste them under Open a cache and press Bury the next version. Either way your message stays the same. It was built and tested with Claude.

Then the cache cannot be opened or updated by anyone. Keep the message in your password manager or your notes. It is shown once.

300 KB a version, which is around 50,000 words. Every bury is a new version and the older ones stay readable.

Not in money here: saving costs you nothing and reading is free. It costs in the chat. Your notes are read at the start of every conversation, and an assistant charges its own usage by how much it reads, so a long cache uses more of a chat's allowance than a short one. It is the same as uploading the same notes by hand, no more, so nothing is added by keeping them here. If yours gets long, put ===== headings ===== in it: the sections can then be read one at a time, and a chat working on one thing need not read all of it.

The line is cache:<name>#<key>.<write>. The name finds the newest version, the key unlocks it, the write token lets a chat bury a new one. The quick address, which the message uses:

https://cache.gekker.lol/api/cache/<name>?key=<key>&format=text

Private mode in Python: the reader serves the locked copy and the chat unlocks it.

import base64, json, urllib.request
from cryptography.hazmat.primitives.ciphers.aead import AESGCM   # pip install cryptography

def b64u(s): return base64.urlsafe_b64decode(s + '=' * (-len(s) % 4))
def unb64u(b): return base64.urlsafe_b64encode(b).decode().rstrip('=')

name, key, write = 'rachel-vulpine', '', ''
j = json.load(urllib.request.urlopen(f'https://cache.gekker.lol/api/cache/{name}'))
raw = b64u(j['ciphertext']); text = AESGCM(b64u(key)).decrypt(raw[:12], raw[12:], None).decode()
print(text)                                            # the document, version j['version']

# to bury the next version:
import os
iv = os.urandom(12); ct = AESGCM(b64u(key)).encrypt(iv, new_text.encode(), None)
req = urllib.request.Request(f'https://cache.gekker.lol/api/cache', method='POST',
    data=json.dumps({'name': name, 'ciphertext': unb64u(iv + ct), 'write': write}).encode(),
    headers={'Content-Type': 'application/json'})
print(json.load(urllib.request.urlopen(req)))          # {ok, version, outpoint, txid}: say "saved" only after this

The same in JavaScript, in a browser or Node 18 and later:

const b64u = (s) => Uint8Array.from(atob(s.replace(/-/g,'+').replace(/_/g,'/')), c => c.charCodeAt(0))
const unb64u = (b) => btoa(String.fromCharCode(...new Uint8Array(b))).replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'')
const k = await crypto.subtle.importKey('raw', b64u(key), 'AES-GCM', false, ['encrypt','decrypt'])
const j = await (await fetch(`https://cache.gekker.lol/api/cache/${name}`)).json()
const raw = b64u(j.ciphertext)
const text = new TextDecoder().decode(await crypto.subtle.decrypt({ name:'AES-GCM', iv: raw.slice(0,12) }, k, raw.slice(12)))
// bury: iv = crypto.getRandomValues(new Uint8Array(12)); ct = await crypto.subtle.encrypt({name:'AES-GCM', iv}, k, new TextEncoder().encode(newText))
// POST /api/cache { name, ciphertext: unb64u(concat(iv, ct)), write }

Every bury is a new inscription and the name always finds the newest. A write token is shown once. Say "saved" only when the transaction id comes back.