The password slot holds a signature that expires in a minute

1 month ago

Every server you send code to asks for a password. These days that password is a long token in a file on your machine. Buzz asks a question instead, and your computer signs the answer. The key that makes that signature stays on your own computer, and a signature is a mark only that key could have made.

Ask

Ask about this presentation

Answers are generated from this presentation.

Chapters

  1. 0:00Buzz · a workspace you run yourself, where a key answers instead of a password
  2. 0:16Your chat and your repositories sit on the same server
  3. 0:29Everything you do is the same seven-line signed record
  4. 0:50The password slot holds a signature that expires in a minute
  5. 1:22The program that signs your saved changes looks for your Buzz key second
  6. 1:46An AI agent joins the workspace the same way a person does
  7. 1:57Open source under Apache 2.0, and still on a version that starts with zero
  8. 2:16One key: your name, your saved changes, and the code you send up
Show transcript

Buzz · a workspace you run yourself, where a key answers instead of a password

→ git push
← 401
WWW-Authenticate: Nostr realm="buzz", method="GET"
→ Authorization: Nostr <credential>
the server answers with a question

Buzz

a workspace you run yourself, where a key answers instead of a password
RustApache-2.0macOS, Linux, Windowsdesktop-v0.5.20
buzz-relay/src/api/git/transport.rs L96 · git-credential-nostr/src/lib.rs L6

Every server you send code to asks for a password. These days that password is a long token in a file on your machine. Buzz asks a question instead, and your computer signs the answer. The key that makes that signature stays on your own computer, and a signature is a mark only that key could have made.

Your chat and your repositories sit on the same server

rooms you run yourself
the same server serves /git/{owner}/{repo} over ordinary git
buzz-relay/src/api/git/transport.rs L1-8 · merged in router.rs L147

Buzz looks like a team chat app. The server is a small program you put on a machine you control, and it hands signed messages to whoever asked for them. That same server also holds your code, and one key gets you into the rooms and the repositories.

Everything you do is the same seven-line signed record

{
"id": "<sha256 of canonical serialization>",
"pubkey": "<secp256k1 public key, hex>",
"created_at": <unix seconds>,
"kind": <unsigned integer>,
"tags": [["e", "<event-id>"], ["p", "<pubkey>"], ...],
"content": "<JSON payload or plain text>",
"sig": "<Schnorr signature over id>"
}
{
"id": "<sha256 of canonical serialization>",
"pubkey": "<secp256k1 public key, hex>",
"created_at": <unix seconds>,
"kind": <unsigned integer>,
"tags": [["e", "<event-id>"], ["p", "<pubkey>"], ...],
"content": "<JSON payload or plain text>",
"sig": "<Schnorr signature over id>"
}
buzz-core/src/verification.rs L11-20

Your name here is the key itself. No account sits behind it. A message, a reaction, a change to a repository: each is one small record, signed. That record carries the public half of your key, the half anyone else uses to check the signature, the second it was made, what kind of thing it is, what it says, and a signature only your key could have made.

The password slot holds a signature that expires in a minute

→ git push
← 401
WWW-Authenticate: Nostr realm="buzz", method="GET"
the server answers with a question
protocol=https
host=relay.example.com
path=git/owner/repo.git/info/refs
→
https://relay.example.com/git/owner/repo.git
your key signs that address, and the moment
capability[]=authtype
authtype=Nostr
credential=<credential>
ephemeral=true
→
→ Authorization: Nostr <credential>
git is told not to save it
https://relay.example.com/git/other/repo.git
✗
different repository
https://relay.example.com/git/owner/repo.git
✗
61 seconds later
it is worth nothing at another repository, and nothing a minute later
git-credential-nostr/src/lib.rs L200-206, L258-263 · buzz-auth/src/nip98.rs L32, L77-101 · git Documentation/git-credential.txt v2.46.0

Here is the clever part. The program that sends your code up is called git, and it has a slot where a password goes. Buzz puts its own program there. The server says prove it, and the program signs the address of that one repository with your key. The signature goes back where the password would have gone, and the program tells git not to save it. You would assume that killing the password moves the secret somewhere else, into a file or a keychain. It never moves: your key stays on your own computer. What crossed the wire is a signature that fits that one repository, and about a minute later Buzz's server turns that signature down.

The program that signs your saved changes looks for your Buzz key second

1NOSTR_PRIVATE_KEY
2BUZZ_PRIVATE_KEY
3git config nostr.keyfile
1NOSTR_PRIVATE_KEY
2BUZZ_PRIVATE_KEY
3git config nostr.keyfile
then it removes the key from its own environment
ships in no download · you build it and point git at it once
git-sign-nostr/src/lib.rs L394, L411-412 · that crate’s README

Git can mark each change you save with who made it, and git hands that job to an outside program. The Buzz project wrote one of those programs. That program looks for a key in three places, in order. The middle one is your Buzz identity, so each saved change carries the same key that is your name in the chat. The program reads the key, then wipes the key out of its own settings. That program comes in no download. You build it yourself, and point git at it once.

An AI agent joins the workspace the same way a person does

its own key
its own rooms
its own trail
block/buzz README · buzz-relay/src/api/git/transport.rs L66-72

A member here is a key, so an AI agent, a program that goes off and does work for you, joins the same way you did. The agent gets its own key, its own rooms, and its own trail of what it did.

Open source under Apache 2.0, and still on a version that starts with zero

macOS (Apple silicon)
103.6 MB
macOS (Intel)
86.5 MB
Linux (.deb)
111.3 MB
Linux (AppImage)
169.5 MB
Windows
52.4 MB
in the app: git-credential-nostr is bundled, and the app sets credential.helper per run
at your own terminal: credential.helper · credential.useHttpPath · nostr.keyfile, and a key file at 0600
the Windows build ships unsignedgit 2.46 or newer
desktop-v0.5.20published 2026-08-26
releases/latest, re-pulled 2026-08-25 · tauri.conf.json L55-62 · project_git_exec.rs L175-180 · that crate’s README Setup

There is a download for macOS, for Linux, and for Windows. That download already carries the program that answers Buzz's server, and the app points git at that program for you. At your own terminal you point git at that program yourself, and keep your key in a file that program can read. The Windows build ships unsigned, so Windows will question it the first time you open it, and the git parts need a recent git.

One key: your name, your saved changes, and the code you send up

One key: your name, your saved changes, and the code you send up.

github.com/block/buzz
Apache-2.0 · desktop-v0.5.20
New repo tomorrow.

Every server you send code to asks for a password. This one asks a question instead, and the key that signs your answer never leaves your machine. That is block slash buzz, on GitHub. New repo tomorrow.