Poof is a private chatroom that lives in a browser tab. No account, no phone number, no email. You open a quant-room, share it, talk. When the timer runs out, the quant-room is gone. Poof.
These docs explain what Poof is, why it exists, how it works, what it protects you from, what it does not, and how you can check every claim yourself.
Poof at a glance
What
Details
Identity
None. No accounts, no email, no phone number, no username.
Quant-Room
10 minutes, 2 people, text. Free.
Super Quant-Room
1 hour or 24 hours, up to 10 people, files up to 2 MB, an optional uncensored AI model. From $0.49, paid from a wallet. More
Payment
USDC on Ethereum, Base or Solana, or USDG on Robinhood Chain. A blind-signed one-time pass keeps the payment and the room apart. More
AI model
Optional, in a sealed hardware enclave. Your browser encrypts the conversation straight to it. More
Joining
A link, a QR code or a four-word phrase.
Encryption
End-to-end, in your browser: AES-256-GCM with a hybrid key (the link's key + ML-KEM-768). More
Transport
Directly between browsers over WebRTC. Poof's servers never carry your messages.
Storage
No messages are stored anywhere. Quant-room state on the server is deleted when the room ends. More
Transparency
Open source (MIT), with signed builds you can verify. More
Privacy is not only about hiding information. It is also about reducing how much information exists in the first place.
Storage is cheap, so most of the internet keeps everything, just in case. Every message, contact list and login stays on someone's server for years. Each of those copies is something that has to be protected, forever.
MORE DATA ──▶ MORE STORAGE ──▶ MORE METADATA ──▶ MORE ATTACK SURFACE ──▶ MORE TO PROTECT, FOREVER
Poof starts from the opposite default. A conversation exists for as long as people are having it, and not much longer.
LESS DATA ──▶ LESS RETENTION ──▶ SMALLER ATTACK SURFACE ──▶ LESS LONG-TERM EXPOSURE
Honest footnote
Keeping less does not make a system secure on its own. It removes some risks completely: a breached database, a subpoena for old messages, someone decrypting an archive years from now. Other risks stay exactly where they were, like a compromised phone or someone taking a screenshot. The threat model lists both.
Privacy is not the same as security
Idea
The question it answers
Privacy
Who can learn things about me?
Security
Can someone without permission read or change my data?
Confidentiality
Who can read the content?
Integrity
Could it be changed without anyone noticing?
Authenticity
Can I tell who really sent it?
Anonymity
Can this activity be tied to a real person?
Ephemerality
How long does any of it exist?
Poof is built around confidentiality and ephemerality. It helps with privacy because it never asks who you are. It is not an anonymity tool on its own: the network still sees which IP addresses connect, and when.
Create, use, expire, poof Concept
Grass grows, exists for a season, then returns to the soil. Nothing about it is meant to last forever, and that is not a flaw. Poof treats a conversation the same way.
NATURE POOF
────── ────
seed ──▶ create quant-room
grow ──▶ people join
exist ──▶ messages are used
change ──▶ timer runs down
return ──▶ quant-room state disappears · poof
An analogy, not a security proof. What actually expires, and where, is described in Data lifecycle.
Why “Poof”?
Because that is what the quant-room does at the end.
How it works
The life of a quant-room.
From the moment you press “Create Quant-Room” to the moment it disappears: what your browser does, what Poof's server does, and what nobody ever gets to see.
Lifetime
10 minutes
People
2
Messages
Text, up to 5,000 characters
Price
Free
Encryption
Hybrid post-quantum, end-to-end
Account
None. Ever.
YOU POOF SERVER GUEST
│ │ │
│ 1 create quant-room ─────────▶│ id + expiry, short-lived │
│ 2 your browser makes the │ │
│ quant-room key (never sent)│ │
│ 3 share: link · QR · 4 words ─────────────────────────────▶ │
│◀──── 4 signaling relay: "how to reach each other" ─────────▶│
│ │ (no keys, no messages) │
│◀═══════════ 5 direct encrypted channel (WebRTC) ═══════════▶│
│◀═══════════ 6 post-quantum key exchange (ML-KEM-768) ══════▶│
│◀═══════════ 7 talk: every message encrypted in-browser ════▶│
│ │ │
│ 8 timer ends ─▶ quant-room state deleted ─▶ poof
1 · Create
When you press Create Quant-Room, your browser first makes a random 32-byte creator secret. It keeps the secret in this tab and sends Poof's server only its SHA-256 fingerprint. The server answers with a fresh quant-room id (16 random bytes) and the moment the quant-room ends, 10 minutes later.
Only after that answer does your browser generate the quant-room key: 32 random bytes from the browser's own Web Crypto API. The key is made in your tab, after the server has already spoken, so there is no request it could ever travel in.
Anatomy of a quant-room link
usepoof.chat/join/#Q2xL…4yHg.k9Fz…7wQe
usepoof.chat/join/ ──▶ WEB PAGE loads the app
#Q2xL…4yHg ──▶ POOF SERVER room id, 22 characters: finds the room
.k9Fz…7wQe ─ ─ THIS TAB ONLY quant-room key, 43 characters: never sent
Everything after the # is the link's fragment. Browsers never put the fragment in a request. Your browser reads the room id from it and tells Poof's server which room to open, but the key next to it stays in the tab. Poof's server never receives the key, so it can never read the quant-room.
the creator secret is not in the link
Only the browser that created the quant-room holds it, in its local storage, and only until the quant-room ends. That's how the server knows who may press Poof it now, even after a reload, without ever knowing who you are. The quant-room key is kept apart from it, in this tab only.
Create a quant-roomengine API
import {
createRoom, RoomSession, browserSocketFactory, browserRtcFactory,
} from"/engine/poof-engine.js";
const API = "https://api.usepoof.chat";
// Ask for a quant-room. The key is generated here, after the server answers.const room = await createRoom({ fetch, origin: API });
room.path; // "/join/#<22-character id>.<43-character key>"
room.ownerSecret; // stays in this tab: it's what "Poof it now" proves// Join it and follow the status.const session = new RoomSession({
roomId: room.roomId,
roomKey: room.key,
origin: API,
appOrigin: location.origin,
ownerSecret: room.ownerSecret,
fetch: fetch.bind(window),
createSocket: browserSocketFactory,
createPeerConnection: browserRtcFactory,
});
// waiting → connecting → sealed
session.subscribe((state) => console.log(state.status));
await session.start();
2 · Invite
Method
How
Trade-off
Link
Send the full link through a channel you trust.
The key travels inside the link. Anyone who sees the link can join, so share it privately.
QR code
Your guest scans your screen in person.
The key never touches the network.
Four words
Press Show a phrase and read it out, like orbit velvet tunnel cabin.
Works once, and only for 3 minutes. Made for a phone call, not for a chat history.
How four words become a link
ORBIT VELVET TUNNEL CABIN 4 of 2,048 words · 44 bits
│
▼
PBKDF2-SHA-256 200,000 rounds, in your browser
│
▼
ADDRESS + LOCK KEY both come from the same slow derivation
│
▼
LOCKED LINK AES-256-GCM, kept by Poof · one read, 3 minutes max
│
▼
OPENED · POOF the first reader takes it, then it's gone
The four words come from a fixed list of 2,048 everyday words, so a phrase holds 44 bits of chance. Your browser stretches it with PBKDF2-SHA-256 over 200,000 rounds and splits the result into two things: a mailbox address and a lock key. It locks the quant-room link with AES-256-GCM and leaves only the locked copy at that address.
Your guest types the same four words, in any case, separated by spaces, dashes or commas. Their browser repeats the derivation, finds the mailbox and opens it. Opening it empties it on the spot, and an unread mailbox disappears after 3 minutes. Poof's server sees an address and a locked blob, never the words: every guess would cost 200,000 rounds across about 17.6 trillion possible phrases, far longer than a phrase lives.
The opened link must point to usepoof.chat and be a well-formed quant-room link, so a tampered mailbox can't send your guest anywhere else.
Share with four wordsengine API
// You: put the link behind a fresh phrase (one use, 3 minutes).const { code, expiresAt } = await session.createPhrase();
code; // "orbit-velvet-tunnel-cabin"// Your guest: turn the words back into the link, then open it.const path = await joinByPhrase({
fetch, origin: API, appOrigin: location.origin,
code: "Orbit velvet tunnel cabin",
});
location.assign(path); // "/join/#<id>.<key>"
To find each other, the two browsers swap connection details through Poof's server. This is signaling: the server relays them, stamps who sent what, and stores none of it. It also holds the door. A Quant-Room has two seats, the server decides who gets one, and a third visitor is turned away.
Once a direct WebRTC data channel is open, the browsers run a post-quantum key exchange over it, mix the result with the quant-room key, and prove to each other that they arrived at the same keys. Only then does the quant-room switch to sealed and the message box opens. If the proof fails, the connection is refused instead of downgraded.
If the two networks can't reach each other directly, traffic goes through a relay over TLS. The relay forwards encrypted bytes it can't read, and its credentials are issued only once two people are paired and stop working when the quant-room ends.
Status
What you see
What's happening
waiting
Your link, QR code and phrase button
You're in the quant-room alone. The server knows a seat is taken.
connecting
Your guest arrived
The browsers are finding a route to each other.
connected
A moment more
The direct channel is open and the post-quantum key exchange runs.
sealed
The message box is open
Both browsers confirmed the same hybrid keys. Everything from here on is encrypted.
ended
“Poof.”
Someone left, the creator ended it, or the timer ran out. See below.
Opened the link inside Instagram, Facebook or TikTok? Their built-in browsers can run their own code in every page they show. Poof spots the common ones and suggests opening the link in your real browser.
4 · Talk
Every message is encrypted in your browser with AES-256-GCM before it leaves, using a key that only travels in your direction, and it carries a sequence number. Your guest's browser checks that number: a message that was altered, replayed, dropped or reordered closes the connection instead of slipping through. Poof's servers are not on the message path at all.
Messages hold up to 5,000 characters. Each person gets a default name, like Amber Fox, that looks the same on both screens until they pick their own (up to 32 characters). The “typing…” hint travels the same encrypted way and carries no text. The developer guide shows every byte of a message on the wire.
Talkengine API
await session.sendMessage("hi"); // encrypted here, then sent
session.setTyping(true); // a hint, no text
session.setNickname("Ana"); // travels only over the encrypted link
5 · Poof
What happens
The conversation
Poof's server
Your guest leaves
Wiped from your screen at once, input switched off
Frees the seat. The quant-room still ends on its timer
Someone reloads the page
Kept for 30 seconds while they come back. Nobody else can take the seat
Lets the same browser back in
The creator presses Poof it now
Ends for both of you
Deletes the quant-room at once
The creator removes the guest
Kept for the creator, who goes back to waiting
Keeps that guest out for good
The timer runs out
The connection closes. What's on your screen stays readable until you leave the page
Deletes everything it held about the quant-room
After that, opening the link only shows that the quant-room no longer exists. There is no archive and no backup to recover it from.
Leave or end itengine API
await session.leave(); // anyone: leave, the other side is toldawait session.destroy(); // creator only: "Poof it now", for everyone
What the server knows
Sees
Never sees
That a quant-room exists, how many seats it has and when it ends
The quant-room key
The fingerprint of the creator secret
The creator secret itself
IP addresses while people connect, used only to count requests and never stored
Messages, names or typing hints
Roughly when people connect
Who you are: there's no account, email or phone number
Limits
What
Limit
People
2, decided by the server
Lifetime
10 minutes
Message
5,000 characters
New quant-rooms
5 per minute from one address
Joining
10 attempts per minute from one address
Four-word phrase
One use, 3 minutes
Need more time, more people or files? That's a Super Quant-Room.
Quant-rooms
When ten minutes isn't enough.
A Super Quant-Room gives the conversation more time, more seats, files and an optional AI model. The privacy architecture is exactly the same: keys made in your browser, messages encrypted end-to-end, nothing kept.
Lifetime
1 hour or 24 hours
People
2 to 10, or just you with the AI
Messages
Text and files up to 2 MB
AI model
Optional, uncensored
Price
From $0.49
Account
None. Ever.
Quant-Room
Super Quant-Room
Lifetime
10 minutes
1 hour or 24 hours
People
2
2 to 10, or 1 with the AI model
Messaging
Text
Text and files
Encryption
Hybrid post-quantum, end-to-end
Hybrid post-quantum, end-to-end
Creator tools
Poof it now, remove the guest, pin a message
The same, plus upgrade
Uncensored AI model
No
Optional: +$2 for 1 hour, +$5 for 24 hours
Cost
Free
From $0.49, paid from a wallet
What it costs
You pay once, for one quant-room. The price depends on how long it lives and how many seats it has.
Lifetime
$0.588$0.49 for two + 2 × $0.049
Lifetime
For two
Each extra person
AI model
1 hour
$0.49
+ $0.049
+ $2
24 hours
$1.49
+ $0.009
+ $5
Ten people for 24 hours cost $1.562. With the AI model you can also open a quant-room just for yourself.
Two ways in
Start super. On usepoof.chat pick Super Quant-Room, choose the lifetime and the number of people, pay, and the quant-room opens already unlocked.
Upgrade on the way. Already talking in a free Quant-Room and the timer is running low? The creator presses Upgrade quant-room, pays, and the room changes in place. Same link, same keys, same conversation. Everyone inside is told, the new lifetime counts from the moment of the upgrade, and the number of seats only ever goes up.
QUANT-ROOM ──▶ PAY ──▶ ONE-TIME PASS ──▶ SUPER QUANT-ROOM
10 min · 2 wallet blind-signed 1 h or 24 h · up to 10
same link, same keys
Create or upgrade with a passengine API
// A new Super Quant-Room: the pass decides lifetime and seats.const room = await createRoom({ fetch, origin: API, pass });
// Or upgrade the quant-room you're in (creator only).await session.upgrade(pass);
session.getState().expiresAt; // now + 1 hour or 24 hours
How a group stays private
YOU ════ ANA
╱ ╲ ╱ ╲
KAI ═══╳═══ LEO every pair has its own encrypted link
╲ ╱ ╲ ╱ no group key, no server in the middle
SAM ════ MIA
one message to 5 people = 5 separate encryptions
There is no group key. Every pair of people in a Super Quant-Room builds its own direct connection and runs its own post-quantum handshake, exactly as in a Quant-Room for two. When you send a message, your browser encrypts it once for each person, with that pair's keys, and sends it down each connection. Ten people means 45 separate encrypted links.
Poof's server still only holds the door: it decides who gets one of the paid seats, and nobody can squeeze in once the room is full. People can leave and come back while the room lives. The quant-room goes on until its timer ends or the creator ends it. If two people briefly see a different list of who's inside, for example while someone is still joining, the room shows it instead of hiding it.
Drop files onto the chat or pick several at once. Images show a preview right in the conversation. Each file is cut into pieces of 16 KiB, every piece is encrypted on its own and travels over a separate encrypted channel for files, to each person in the room. The receiving browser checks the size, the number of pieces and finally the SHA-256 fingerprint of the whole file. Only then does it show as delivered.
Rule
Value
Size per file
Up to 2 MB
Piece size
16 KiB, so a 2 MB file is 128 pieces per person
Order
One file at a time in each direction, the rest wait in line
Cancel
The sender or the receiver can stop a transfer at any time
Where it goes
Browser to browser, or through the relay when a direct path is blocked. Always encrypted, never stored on a server
Saved a file? That copy is yours now and stays on your device after the quant-room is gone. Everything you didn't save disappears with the room.
Send a fileengine API
const fileId = await session.sendFile(input.files[0]); // encrypted per person
session.abortTransfer(fileId); // stop it, for everyone
Creator tools
Tool
What it does
Poof it now
Ends the quant-room for everyone. Poof's server deletes it at once.
Remove someone
The server disconnects that person and keeps them out for the rest of the room's life. Everyone drops their link to them.
Pin a message
Hover a message and press the pin. One pinned message for everyone, shown again to people who join later. It travels encrypted, like any message.
Upgrade quant-room
More time and more seats, without leaving the room.
The creator proves who they are with the creator secret kept in their tab, never with an account. Everyone gets a default name like Amber Fox and can pick their own. Type / in the message box for the shortcuts:
Command
Who
What it does
/name new name
Everyone
Change your name
/ban name
Creator
Remove someone from the quant-room
/unpin
Creator
Take down the pinned message
Creator toolsengine API
session.ban(peerId); // remove someone, for good
session.pin(messageId); // pin a message for everyone
session.pin(null); // unpinawait session.destroy(); // Poof it now
An uncensored AI model
When you create a Super Quant-Room you can add an uncensored AI model to it. Talk to it alone, in a quant-room just for you, or bring it into a group: in a room with other people, start a message with @ai to ask it something.
The model runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave. Poof's servers only pass the encrypted text along, and nobody outside the enclave, Poof included, can read it.
YOUR BROWSER ──▶ checks the enclave's proof ──▶ encrypts to the enclave
│
▼
POOF SERVER: passes ciphertext along, can't read it
│
▼
ENCLAVE (Intel TDX): reads, answers, encrypted back to you
│
▼
the answer goes to everyone over the room's encrypted links
Before anything leaves your browser, it asks the enclave for a fresh proof of what it is running, checks that the proof covers the model's key, and only then encrypts to that key. The answer streams back encrypted to your browser, which decrypts it and shares it with everyone in the room over the same encrypted links as any message.
what changes with the AI on
To answer, the model has to read. When someone asks it a question, their browser sends the recent conversation along with it, so the model sees what was said in the room. It keeps no logs and no memory between quant-rooms, and it leaves when the timer ends. Without the AI, nothing changes: no server ever sees your messages. One honest limit: your browser checks what the enclave's proof says, while Intel's signature on that proof is confirmed by the hosting partner, not yet by your browser.
Limit
1 hour
24 hours
Questions per quant-room
150
600
Questions per minute
10
10
Longest answer
1,024 tokens
1,024 tokens
A question the model never answered doesn't count against the room. More on the AI model page.
How payment works
STABLECOINS ──▶ ONE-TIME PASS ──▶ SUPER QUANT-ROOM ──▶ TIMER ENDS ──▶ POOF
USDC · USDG blind-signed same encryption,
to Poof's wallet same nothing-kept
Poof doesn't need to know who you are to give you more. You pay from a wallet, on one of four networks:
Network
Pay with
Ethereum
USDC
Base
USDC
Solana
USDC
Robinhood Chain
USDG
The price on the site is the amount you send: every token is a dollar stablecoin, paid at face value. On a computer, pay from the wallet in your browser. On a phone, Ethereum, Base and Robinhood Chain wallets connect by scanning a code; for Solana, open this site inside your wallet's own browser (Phantom, Solflare).
The payment and the quant-room stay apart through blind signatures. Before you pay, your browser prepares a random one-time pass and “blinds” it. After the payment, Poof signs the blinded pass without being able to see it, and your browser unblinds it. When you spend the pass, Poof can check its own signature, but it has never seen that pass before, so it can't tell which payment the quant-room came from. Each pass works exactly once.
where the money goes
Every payment goes to Poof's treasury on the network you paid on: 0x68222E6dC73e161045233B2b76a47d98F84A7e8C on Ethereum, Base and Robinhood Chain, AGQzMmBEgxTeLonpt11isEu6KBDv4h3VbPofCEy4i8Et on Solana. Once POOF is listed, the whole amount buys back POOF and burns it.
Payments are public on the blockchain, like any transfer: your wallet and the amount can be seen there. What nobody can see is which quant-room that payment opened. Every step is on the Payments page.
Quant-rooms
Pay without an account.
A Super Quant-Room is paid from a wallet, with no sign-up and no profile. Blind signatures keep the payment and the quant-room apart, so Poof can tell that someone paid, but not which room that payment opened.
Networks
Ethereum, Base, Solana, Robinhood Chain
Pay with
USDC or USDG
Account
None. Ever.
What you get
A one-time pass
Link to the room
None, by design
Test networks
Never
YOUR BROWSER POOF SERVER BLOCKCHAIN
1 make a pass, blind it
2 wallet pays Poof's treasury ───────────────────────────────▶
3 wallet signs: payment + blinded pass ──▶
4 reads the payment ─────────▶
5 ◀────────── blind signature
6 unblind: a pass Poof has never seen
7 spend the pass ───────────────▶ Super Quant-Room · pass used up
Step by step
1 · Choose
Pick the lifetime, the number of people and, if you want it, the AI model. That choice is the pass's variant, for example “1 hour, 4 people”. See what it costs. Your browser makes a random pass for that variant and blinds it before anything else happens.
2 · Pay
Connect a wallet: the one in your browser, or, on Ethereum, Base and Robinhood Chain, a phone wallet through WalletConnect. On Solana, a phone pays from the wallet's own browser. The wallet sends the price to Poof's address on the network you picked.
Network
Pay with
Counts after
Ethereum
USDC
2 confirmations
Base
USDC
1 confirmation
Solana
USDC
Finality, about 15 seconds
Robinhood Chain
USDG
1 confirmation
Every token is a dollar stablecoin with six decimals, paid at face value: the price on the site is exactly the amount sent. Only mainnet payments count, never a test network.
3 · Prove it's your payment
Anyone can see a transaction on the blockchain, so seeing it isn't proof that you made it. Your wallet signs one short message that ties the payment to your blinded pass:
What your wallet signsexact text
Poof: unlock a Super Quant-Room
Chain: base
Transaction: 0x…your transaction…
Quant-room: 3600-4
Pass: <fingerprint of your blinded pass>
Poof checks that the signature comes from the wallet that paid (on Solana, the wallet signs the same text with its own key). Someone who copies your transaction id can't use it: they don't have your wallet to sign with. 3600-4 means 1 hour (3,600 seconds) for 4 people; a variant with the AI model ends in -ai.
4 · Get the pass
Poof reads the payment straight from the blockchain. While it's still confirming, the answer is “pending” and your browser simply asks again. Once it counts, Poof signs your blinded pass, without being able to see it, and your browser unblinds the signature. Now you hold a pass that Poof can recognise as its own, but has never seen.
5 · Spend it
Your browser uses the pass to create a Super Quant-Room, or to upgrade the one you're in. Poof checks its signature, records that this pass is used up, and opens the room. Each pass works exactly once.
Paying, from the browserengine API
// Treasury, networks and the pass keys.const cfg = await fetchPayConfig({ fetch, origin: API });
// 1 hour, 4 people: a random pass for it, blinded.const variant = { lifetime: 3600, people: 4, ai: false };
const pending = await startPass(cfg.keys, variant);
// The wallet pays cfg.treasury, then signs:const text = await paymentMessage("base", txHash, pending);
let out;
for (;;) {
out = await redeemPayment({ fetch, origin: API, chain: "base", token: "USDC",
txHash, pending, payer, signature });
if (out.status !== "pending") break; // else: still confirmingawait new Promise((r) => setTimeout(r, 5000));
}
const room = await createRoom({ fetch, origin: API, pass: out.pass });
How a blind signature works
PASS ──▶ BLINDED ──▶ SIGNED, STILL BLIND ──▶ UNBLINDED PASS + SIGNATURE ──▶ USED ONCE
random your browser Poof signs without only your browser Poof knows it's real,
hides it seeing it can do this not where it came from
Picture a letter sealed in an envelope lined with carbon paper. Poof signs the outside of the envelope after checking your payment. The signature presses through onto the letter, but Poof never sees the letter. Later you show the letter on its own: the signature on it is clearly Poof's, yet Poof has no way to tell which envelope it signed.
In technical terms, Poof uses RSA blind signatures (RFC 9474, the RSABSSA-SHA384-PSS-Randomized variant), with one signing key per variant, so a pass is worth exactly what was paid for it. Each key's id is its own fingerprint, and your browser checks it, so a key can't be passed off under another key's name. The blinding factor, the one secret that could connect the two ends, never leaves your browser.
What Poof keeps
Kept, per payment
Never kept
Network and transaction hash
Which quant-room the payment opened
Token, variant, price and the amount that arrived
The pass itself before it's spent
Status: issued or underpaid
The blinding factor
A fingerprint of the blinded pass, so a retry gets the same answer
Names, emails or accounts (there are none)
When a pass is spent, Poof stores only a fingerprint of it, to refuse it a second time. Your browser keeps a payment in progress and any unused passes in its local storage, so a reload doesn't lose what you paid for. Clear your browser data before spending a pass and it's gone from there.
When something goes wrong
What happened
What you see
What to do
The payment is still confirming
“Pending”
Wait, it picks up by itself
Less arrived than the price
The price and what arrived
Write to us with the transaction
The payment is more than a day old
“Older than a day”
Write to us with the transaction
You signed with a different wallet
“Came from another wallet”
Sign with the wallet that paid
The pass got lost before you used it
No pass in this browser
The same payment can be redeemed for a new pass once
Write to contact@usepoof.chat with the network and the transaction hash. That's all we need, and all we'll ask for.
Where the money goes
Poof's treasury
0x68222E6dC73e161045233B2b76a47d98F84A7e8C
The same address on Ethereum, Base and Robinhood Chain.
AGQzMmBEgxTeLonpt11isEu6KBDv4h3VbPofCEy4i8Et
On Solana. Every payment goes to one of the two, and anyone can follow them on the blockchain. Once POOF is listed, the whole amount buys back POOF and burns it.
What it doesn't hide
The payment itself is public. Your wallet, the amount and the time are on the blockchain for anyone to see, like any transfer.
The variant is visible. A pass shows what it buys, for example 24 hours for 6 people. If few people buy that exact kind, it narrows things down.
The keys are Poof's word. Poof publishes one key per variant at api.usepoof.chat/api/pay/config. A dishonest server could, in principle, hand someone a key of their own to recognise them later. Anyone can compare the published keys with what others see.
Timing can hint. Spending a pass seconds after paying, on a quiet day, makes the two easier to match up. Waiting a while before you use it helps.
Quant-rooms
An AI in the room.
Any Super Quant-Room can include an uncensored AI model. Talk to it alone, or ask it something in the middle of a group conversation. It answers, and when the timer ends it leaves with everything else.
Where it runs
A sealed hardware enclave (Intel TDX)
Who can read
Only the enclave
Price
+$2 for 1 hour, +$5 for 24 hours
Questions
150 per 1-hour room, 600 per 24-hour room
Memory
None between quant-rooms
Logs
None
The model runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave. Poof's servers only pass the encrypted text along, and nobody outside the enclave, Poof included, can read it.
How to use it
Quant-room
How you ask
Just you and the AI
Every message goes to the model. Open one by choosing 1 person with the AI model.
A group with the AI
Start a message with @ai. Other messages are never sent to the model on their own, but recent ones travel along as context when someone asks.
In a groupexample
Ana are we still on for saturday?
Amber Fox yes, but where?
Ana @ai three quiet places for a long lunch in Cluj, one line each
AI 1. ... 2. ... 3. ... ← everyone in the room sees the answer
The answer streams in for the person who asked. When it's complete, their browser shares it with everyone in the room over the same encrypted links as any other message.
How a question travels
YOUR BROWSER POOF SERVER ENCLAVE
1 ask for a fresh proof ───────────────────────────────────▶
2 ◀────────────────────────────────────── proof + model key
3 check the proof
4 question, encrypted to the enclave ─────────────────────▶ (Poof sees ciphertext only)
5 ◀───────────────────────────── answer, encrypted to you
6 decrypt, share with the room
1-3 · The proof comes first
Before a single word leaves your browser, it sends the enclave 32 fresh random bytes and asks for a proof of what it is. The proof comes back signed into the hardware's own report, and your browser checks it:
it's a report from an Intel TDX enclave;
the enclave doesn't run in debug mode, where its memory could be read;
the report contains the model's key, so that key lives inside this enclave;
the report contains your 32 random bytes, so it was made just now, for you;
it's the model Poof uses, and nothing else.
If any check fails, nothing is sent.
4-5 · Encrypted both ways
Your browser encrypts the question to the model's key with a fresh one-time key for every message (elliptic-curve key agreement, HKDF-SHA-256 and AES-256-GCM). It also sends a temporary key of its own, and the enclave encrypts every piece of the answer to it. Poof's server forwards the ciphertext both ways and turns away anything that isn't encrypted. Your browser does the same: an answer that arrives unencrypted is refused.
Who may ask
Anyone who is in the quant-room. Each browser derives an AI token from the quant-room key, and the creator registers only the token's fingerprint with Poof. Poof can check that a question comes from someone with the link, without ever learning the key.
What the model sees
To answer well, the model needs the conversation. With each question, the asking browser sends the recent messages along, oldest dropped first, up to about 120 KB of text, with each line marked by the speaker's name. Poof's instructions to the model are public and only explain the format:
The model's instructionsexact text
You are the AI in a private, temporary group chat.
Messages from people are prefixed with their name, like "Ana: ...", and your
own earlier answers with "AI: ...". Answer the latest message, which is
addressed to you. Reply in the language it was written in. Be direct and
concise unless asked for detail. You have no memory beyond this conversation
and no access to the internet.
There are no other rules on top. What “uncensored” means is the model's own behaviour.
Limits
Limit
1 hour
24 hours
Questions per quant-room
150
600
Questions per minute
10
10
Longest answer
1,024 tokens
1,024 tokens
Conversation sent along
About 120 KB
About 120 KB
A question the model never answered is given back to the room's count.
What it doesn't promise
the AI reads what it's asked about
Turning the AI on is a choice to let a model read the conversation it's asked about. Without it, no server ever sees your messages. With it, the enclave does, for as long as it takes to answer.
The proof is checked in part by the partner. Your browser checks what the enclave's report says. Intel's signature on that report, and which exact software image the enclave runs, are confirmed by the hosting partner, not yet by your browser.
Answers are shared. In a group, everyone in the room sees every answer.
Models get things wrong. Treat answers as you would any other message: useful, not authoritative.
Network
Relay nodes.
Most quant-rooms connect browser to browser. When a network won't allow that, a relay carries the encrypted traffic between you. It forwards bytes it can't read. Relay nodes are the next step: more independent relays, run by more operators, under the same rule.
coming next
Relay nodes aren't live yet. Everything under Relays today is how Poof works right now. Relay nodes describes the next feature we're building, and this page changes when it ships.
First choice
A direct link, browser to browser
Relay used
Only when a direct link fails
Transport
TURN over TLS only
Credentials
Issued once two people are paired
Credentials last
Until the quant-room ends, 24 hours at most
The relay sees
IP addresses, timing, volume
Relays today
Two different things in Poof are called a relay. Neither one ever holds a key.
Relay
What it carries
What it never carries
Signaling, on Poof's server
Connection details: offers, answers and network candidates. The server stamps who sent what and keeps none of it.
Messages, files, names, keys. Chat never falls back to this path, not even when a link fails.
Traffic relay (TURN)
Your encrypted traffic, when two browsers can't reach each other directly.
Anything readable. It forwards encrypted bytes and has no key to open them.
Direct, or via a relay
YOU RELAY GUEST
1 try a direct path ──────────────────────────────────────▶
2 blocked by the network
3 encrypted, inside TLS ──▶
4 ──▶ forwarded as it is
5 ◀── answer, encrypted
6 ◀── forwarded as it is
7 sealed · via relay
Every link tries a direct path first. Each browser learns its public address from a STUN server, and the two swap candidates through the signaling relay. If a direct pair works, traffic goes straight from one browser to the other.
Some networks don't allow that: strict office firewalls, some mobile carriers, routers that change your address for every connection. Then the link goes through the relay. Poof only hands out the relay's TLS address, so relayed traffic looks like ordinary encrypted web traffic on the wire.
What the quant-room shows
Once a link is sealed, the status line says sealed · direct or sealed · via relay. Your browser reads which network path the connection picked. If either side goes through the relay, or it can't tell, it says relay: the careful answer. The two browsers also tell each other what they saw, and relay wins. In a group, one relayed link is enough for the quant-room to say via relay.
Read the pathengine API
session.subscribe((state) => {
if (state.status !== "sealed") return;
// "direct", or "relay" if any link uses one
const relay = state.connectionType === "relay";
show(relay ? "sealed · via relay" : "sealed · direct");
});
Credentials that run out
Relay credentials are issued only when two people are paired, never from a public endpoint.
They last as long as the quant-room has left: at least 60 seconds, at most 24 hours. Nobody holds a working relay credential after the quant-room is gone.
When a quant-room becomes a Super Quant-Room, everyone gets fresh credentials for the new end time, and relayed links reconnect with them before the old ones run out.
Only TLS relay addresses are handed out. Plain UDP and TCP relay addresses are dropped.
If relay credentials can't be issued within 3 seconds, the quant-room carries on with direct links only. On networks that allow a direct path nothing changes. On networks that don't, people can't connect until the relay answers again.
What a relay can and can't do
A relay can
A relay can't
See the IP addresses of both ends
Read messages, files or names. They travel inside DTLS and, inside that, Poof's own AES-256-GCM frames, under a key made with ML-KEM-768 that the relay never sees.
See when you're connected and how much traffic goes through
Change a message. Every frame is numbered and authenticated, so an altered, replayed, dropped or reordered frame closes the link.
Stop forwarding
Get a key, or turn a relayed link into a weaker one. A failed handshake refuses the connection; it's never quietly downgraded.
Files follow the same limits direct or via the relay.
Relay nodes: what comes next
coming next
Not live yet. Today every relayed connection goes through one infrastructure provider.
One provider means one place that sees which IP addresses talk through it, and one dependency if it has a bad day. Relay nodes spread that out: independent relays, run by more operators, so no single company carries all of Poof's relayed traffic.
What won't change
These hold because of how the encryption works, not because of who runs the relay:
A node forwards encrypted bytes. End-to-end encryption and the hybrid key stay exactly as they are, and a node never gets a key.
A node can't alter, replay or reorder anything without the link closing.
Credentials stay short-lived and tied to one pairing.
Direct links stay the first choice. A node only carries traffic when a direct path fails.
What a node will still see
The same as today's relay: IP addresses, timing and volume. Spreading relays out lowers how much any one operator sees. It doesn't make relayed traffic anonymous.
Before it ships, this page will say
who can run a node, and what it needs;
how your browser picks a node;
how a node that misbehaves is spotted and dropped;
where the node code lives, open source like the rest of Poof.
What it doesn't promise
A direct link shows your IP address to the other person. Their browser connects to yours, the way any direct connection does. There's no relay-only switch in quant-rooms today. Use a VPN if you need to hide your address.
A relay sees who is connected. Not what is said, but which addresses, when, and how much.
A relay can refuse service. It can't read or change your traffic, but it can stop carrying it, and the link ends.
One-time messages
Poof Secretz.
A secret that opens once. It's encrypted in your browser, the server keeps only what it can't read, and the first reading erases it. Read once. Then poof.
Encryption
AES-256-GCM, in your browser
The key
32 random bytes, only in the link after #
Password
Optional, needed together with the link
Readings
One
Lifetime
10 minutes, 1 hour or 24 hours
Size
Up to 10,000 characters
How a secret travels
WRITER POOF SERVER READER
1 encrypt in this browser
2 ciphertext + 2 hashes ──▶
3 the link, your channel ─────────────────────────────────▶
4 ◀── reveal (POST, token)
5 ──▶ ciphertext, erased now
6 decrypt in this browser
7 ◀── a second reveal
8 ──▶ gone
You write the secret at usepoof.chat/secretz/. Your browser makes a random key and encrypts the secret with it before anything is sent. The server receives the ciphertext, a lifetime and two hashes, and answers with nothing more than when the secret will disappear.
The link looks like usepoof.chat/secretz/#<id>.<key>. Everything after # stays in the browser: it isn't sent with any request, so the key never reaches Poof. You send the link the way you choose.
Opening the link doesn't read the secret. The page says This secret can be read once and waits. Only when the reader presses Reveal secret does the browser ask the server for it. The server hands the ciphertext over and erases it in the same step, so a second request, from anyone, gets gone.
Link previews in Telegram, X or WhatsApp fetch the page, not the secret: a secret is only handed over to a POST that carries the right token, which a preview never sends.
The keys, and the token
LINK KEY (32 bytes, after #) + PASSWORD (optional, PBKDF2 ×200,000)
──▶ HKDF-SHA-256 (salt: the secret id)
──▶ AES-256-GCM key: encrypts the secret
──▶ reveal token: the server keeps only its hash
From the link's key, and the password if there is one, the browser derives two separate things with HKDF-SHA-256: the AES-256-GCM key that encrypts the secret, and a reveal token. The server stores only a SHA-256 hash of the token. To read a secret, a browser has to show the token, which only someone with the key (and the password) can compute.
Someone who learns only a secret's id can't use it up. Without the key there's no token.
A wrong password doesn't erase the secret. The token doesn't match, the server refuses, and the secret stays. After ten wrong tries, the secret deletes itself.
The secret id is part of the encryption's associated data, so a ciphertext can't be moved to another secret without failing to decrypt.
With a password, the link ends in .p, so the page asks for it before anything is requested. The server never learns that a password exists.
What the server sees
Poof's server sees
Poof's server never sees
A random secret id, the ciphertext and its size
The secret, the key or the link after #
The lifetime you picked, and when the secret was read, deleted or expired
The password, or whether there is one
A hash of the reveal token and a hash of the writer's secret
The reveal token or the writer's secret themselves
Your IP address on each request, for rate limits, never written down
Who you sent the link to, or how
Nothing is logged. The ciphertext is erased by the reading itself; what remains is a marker that says read or deleted, so the writer can see what happened, and that marker is wiped at the end of the secret's lifetime along with everything else.
For the writer
When you create a secret, your browser also makes a writer's secret and sends only its hash. With it, the page you wrote the secret on shows a live status (waiting, read, deleted or expired, never any content) and a Delete now button that erases the secret before anyone reads it.
The link is shown once and isn't kept anywhere. The writer's id and secret stay in that browser tab only, so a reload keeps the status and the delete button; closing the tab forgets them.
Limit
Value
Text
10,000 characters, at most 16 KiB once encrypted (text outside ASCII takes more room)
Lifetime if nobody reads it
10 minutes, 1 hour or 24 hours
New secrets
10 per minute from one IP address
Readings, status checks and deletes
30 per minute from one IP address
Wrong passwords
10, then the secret deletes itself
By four words
A link is hard to say out loud. The writer can turn it into four words instead, through the same one-time mailbox as quant-room invites: the link is encrypted under a key derived from the words, which work once, for 3 minutes. The reader types them on usepoof.chat/secretz/, gets the secret's link back in the browser, and still decides when to reveal it.
Four words are a short secret. They're meant to be used within minutes; a new phrase replaces an expired one while the secret is waiting.
For developers
Write, then read onceengine API
// the writer
const note = await createNote({ fetch, origin, appOrigin, text, ttl: 3600 });
send(note.url); // usepoof.chat/note/#<id>.<key>// the reader, only when they choose to
const link = parseNoteFragment(location.hash);
const text = await revealNote({ fetch, origin, link }); // a second call throws note_gone
The routes are POST /api/notes, POST /api/notes/:id/reveal, POST /api/notes/:id/status and DELETE /api/notes/:id. See the API reference.
What it doesn't promise
Whoever opens the link first reads the secret. If someone else gets the link before the person you meant, they can read it, and the secret is gone for your reader. Add a password, or send the link and the password through different channels.
The reader can keep it. They can copy the text or take a screenshot. Read once is about the server, not about what the reader does.
The link is as safe as the way you send it. A chat app that stores your messages stores the link too. That's what the password and the four words are for.
Symmetric encryption only. A secret uses AES-256 and a key carried in the link. There's no key exchange with public keys, so nothing in it depends on a key agreement holding up, and there's nothing to verify about who wrote it.
A password is only as strong as you make it. It's stretched with PBKDF2 and needs the link too, but a short one is easier to guess for someone who has the link.
Quantum, part 1
What happens to today's secrets when tomorrow's computers arrive?
Encryption is a bet that some maths problems are too hard to solve. Quantum computers change which problems are hard. This page explains how, without the hype.
Bits and qubits
A normal bit is 0 or 1. A qubit can be in a combination of both, called superposition, until you measure it, and then it becomes a plain 0 or 1. Quantum algorithms use quantum gates to arrange those combinations so that wrong answers cancel out and right answers become likely when you measure. That is not “trying every answer at once”. It only helps for problems with special structure. Try it in the Quantum Lab.
Two kinds of encryption, two kinds of risk
Public-key cryptography (RSA, elliptic curves, ECDH key exchange, digital signatures) lets two strangers agree on a secret. It relies on problems like factoring large numbers or computing discrete logarithms. Symmetric cryptography (AES) encrypts the actual data once both sides share a key. It relies on the key simply being too big to guess.
CLASSICAL COMPUTER QUANTUM COMPUTER
│ │
┌────────▼────────┐ ┌─────────▼─────────┐
│ RSA · ECC │ │ Shor's algorithm │
│ factoring / │ │ factoring and │
│ discrete logs │ │ discrete logs │
└────────┬────────┘ └─────────┬─────────┘
▼ ▼
impractical to solve solvable, on a large enough
error-corrected machine
A picture of the idea, not a description of how Shor's algorithm works inside. Concept
Algorithm
Used for
Quantum attack
Effect
RSA
Key exchange, signatures
Shor
Broken by a large enough quantum computer
ECDH, ECDSA, Ed25519
Key exchange, signatures
Shor
Broken by a large enough quantum computer
AES-256
Encrypting data
Grover
Weakened (roughly the strength of a 128-bit key). Still considered strong.
SHA-256
Hashing
Grover-type
Margins shrink, still considered safe for most uses
So the weak spot is the handshake
The data itself (AES-256) holds up well. The vulnerable moment is when two parties agree on a key with RSA or elliptic curves. If someone can later recover that key exchange, they can unlock everything it protected.
Today vs tomorrow
No quantum computer is publicly known to break RSA or elliptic-curve keys at the sizes used on the internet. That would take a large, error-corrected machine, often called a “cryptographically relevant quantum computer”. Nobody can give a reliable date for one. The reason to act now anyway is on the next page.
Quantum, part 2
Harvest now, decrypt later.
You do not need a quantum computer today to attack today's messages. You only need to record them and wait.
TODAY SOMEDAY
───── ───────
encrypted traffic quantum capability
│ │
▼ ▼
┌──────────────┐ store ┌──────────────┐ ┌──────────────────┐
│ attacker │ ────────▶ │ encrypted │──▶│ try to recover │
│ records it │ │ archive │ │ the key exchange │
└──────────────┘ └──────────────┘ └──────────────────┘
Anyone who can watch a network (an internet provider, a compromised router, a state agency) can save encrypted traffic cheaply and keep it for years. If that traffic relied only on RSA or elliptic-curve key exchange, a future quantum computer could unlock it. For conversations that must stay private for a long time, the risk starts the day they are recorded.
How Poof answers it
MINIMIZE WHAT EXISTS nothing stored on servers, quant-rooms expire
+ HYBRID POST-QUANTUM KEYS classical key + ML-KEM-768
+ FRESH KEYS PER QUANT-ROOM each quant-room gets new keys, then they're gone
+ KEYS STAY IN THE BROWSER the server never holds them
──────────────────────────
= LESS LONG-TERM EXPOSURE
Ephemerality alone is not enough. Poof deleting things does not stop someone else from recording traffic on the network. That is why the encryption itself holds up against future quantum attacks, which is the job of the hybrid post-quantum key. See it play out in the Quantum Lab.
What this does not solve
A compromised device. If your phone or browser is infected, messages can be read before they are encrypted.
The link. The classical half of the key travels in the quant-room link. Someone who captured the link and broke the post-quantum exchange could read the quant-room. Both are needed.
Metadata. A recorder still sees that two IP addresses talked, when, and for how long.
Quantum, part 3
Two locks on every quant-room.
Post-quantum cryptography is ordinary software that runs on today's devices, built on maths problems believed to be hard even for quantum computers.
The NIST standards
In 2024 the U.S. National Institute of Standards and Technology published the first post-quantum standards:
Standard
Name
Job
Based on
FIPS 203
ML-KEM
Agreeing on a shared key
Module lattices
FIPS 204
ML-DSA
Digital signatures
Module lattices
FIPS 205
SLH-DSA
Digital signatures
Hash functions only
Poof uses ML-KEM-768 for its key exchange.
What a KEM does Concept
A key encapsulation mechanism works like a lockbox. Your guest publishes an open padlock (public key). You put a random secret in a box, snap the padlock shut and send it (ciphertext). Only your guest has the key that opens it. Now you both share the same secret, and anyone who watched only saw a locked box.
ML-KEM-768 in numbers
Item
ML-KEM-768
For comparison: X25519
Public key
1,184 bytes
32 bytes
Ciphertext
1,088 bytes
32 bytes
Shared secret
32 bytes
32 bytes
Security level
NIST category 3
Not quantum-resistant
The keys are bigger, but for a chat handshake a couple of kilobytes, once per quant-room, makes no noticeable difference.
Why hybrid
Post-quantum algorithms are newer than RSA or elliptic curves. A hybrid design does not bet everything on one of them: it combines a classical secret with a post-quantum one, so an attacker has to break both.
QUANT-ROOM KEY (classical) ML-KEM-768 SHARED SECRET
256-bit, made in your browser, agreed directly between browsers
carried in the link after # over the encrypted data channel
│ │
└──────────────┐ ┌───────────────┘
▼ ▼
┌────────────────────┐
│ HKDF-SHA-256 │ both in, bound to the exchange
└─────────┬──────────┘
▼
HYBRID KEY · AES-256-GCM
one key per direction, every message
Both secrets go into HKDF-SHA-256 together, as one input, with a fixed, versioned Poof label and a hash of the whole exchange: the room, the two people, the public key and the ciphertext. The result stays secret as long as either half does. From it each side derives one key per direction and a confirmation key. Before any message, both browsers prove they arrived at the same result with an HMAC-SHA-256, each side using its own label, so a confirmation can't simply be bounced back. A tampered handshake fails this check and the connection is refused. Every label is on the developer guide.
Implementation notes
In the browser. Browsers don't ship ML-KEM yet, so Poof uses a pinned open-source implementation bundled into its engine, never fetched from a third-party server at runtime. AES-GCM, HKDF and HMAC come from the browser's own Web Crypto API.
Side channels. The ML-KEM library is written to avoid secret-dependent branches, and MAC checks go through Web Crypto, which compares in constant time. JavaScript in a browser can't promise strict constant time for everything, so the hybrid design never relies on one half alone.
Signatures. Poof does not use post-quantum signatures. Quant-room integrity comes from the shared keys and key confirmation, not from long-term identities.
Quantum Lab Concept
Play with the ideas.
Three small experiments that make the quantum chapters tangible. They are teaching models, not simulations of real hardware or of Poof's code.
1 · A qubit, measured
|0⟩
|1⟩
Before measurement the qubit holds both possibilities. Each measurement gives a plain 0 or 1, and the pattern of results reveals the probabilities.
2 · Two locks
The session key comes from both secrets. Knowing one of them is not enough.
3 · Harvest now, decrypt later
Recorded conversation
Status
Classical key exchange only (RSA / ECDH)
Poof: hybrid key (classical + ML-KEM-768)
Copies on Poof's servers
You choose the year. Nobody can reliably predict it, which is exactly why protection has to be in place before it.
Security
Every lock, and what it rests on.
For each protection: the threat it answers, the mechanism, what has to be true for it to work, and where it stops.
┌─────────────────────── YOUR BROWSER ──────────────────────────┐
│ quant-room key (from the link) ─┐ │
│ ├─▶ HKDF ─▶ keys ─▶ AES-256-GCM │──┐
│ ML-KEM-768 secret ─────────────┘ │ │ ciphertext only
└───────────────────────────────────────────────────────────────┘ │
│ signaling (no keys, no content) ▼
┌───────▼────────┐ ┌────────────────────┐
│ POOF SERVER │ room id + end time, short-lived │ WebRTC data channel│
│ no message │ │ direct, or via a │
│ storage │ │ TURN relay │
└────────────────┘ └────────────────────┘
The locks
End-to-end encryption
threatServers or networks reading messages
mechanismAES-256-GCM in the browser, a separate key for each direction, a counter for every frame
assumesYour browser and device are not compromised
limitDoesn't protect what's on screen
Key in the fragment
threatThe server learning the key
mechanismThe key lives after #, is generated after the server's answer and is never put in a request
assumesThe code you run is genuine
limitAnyone with the link has the key
Hybrid post-quantum key
threatRecorded traffic decrypted later
mechanismQuant-room key and ML-KEM-768 secret mixed with HKDF-SHA-256, bound to the room and both people
assumesAt least one of the two stays secret
limitMetadata stays visible to recorders
Key confirmation
threatTampering with the handshake
mechanismMutual HMAC-SHA-256 over the whole exchange, checked in constant time
assumesThe link reached the right person
limitSomeone with the link could sit in the middle; the safety code that would show it isn't on screen yet
Strict frame order
threatReplayed, dropped or reordered messages
mechanismPer-direction counters, header authenticated with every frame
assumesNone beyond the keys
limitA broken link ends the conversation instead of repairing it
Short-lived server state
threatOld data leaking later
mechanismOne small server object per quant-room, deleted when it ends; no message storage
assumesServer configuration as published
limitCan't erase copies someone else made
No logs
threatLogs revealing who talked to whom
mechanismThe API writes no logs and platform logging is off; no analytics or cookies
assumesHosting layers follow the same policy
limitThe hosting provider keeps request metrics; networks keep their own logs
A narrow API
threatOther sites or scripts abusing it
mechanismOnly usepoof.chat may call it from a browser, JSON only, a size and rate limit on every input
assumesBrowsers enforce CORS and origin checks
limitDenial of service by sheer volume
The client distrusts the server
threatA hostile server exhausting your browser
mechanismPeer counts, file sizes and relay lists are capped in the browser too
assumesNone
limitThe server can still refuse service
Relay (TURN)
threatNetworks that block direct connections
mechanismCredentials only once two people are paired, valid until the room ends, TLS only
assumesThe relay only forwards
limitThe relay sees IP addresses and volume
Four-word phrase
threatGuessing the phrase
mechanismPBKDF2-SHA-256, 200,000 rounds; one read; gone after 3 minutes
limitThe payment itself is public on the blockchain
AI in an enclave
threatAnyone but the model reading AI questions
mechanismFresh enclave proof checked in the browser, end-to-end encryption to the enclave
assumesThe hardware enclave holds
limitIntel's signature on the proof is confirmed by the hosting partner, not yet by the browser
Hardened pages
threatA downgrade to plain HTTP, Poof shown inside another site, links revealing where you came from, injected code loading from or sending data to somewhere else
mechanismHTTPS enforced for a year (HSTS), a Content Security Policy that lets the pages load code and connect only to Poof and a short list of named services (fonts, a code CDN, chain nodes, WalletConnect), no embedding in other sites, no referrer sent to external links, no guessing of file types, and camera, microphone, location, payments and USB switched off
assumesThe browser honours the headers
limitInline scripts are still allowed, because the pages carry their own code inline, so the policy can't stop an injected inline script from running. The signed engine checksum is how you check the code that holds your keys
In-app browser warning
threatApps injecting code into the page
mechanismInstagram, Facebook, TikTok and similar are detected
assumesThe person follows the advice
limitPoof can only warn, not stop the app
Limits the code enforces
Input
Limit
New quant-rooms
5 per minute per IP address
Joining a room
10 per minute per IP address
Four-word phrases
10 per minute per IP address; a locked link of at most 2 KiB, one read, 3 minutes
Request bodies
At most 4 KiB, cut off while reading
WebSocket messages
Text only, at most 32 KiB, schema-checked; the second malformed one closes the socket
Connection details (signals)
At most 16 KiB each, 200 per pairing
Chat message
5,000 characters, normalised
Files
2 MB; browsers refuse anything over 64 MiB whatever the server says
Payments and AI
30 requests per minute per IP address; AI 10 questions per minute per room
Rate limits count per IP address and per data center. The address is used only to count, never stored. Every limit has tests that go past it, and every parser is fuzzed.
Supply chain
Five small libraries in the engine, all cryptography or the word list, locked to exact versions and checked for known vulnerabilities (pnpm audit) on every change.
Dependabot for libraries and for the build pipeline, whose actions are pinned to exact commits.
Reproducible, signed releases of the API and the engine. See Verify it yourself.
Where does data go?
Everything Poof touches, and when it's gone.
CREATE ──▶ PROCESS ──▶ TRANSMIT ──▶ USE ──▶ EXPIRE ──▶ DELETE ──▶ POOF
On Poof's server
Data
Created
How long
Then
Quant-room record: id, seats, end time, fingerprint of the creator secret
When you create a quant-room
The room's lifetime: 10 minutes, 1 hour or 24 hours
The link's fragment, memory, and this tab's session storage so a reload brings you back
While the tab is open and the room lives
Gone when the tab closes or the room ends
Creator secret
The creator's browser, local storage
Until the room ends
Removed, and swept on the next visit if the tab closed first
ML-KEM keys and the shared secret
Memory, per pair of people
The handshake
Wiped once the keys are derived
Session keys
Memory
While the link is up
Gone when it closes
Messages, names, received files
Your screen and memory
Until the conversation ends
Wiped when the other person leaves; after the timer, readable until you leave the page
A payment in progress, unused passes
Local storage
Until the pass is spent
Removed when used
Elsewhere
Data
Where
How long
Encrypted traffic
The relay, when a direct path is blocked
Forwarded, never stored by Poof
An AI question and the conversation sent with it
The AI enclave
While it answers; no logs, no memory
Your payment
The blockchain
Forever, like every transaction
Backups: none for quant-rooms. Their state exists only while the room lives, so there is nothing to back up.
What Poof can't erase
Screenshots, copied text, files your guest saved, payments on the blockchain, and logs kept by internet providers along the way. Ephemerality covers what Poof controls.
Threat model
Who can learn what.
A security promise is only useful if it says who it protects you from, and who it doesn't.
protects against
Poof's own servers reading your messages, with or without the AI model
Network eavesdroppers reading content
Messages tampered with, replayed or reordered on the way
Old servers or databases leaking conversations later
Recorded traffic decrypted by a future quantum computer (both keys needed)
A payment being linked to the quant-room it opened
does not protect against
A compromised phone, computer, browser extension or in-app browser
The person you're talking to (screenshots, copying)
Someone who gets the link or the phrase
The AI model, in rooms where it's on: it reads what it's asked about
Network observers seeing that you connected, and when
Anyone reading your payment on the blockchain
Attacker by attacker
Attacker
Can learn
Cannot learn
Passive network observer
That you use Poof, timing, traffic size
Message content
Active network attacker
The same, and can block connections
Content. Tampering fails key confirmation, and altered frames close the link
Poof's server, honest but curious
Quant-room ids, seats, end times, IP addresses and timing while connected
Keys, messages, files, names, the four words behind a phrase
Poof's server, hostile, without the link
The same, and it can deny service
Content. It can sit in the middle of the handshake, but without the link's key the confirmation fails
Poof's server, hostile, with the link
Everything, by sitting in the middle
It can't hide once the safety code is on screen
Someone serving altered page code
Everything, as with any web app
Not unnoticed: the engine is open and attested, see Verify
Someone with the link
Joins if a seat is free; could sit between two people
Nothing more than any participant
Compromised relay (TURN)
IP addresses, traffic volume
Content
The AI enclave (only with the AI on)
The question and the conversation sent along with it
Anything from quant-rooms without the AI. It keeps no logs and no memory
Blockchain observer
Your wallet, the amount, the time of a payment
Which quant-room it opened
Malicious guest
Everything you send them
Nothing protects you here
Malware, a bad extension or an in-app browser
Everything on screen, and the key
Nothing protects you here
Future quantum attacker with recordings
Metadata
Content, unless they also captured the link and broke ML-KEM
Known limits, in plain words
No safety code on screen yet. The engine computes it; the quant-room doesn't show it. Until it does, a link that reaches the wrong person can be used to sit in the middle. Share links privately.
The AI enclave's proof is partly checked by the partner. Your browser checks what the proof says. Intel's signature on it, and which software the enclave runs, are confirmed by the hosting partner.
Payment keys are Poof's word. A dishonest server could, in principle, hand someone their own pass key to recognise them later. The published keys can be compared by anyone.
Rate limits are per data center. Someone with many addresses can still flood the service.
The web-app problem
Any website can be changed by whoever runs the server. In theory, a compromised server could send you code that leaks your key. Poof's answer is to make the code that matters checkable: the engine that holds your keys is one open, unminified file, built reproducibly, signed with every release, and served next to its checksum. A change to it can't go unnoticed by anyone who looks. See Verify it yourself.
Transparency
Don't trust the docs. Check the code.
Every claim on these pages points to something you can inspect: the source, the build that produced the live server, and the exact engine file your browser runs.
PUBLIC COMMIT ──▶ GITHUB ACTIONS ──▶ ATTESTED RELEASE ──▶ LIVE API ──▶ ENGINE IN YOUR BROWSER
on main tests, same bytes signed checksums /api/health = commit sha256 matches the release
Claim by claim
Claim
Where to look
How to check
The key never reaches the server
How browsers treat the # fragment; packages/core/src/api.ts
DevTools → Network: no request contains the key
Messages are end-to-end encrypted
packages/core/src/crypto/
Read it; the WebSocket only ever carries connection details
Post-quantum key exchange
crypto/handshake.ts and its tests
Check the ML-KEM-768 library and crypto.test.ts
Nothing is kept after a room ends
worker/src/room-do.ts, worker/wrangler.jsonc
Room state is deleted at the end; logging is switched off
Every push to main runs the Deploy workflow. It tests the code, bundles the API, checks that bundling twice gives identical bytes, signs the result and deploys exactly those bytes. Then it checks that the live API reports that commit. A server that answers "commit":"dev" wasn't deployed this way.
2 · Check the release
Verify the signed releaseGitHub CLI
# The Deploy run for that commit
gh run list --repo usepoofchat/poof-app --workflow deploy.yml
# Its signed files, kept for 90 days
gh run download RUN_ID --repo usepoofchat/poof-app -n release -D release
gh attestation verify release/worker-checksums.sha256 --repo usepoofchat/poof-app
gh attestation verify release/worker-bundle/index.js --repo usepoofchat/poof-app
gh attestation verify release/poof-engine.js --repo usepoofchat/poof-app
A successful check means GitHub's signing service vouches that these exact files were built by the repository's own workflow, from that public commit.
3 · Check the engine your browser runs
Compare the served engine with the releaseany terminal
curl -s https://usepoof.chat/engine/poof-engine.js | sha256sum
curl -s https://usepoof.chat/engine/poof-engine.js.sha256
cat release/engine-checksums.sha256
# all three must show the same 64 characters
The engine is the part of the web app that holds your keys: room creation, the key exchange, every encryption and decryption. usepoof.chat serves it as one plain, unminified file next to its checksum and the commit it was built from, so anyone can read it and compare it with the signed release.
You can check the first claim without trusting Poof. It's how every browser works:
Open any link with a #something at the end.
Open DevTools (F12) → Network and reload.
Look at the request URL. Everything after # is missing. It never left your browser.
Then, inside a quant-room, open the WS filter in the same panel and click the WebSocket. You'll see the connection details going back and forth and nothing you typed: your messages travel on a different, direct channel, already encrypted.
What this proves, and what it doesn't
Proves
Doesn't prove
The signed files were built by GitHub Actions from that public commit, by the repository's own workflow
What runs on the server at this second. Nobody outside the hosting provider can download it, and a server could report any commit. The API never sees keys or messages, so this concerns metadata, not what you say
Those exact bytes were uploaded as the live API
The web page around the engine. The HTML of usepoof.chat is published openly but isn't part of the signed release
The engine file usepoof.chat serves can be matched to a signed build, byte for byte
Anything about your own device, browser or extensions
Security reports
Found something? Tell us first.
If you believe you've found a security issue in Poof, we want to hear about it, privately, before anyone else does.
How to report
Email security@usepoof.chat with a description, steps to reproduce and the impact you expect.
Please don't test against other people's quant-rooms, and don't publish details until we've had time to fix it.
Include your PGP key if you'd like an encrypted reply.
Mention the commit you tested. https://api.usepoof.chat/api/health shows the live one.
We acknowledge every report within 48 hours, assess severity, agree a fix plan and coordinate the disclosure date with you. We credit reporters publicly if they wish.
Joining quant-rooms without the link or phrase, linking payments to quant-rooms
Medium
Metadata leaks beyond what the threat model describes
Low
Hardening gaps without a direct impact
Safe harbour
We won't take legal action against good-faith research that avoids privacy violations, data destruction and service disruption, accesses no more than needed to show the issue, and gives us reasonable time to fix it before disclosure.
Out of scope
Attacks that need a compromised device or browser, including a malicious extension or an in-app browser, and social engineering.
Denial of service through volume. Rate limits count per IP address and per data center.
Issues in third-party services outside Poof's control.
Missing security headers on the API's JSON responses. They aren't documents, and they carry nosniff and no-store.
Reports that only come from automated scanners, without a concrete impact.
Only the current version is supported: there are no older releases to patch. Reports that show a gap between these docs and the code are exactly what we want.
For developers
The protocol, step by step.
How the Poof engine talks to Poof's server and to other browsers. Every name, size and label on this page comes from the open-source code, so you can read it side by side with the repository.
WebRTC, with two ordered, reliable DataChannels per pair: poof-ctl for chat and control, poof-files for files
Signaling
WebSocket at wss://api.usepoof.chat/ws/rooms/:id. The server relays connection details and never keeps them
Quant-room state
One short-lived server object per quant-room, deleted when it ends. No message storage, ever
Client
The engine: TypeScript compiled to one file, poof-engine.js, the same bytes on every build. Nothing is loaded from third-party servers at runtime
Classical crypto
The browser's Web Crypto API: AES-256-GCM, HKDF-SHA-256, HMAC-SHA-256, SHA-256, PBKDF2
Post-quantum
ML-KEM-768 (FIPS 203), from a pinned open-source implementation bundled into the engine
Wire format
Protocol version 1. Every HTTP body, WebSocket message and frame is checked against a schema, with a size limit
NAT traversal
STUN, plus TURN over TLS only (turns:)
From click to sealed
YOU POOF SERVER GUEST
1 POST /api/rooms {ownerHash} ──▶
2 ◀── roomId + expiry
3 make the 32-byte key (never sent)
4 WebSocket join ───────────────▶ welcome
5 ◀──────────────── joins with the link
6 paired: roles + relay credentials ──▶ both
7 offer · answer · ICE, relayed through the server ─────────────────▶
8 ◀═══════════════ two DataChannels open (DTLS) ═════════════════════▶
9 ◀═══════════════ hybrid handshake (ML-KEM-768) ════════════════════▶
10 sealed: chat is on
The server pairs people by itself. When someone joins, it sends paired to both sides, with a role and the relay credentials. The member who joined first is the initiator: it makes the WebRTC offer and starts the key exchange. The server stamps the sender of every signal itself, from the socket it came on, so nobody can pretend to be someone else in the room. In a group, every pair goes through steps 6 to 10 on its own.
The hybrid handshake
INITIATOR (A) RESPONDER (B)
────────────── ──────────────
════════ 2 DataChannels open (DTLS) ════════
(pk, sk) = ML-KEM-768.KeyGen()
1 ── pq.hello { pk } (1,184 bytes) ───────────────▶
(ct, SQ) = ML-KEM-768.Encaps(pk)
T = transcript hash · K = master key
2 ◀────────────── pq.reply { ct (1,088 bytes), MAC_R } ──
SQ = Decaps(sk, ct) · K · check MAC_R
3 ── pq.confirm { MAC_I } ─────────────────────────▶ check MAC_I
sealed: one AES-256-GCM key per direction, derived from K
The handshake runs inside the DataChannel, before any chat. Both sides mix two secrets: K_C, the 32-byte quant-room key from the link, and SQ, the shared secret from ML-KEM-768. The derivation is bound to everything the two sides just exchanged:
Key derivationexact labels
T = SHA-256( "poof/v1/transcript" ‖ len‖roomId ‖ len‖initiatorId ‖ len‖responderId
‖ len‖pk ‖ len‖ct )
K = HKDF-SHA-256( ikm = K_C ‖ SQ,
salt = "poof/v1/salt",
info = "poof/v1/master" ‖ T )
confirm key = HKDF(K, "poof/v1/confirm")
A → B key = HKDF(K, "poof/v1/key/initiator-to-responder")
B → A key = HKDF(K, "poof/v1/key/responder-to-initiator")
safety code = HKDF(K, "poof/v1/sas")
MAC_R = HMAC-SHA-256( confirm key, "poof/v1/mac/responder" ‖ T )
MAC_I = HMAC-SHA-256( confirm key, "poof/v1/mac/initiator" ‖ T )
Putting both secrets into the same input is the standard hybrid combiner: K stays secret as long as eitherK_C or SQ does. Binding the room id and both member ids into T means a handshake can't be replayed or spliced between a different pair of people. Each side checks the other's MAC in constant time. If a check fails, the connection is refused, never quietly downgraded.
honest limit
Someone who doesn't have the link can't derive K, so even a hostile server sitting in the middle fails the MAC check. Someone who does have the link could run two separate handshakes, one with each of you, and both would pass. Comparing the safety code on two screens would expose that. The engine already derives it; the room doesn't show it yet. Until it does, share the link only with the person it's meant for.
Frames on the wire
header (11 bytes, sent in clear, authenticated) encrypted
version · channel · type · seq (8 bytes) AES-256-GCM(payload) + tag (16 bytes)
nonce = channel ‖ 00 00 00 ‖ seq (12 bytes, never sent, never repeats)
AAD = the 11 header bytes
After the handshake every message is a binary frame. Each direction has its own key and each channel its own counter, starting at 0 and going up by exactly 1. The receiver rebuilds the nonce from the header and checks the counter before decrypting. DataChannels are ordered and reliable, so any gap, repeat or reflection can only be tampering: the link is closed.
The receiver's verdict after hashing the whole file
A 16 KiB file chunk makes a frame of 11 + 20 + 16,384 + 16 bytes, far below the 64 KiB every browser accepts per DataChannel message.
Using the engine
The web app at usepoof.chat loads the engine as one file, /engine/poof-engine.js. Everything the browser does lives there: room creation, links and phrases, the key exchange, frames, WebRTC and the room's state. A page only renders state and calls a handful of commands.
A whole quant-roomengine API
import {
createRoom, RoomSession, parseInviteFragment,
browserSocketFactory, browserRtcFactory,
} from"/engine/poof-engine.js";
const API = "https://api.usepoof.chat";
// Creator: a new room. A guest instead reads the link it was given:// const { roomId, key } = parseInviteFragment(location.hash);const room = await createRoom({ fetch, origin: API });
const session = new RoomSession({
roomId: room.roomId, roomKey: room.key, ownerSecret: room.ownerSecret,
origin: API, appOrigin: location.origin, fetch: fetch.bind(window),
createSocket: browserSocketFactory, createPeerConnection: browserRtcFactory,
});
session.subscribe((s) => {
s.status; // loading, waiting, connecting, connected, sealed, terminated, expired, error
s.inviteUrl; // the full link, for copying or a QR code
s.expiresAt; // already corrected for clock skew
});
await session.start();
await session.sendMessage("hi");
Command
What it does
sendMessage(text)
Encrypt and send to everyone connected
sendFile(file), abortTransfer(id)
Files, Super Quant-Rooms only
setNickname(name), setTyping(on)
Your name and the typing hint
createPhrase()
Put the link behind four words, one use, 3 minutes
ban(peerId), pin(id), destroy()
Creator tools
upgrade(pass)
Turn the room into a Super Quant-Room
suspend(), leave()
Reload without leaving, or leave for good
Rules the code keeps
Keys are made in the browser and stay there. The room key lives in the link's fragment and in memory, never in a request, a header or a log.
The server never sees content. Chat, files, file names and names travel only as end-to-end encrypted frames.
Signaling is a relay, not a transport. Chat never goes over the WebSocket, not even as a fallback.
The server enforces capacity. It decides who gets a seat; a client can't talk its way past it.
Quant-rooms are ephemeral. Server state is deleted when a room expires or ends.
Logging stays off. The API writes no logs, and there are no analytics, cookies or third-party scripts.
The API stays narrow. Only usepoof.chat may call it from a browser, and it serves nothing but /api/* and /ws/*.
Every input has a limit, a schema, and tests that go past it.
The client doesn't trust the server for resources. Peer counts, file sizes and relay lists are capped in the browser too.
Wire changes are versioned. Any incompatible change bumps the protocol version.
Builds are reproducible and attested. Same commit, same bytes. See Verify it yourself.
Running it locally
Start Poof on your machineNode 22+, pnpm 10
git clone https://github.com/usepoofchat/poof-app && cd poof-app
corepack enable
pnpm install
pnpm dev # the smoke-test page on :5173, the API on :8787
Open http://localhost:5173 in two browser profiles (or one normal and one private window) and create a quant-room between them. The page shows the status, whether the path is direct or relayed, the chat and the raw log of the handshake. Add ?relay=1 before the # to force the connection through the relay.
Command
What it runs
pnpm check
Types, lint, unit tests and the engine against a real local API
pnpm test:browser
Real Chrome over real WebRTC: rooms for two and a 4-person group
pnpm build:engine
Builds poof-engine.js, the same bytes every time
For developers
API reference.
Everything Poof's server answers to, at https://api.usepoof.chat. It's deliberately small: it creates quant-rooms, introduces browsers to each other, holds four-word mailboxes for a few minutes and turns payments into passes. It never sees a key or a message.
Base URL
api.usepoof.chat
Paths
/api/* and /ws/* only
Format
JSON, schema-checked
Browsers
Only usepoof.chat (CORS)
Auth
None. Proofs, not accounts
Logs
None
Browsers may call the API only from https://usepoof.chat, without cookies or credentials. Requests without an Origin header, like curl, are fine. Every POST and PUT needs Content-Type: application/json and a body of at most 4 KiB. Rate limits count per IP address, per data center, and the address is never stored.
Endpoints
Method and path
What it does
Limit
GET /api/health
Is it up, and which commit is live
POST /api/rooms
Create a quant-room (with a pass: a Super Quant-Room)
5 / min
GET /api/rooms/:id
Public facts about a live room
30 / min
POST /api/rooms/:id/upgrade
Creator: turn the room into a Super Quant-Room
30 / min
PUT /api/handshakes/:id
Leave a locked link behind four words
10 / min
POST /api/handshakes/:id/take
Take it, once
10 / min
POST /api/notes
Store an encrypted Poof Secretz secret
10 / min
POST /api/notes/:id/reveal
Read it, once (erased in the same step)
30 / min
POST /api/notes/:id/status
For the writer: waiting, read, deleted or expired
30 / min
DELETE /api/notes/:id
For the writer: delete it unread
30 / min
GET /api/pay/config
Networks, each with Poof's address and its tokens, and the pass keys
POST /api/pay/redeem
Payment in, blind signature out
30 / min
POST /api/rooms/:id/ai
Creator: register the room's AI token fingerprint
30 / min
POST /api/ai/attestation
A fresh proof from the AI enclave
30 / min
POST /api/ai/chat
Forward one encrypted question, stream the encrypted answer
// Request: only the fingerprint of the creator secret (SHA-256, base64url).
{ "ownerHash": "3vQ…43 characters" }
// A Super Quant-Room adds: "pass": { variant, keyId, msg, signature }// Response
{
"roomId": "Q2xL8vT0b3nZkR1pWq4yHg",
"expiresAt": 1791200400000, "serverNow": 1791199800000,
"plan": "free", "tier": "free", "maxPeers": 2,
"limits": { "fileTransfer": false, "fileMaxBytes": 2097152 },
"ai": false
}
The key is not part of any of this. The browser generates it after this answer arrives and keeps it in the link's fragment. GET /api/rooms/:id returns the same fields plus peers, the number of people inside. tier is free, 60m or 24h.
The server checks the secret against the fingerprint it was given at creation. The new lifetime starts now, seats only go up, and everyone in the room gets room.upgraded.
Four-word mailboxes
Leave and take a locked linkPUT, POST /api/handshakes
// :id = 43 characters derived from the four words (PBKDF2, 200,000 rounds)
PUT /api/handshakes/:id { "blob": "base64(nonce ‖ AES-GCM(link))" } → 201 { "expiresAt" }
POST /api/handshakes/:id/take → 200 { "blob" }
The blob is at most 2 KiB and lives for 3 minutes. take returns and deletes it in one step, so the second attempt gets handshake_not_found. An id that already holds a blob can't be filled again until it's taken or expires (handshake_exists).
Poof Secretz
Store, read once, check, delete/api/notes
// :id = 22 characters, made by the writer's browser; the key never leaves it
POST /api/notes { "id", "ciphertext", "ttl": 600 | 3600 | 86400, "creatorHash", "revealHash" } → 201 { "id", "expiresAt" }
POST /api/notes/:id/reveal { "revealToken" } → 200 { "ciphertext" } · 403 wrong_secret · 410 note_gone
POST /api/notes/:id/status { "creatorSecret" } → 200 { "state", "expiresAt" }
DELETE /api/notes/:id { "creatorSecret" } → 200 { "state": "deleted" }
The ciphertext is base64url, at most 16 KiB decoded; the request body at most 32 KiB. reveal returns and erases the ciphertext in one step, so the second attempt gets note_gone. A wrong token leaves the secret in place; the tenth deletes it. Secrets travel in the body, never in the URL. See Poof Secretz.
Variants are written lifetime-people, with -ai when the AI model is included: 3600-4, 86400-10-ai. The whole flow is on the Payments page.
AI model
All three calls carry the room id and the room's AI token, which the browser derives from the quant-room key. /api/ai/chat accepts only hex ciphertext, forces the model and its settings, and streams the encrypted answer back untouched. See The AI model.
The WebSocket
Connect to wss://api.usepoof.chat/ws/rooms/:id?peerId=<22 characters>. The peer id is random per session and stays the same across reconnects. Messages are JSON text of at most 32 KiB, each carrying "v": 1. A plain ping every 20 seconds gets a pong; no answer within 8 seconds means the socket is dead. The second malformed message closes it.
Browser → server
Meaning
signal
An offer, answer or ICE candidate for one member (to), at most 16 KiB, 200 per pairing
claim
The creator proves who they are, with the creator secret
ban
Creator: remove one member for good
destroy
Creator: end the room for everyone
leave
Leave on purpose
Server → browser
Meaning
welcome
You're in: room facts, server time, members, limits
paired
Connect to this member: your role and the relay credentials
signal
Connection details, with from stamped by the server
simpleOld conversations stay safe even if a key leaks later.
technicalSession keys are ephemeral and not derivable from long-term keys.
for poofEach Poof quant-room uses fresh keys that disappear with the quant-room.
URL fragment
simpleThe part of a link after #.
technicalNot sent to the server in HTTP requests.
for poofWhere Poof keeps the classical quant-room key.
WebRTC
simpleBrowser technology for direct connections.
technicalPeer-to-peer media and data channels with DTLS encryption.
for poofHow messages travel between browsers without Poof's servers.
TURN relay
simpleA fallback server that forwards traffic when a direct link fails.
technicalRelays packets; sees only encrypted payloads.
for poofLets quant-rooms work behind strict networks.
HKDF
simpleA recipe for mixing secrets into a key.
technicalHMAC-based key derivation function (RFC 5869).
for poofCombines the classical and post-quantum secrets.
AES-GCM
simpleFast, standard encryption that also detects tampering.
technicalAuthenticated encryption with associated data.
for poofEncrypts every message in a quant-room.
Quant-room
simpleA temporary, private chatroom in Poof.
technicalA short-lived room on Poof's server that introduces browsers, plus end-to-end encrypted links between them.
for poofA Quant-Room lasts 10 minutes; a Super Quant-Room 1 hour or 24 hours.
Signaling
simpleIntroducing two browsers so they can connect.
technicalExchanging WebRTC offers, answers and ICE candidates through a server.
for poofPoof's server passes them along and stores nothing. Chat never goes this way.
DataChannel
simpleA direct pipe between two browsers.
technicalA WebRTC channel for any data, protected by DTLS.
for poofPoof opens two per pair, one for chat and one for files, each carrying its own encrypted frames.
Nonce
simpleA number used once.
technicalA per-message value that must never repeat under the same key.
for poofPoof builds it from a counter, so it never repeats and a missing message is noticed.
Key confirmation
simpleProving both sides got the same key, without showing it.
technicalEach side sends a MAC over the handshake transcript, under a key derived from the result.
for poofA failed check refuses the connection; it's never quietly downgraded.
Safety code
simpleA short code two people compare to rule out someone in the middle.
technicalA short authentication string derived from the session's keys.
for poofThe engine derives it; the quant-room doesn't show it yet.
PBKDF2
simpleA deliberately slow way to turn a password into a key.
technicalPassword-based key derivation with many rounds of HMAC.
for poofTurns four words into a mailbox address and a lock key, over 200,000 rounds.
Blind signature
simpleSigning something without seeing it.
technicalRSA blind signatures (RFC 9474): the signer signs a blinded message that only the requester can unblind.
for poofLets Poof sign a one-time pass without linking it to your payment.
One-time pass
simpleA ticket that works once.
technicalA blind-signed message, spent once and remembered only as a fingerprint.
for poofWhat a payment turns into, and what opens a Super Quant-Room.
Hardware enclave
simpleA sealed area inside a processor that even the machine's owner can't look into.
technicalA trusted execution environment, here Intel TDX, whose memory the hardware encrypts.
for poofWhere the AI model reads and answers.
Attestation
simpleA signed proof of what a machine is.
technicalA hardware-signed report that binds keys and fresh data to an enclave.
for poofYour browser checks one before it asks the AI anything.
Reproducible build
simpleThe same source always produces the same file.
technicalA deterministic build whose output can be hashed and compared by anyone.
for poofLets you match the live engine and API to the public code.
Poof Secretz
simpleA message that can be read once, then it's gone.
technicalAES-256-GCM ciphertext made in the browser; the server hands it over once and erases it in the same step.
for poofWritten at usepoof.chat/secretz/. The key lives only in the link, after #.
Reveal token
simpleProof that you hold a note's key, without showing the key.
technicalA value derived with HKDF from the link key (and the password); the server stores only its SHA-256.
for poofWithout it nobody can use a note up, and a wrong password doesn't erase it.
Reference
Questions.
41 short answers. Most link to a page with the full story.
What is Poof?
A private chatroom in your browser that doesn't ask who you are and disappears when the timer ends.
Why is it called Poof?
Because that's what the quant-room does at the end.
What does ephemeral mean?
Temporary by design. Quant-rooms have a fixed lifetime and nothing about the conversation is kept after it.
Do I need an account?
No. No email, no phone number, no username. Ever.
What is Poof Secretz?
A one-time message. You write it at usepoof.chat/secretz/, your browser encrypts it, and you send the link. It opens once, then it's gone from the server. See Poof Secretz.
Can someone else read my secret first?
Yes, if they get the link before your reader does: whoever opens it first reads it. Add a password and send it another way than the link. The reader can always copy or screenshot what they read. See Poof Secretz.
How long does a quant-room last?
A Quant-Room lasts 10 minutes. A Super Quant-Room lasts 1 hour or 24 hours.
How many people can join?
Two in a Quant-Room, up to ten in a Super Quant-Room, or just you with the AI model. The server holds the door, so nobody squeezes in once it's full.
How do I invite someone?
Send the link privately, show the QR code, or press Show a phrase and read out the four words. See How a quant-room works.
Is the four-word phrase secure?
For what it's for, yes: it works once and disappears after 3 minutes, and every guess costs 200,000 rounds of PBKDF2. Don't reuse it as a password.
What happens if I reload the page?
You go straight back into the quant-room. In a room for two, the other person's screen keeps the conversation for 30 seconds while you return.
What happens when the other person leaves?
The conversation is wiped from your screen at once. In a group, the room goes on without them.
What happens when the timer ends?
The connection closes and Poof's server deletes everything it held about the room. What's on your screen stays readable until you leave the page, then it's gone.
Can I end a quant-room early?
The person who created it can press Poof it now. It ends for everyone, and the server deletes it at once.
Can the creator remove someone?
Yes. That person is disconnected and can't come back into that room. The creator can also pin one message for everyone.
Can I send files?
In a Super Quant-Room, up to 2 MB per file. Files go browser to browser, encrypted piece by piece, and are checked on arrival. See Super Quant-Rooms.
Can Poof read my messages?
No. The key stays in your browser and Poof's servers never have it. Messages travel directly between browsers, already encrypted.
What does Poof's server know?
That a quant-room exists, how many seats it has, when it ends, and which IP addresses are connected while they are. Not what was said. See Data lifecycle.
Not on its own. It never asks who you are, but networks can still see your IP address. Use Tor or a VPN if you need to hide that.
What's the difference between privacy and security?
Privacy is about who can learn things about you. Security is about whether data can be read or changed without permission. See Philosophy.
How do I pay for a Super Quant-Room?
From a wallet, in USDC on Ethereum, Base or Solana, or USDG on Robinhood Chain. No account. See Payments.
Can Poof link my payment to my quant-room?
No. Blind signatures give you a one-time pass Poof has signed but never seen, so it can't tell which payment a room came from. The payment itself is public on the blockchain, like any transfer.
Where does the money go?
To Poof's treasury, 0x68222E6dC73e161045233B2b76a47d98F84A7e8C. Once POOF is listed, the whole amount buys back POOF and burns it.
Can I talk to an AI in a quant-room?
Yes, in a Super Quant-Room: add the uncensored AI model when you create it (+$2 for 1 hour, +$5 for 24 hours). Talk to it alone, or start a message with @ai in a group. See The AI model.
Who can read what I ask the AI?
Only the model. It runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave, and Poof's servers only pass the encrypted text along. To answer, the model reads the question and the recent conversation sent with it.
Is there mining or AI training?
No. Poof doesn't store conversations, and the AI model keeps no logs and no memory, so there's nothing to train on.
What is post-quantum cryptography?
Encryption designed to resist future quantum computers, running on today's devices.
No machine is publicly known to be able to break today's key exchanges at real-world sizes.
What is Shor's algorithm?
A quantum algorithm that would break RSA and elliptic-curve key exchange on a large, error-corrected quantum computer.
What is ML-KEM?
The NIST-standard (FIPS 203) post-quantum way to agree on a key. Poof uses ML-KEM-768.
What is a KEM?
A key encapsulation mechanism: one side locks a random secret with the other side's public key.
Why hybrid instead of only post-quantum?
So an attacker has to break both a classical and a post-quantum secret. Neither alone is enough.
Can a hacked device still leak messages?
Yes. Encryption protects messages on the way, not on a compromised screen.
What if Poof's server is hacked?
It never has the keys or the messages. It could try to serve altered code, which is why the engine that holds your keys is open, signed and checkable. See Verify it yourself.
What if the relay (TURN) is compromised?
It only ever sees encrypted traffic and IP addresses.
One fox, one checkerboard, one orange. Everything here exists to keep Poof recognizable wherever it shows up: on the site, in a post, in a quant-room.
Writing about Poof or making something for the community? Use this page for the rules and the Brand kit for the files.
Essence
Poof is a private chatroom that forgets. You open a quant-room, talk, and when the timer runs out, it is gone. The brand carries that idea: things appear, do their job, and disappear.
Line
Where it goes
Talk freely. Then poof.
The main line. Closings, covers, the end of the site.
Private by default. Temporary by design.
The descriptor. Page titles, bios, share images.
Nothing is kept.
The short promise. Captions, small spaces.
The personality is calm, direct and a little dry. Poof never shouts, never scares people into privacy and never pretends to be more than it is.
Voice
Short sentences. Plain words. Present tense. Say what Poof does, and just as clearly what it doesn't.
write
No account. No email. No phone.
The quant-room closes in 10 minutes. Then nothing is left.
Poof can't stop someone taking a screenshot.
avoid
Unhackable, 100% secure, military-grade.
Dates for when quantum computers arrive.
Fear, urgency, or long technical words where a short one works.
Logo
The logo has two parts. The mark is a 4×4 checkerboard with the top-left cell empty, always in rust. The wordmark is "Poof" drawn from Chakra Petch SemiBold, with three pixel details: a flag on the P, a drip under the f, and two o's that are eyes looking up and to the right.
On dark
cream wordmark · rust mark
On light
ink wordmark · rust mark
Clear space. Keep at least one mark cell (a quarter of the logo's height) free on every side. Minimum size. 18 px tall on screen for the full logo, 16 px for the mark alone.
The dashed line is the clear space: one mark cell around the logo.
Don't change the logo. These are all wrong:
Stretched
Recolored
Rotated
POOF
Typed in a font
Effects and glows
Low contrast
Color
Rust is the only loud color. Everything else stays quiet so it can do its job. Click a color to copy its hex code.
Frost only appears next to quantum and future topics. No violet, cyan or neon, anywhere.
Typography
Geist
Talk freely. Then poof.
headlines and body · SemiBold for headlines, tight tracking
Geist Mono
quant-room k7q2 · closes in 09:59
labels, system details, crypto · never for long text
Chakra Petch lives only inside the logo. Never use it for text, and never type "Poof" in any font as a logo.
The fox
Poof has one mascot: the fox. It is the same character everywhere, in new poses and moods but never redesigned.
Proportions. Upright on two legs, stocky, broad torso, short legs, a slightly oversized head.
Face. No beard or facial hair. Expressive, a bit rugged, charming.
Look. 3D, rendered with an ordered dither, sometimes as ASCII. Only brand colors.
Roles. The Host (idle), the Sleeper (dozing, for anything expired), the Keeper (presenting), the Watcher (gazing up), the Worker (busy), the Skeptic (shrugging, for limits), plus a raised paw for success and a wave for hello.
don't
Add other mascots, change the species or proportions, give it a beard, or recolor it outside the palette.
Emoji
Poof has its own animated emoji for Telegram: the mark, four coins in the brand colors, a poof, and the fox in four moods. They follow the same rules as everything else: brand colors only, pixel edges, quick and quiet motion.
Use them in the Poof community and anywhere you talk about Poof.
Don't recolor them, stretch them or draw new versions of the fox from them.
Things appear and disappear through a dither, like a quant-room going poof. Movement is quick and quiet: no bounces, no spins, no confetti. When someone asks their device for reduced motion, Poof shows everything without animation.
Brand
Brand kit.
Every official Poof file, ready to use. Preview it here, download one file or take the whole kit.