Install anywhere

The whisper CLI is the one binary that gives an agent a real, routable IPv6 identity — and it only earns that job if it's on every machine that runs one.

Your laptop, your teammate's Windows box, the CI runner, the Alpine container in prod, the NixOS build server. Package-manager sprawl is where good tools go to die: one more curl | sh that isn't pinned, one more stale download, one more platform onboarding forgets. Whisper ships as a single MIT-licensed, statically-linked Go binary — no runtime dependency, no phone-home — published to every channel a developer or CI pipeline reaches for first, each one signed, each one ending in the same check: whisper --version.

This page is the exhaustive list. Pick the channel that matches where the binary needs to live; skip the rest.

The fast path

curl -fsSL https://get.whisper.online | sh
whisper --version

get.whisper.online serves a plain, readable shell script — pipe it through less first if you want to read it before you run it, that's the point of Postel's Law applied to supply chain: we make it trivial to inspect, we never make you trust blindly.

curl -fsSL https://get.whisper.online -o install.sh   # read it
less install.sh
sh install.sh                                          # then run it

Every channel, at a glance

Every one of these builds from the same tagged release in whisper-sec/whisper-cli — there is no channel-specific fork of the binary, so whisper --version returns the identical build hash no matter how you got it.

Homebrew

macOS and Linux, our own tap (not homebrew-core, so no review lag on new releases):

brew install whisper-sec/tap/whisper
whisper --version

Without Whisper, this is the manual equivalent — download the darwin-arm64 asset and its checksum straight from GitHub Releases and verify by hand:

curl -fsSLO https://github.com/whisper-sec/whisper-cli/releases/latest/download/whisper-darwin-arm64
curl -fsSLO https://github.com/whisper-sec/whisper-cli/releases/latest/download/checksums.txt
grep whisper-darwin-arm64 checksums.txt | sha256sum -c -
chmod +x whisper-darwin-arm64 && ./whisper-darwin-arm64 --version

The Homebrew formula pins that same per-arch sha256 in the tap, so brew install does the sha256sum -c for you on every install — that's what a formula bump is.

Scoop

Windows, our own bucket:

scoop bucket add whisper https://github.com/whisper-sec/scoop-bucket
scoop install whisper
whisper --version

Without Whisper, PowerShell's own hash check against the published checksums.txt:

Invoke-WebRequest https://github.com/whisper-sec/whisper-cli/releases/latest/download/whisper-windows-amd64.exe -OutFile whisper.exe
Invoke-WebRequest https://github.com/whisper-sec/whisper-cli/releases/latest/download/checksums.txt -OutFile checksums.txt
Get-FileHash whisper.exe -Algorithm SHA256
Select-String whisper-windows-amd64.exe checksums.txt   # compare by eye, or script it

apt (Debian/Ubuntu)

A self-hosted repo on our own address space (AS219419), signed with a dedicated RSA-4096 key (fingerprint 7570D759316F7C1F) kept separate from the binary-release signing key:

curl -fsSL https://get.whisper.online/whisper.gpg | sudo tee /usr/share/keyrings/whisper.asc >/dev/null
echo "deb [signed-by=/usr/share/keyrings/whisper.asc] https://get.whisper.online/deb stable main" \
  | sudo tee /etc/apt/sources.list.d/whisper.list
sudo apt update && sudo apt install whisper
whisper --version

Verify the key yourself before you trust it (stock gpg, no Whisper software involved):

curl -fsSL https://get.whisper.online/whisper.gpg | gpg --show-keys --with-fingerprint --dry-run
# pub   rsa4096 ...  7570 D759 316F 7C1F ...

apt then does its normal Release/InRelease signature check against that key on every apt update — the same mechanism that protects every other repo on your system, nothing bespoke.

dnf (Fedora/RHEL)

sudo tee /etc/yum.repos.d/whisper.repo >/dev/null <<'EOF'
[whisper]
name=Whisper
baseurl=https://get.whisper.online/rpm
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://get.whisper.online/whisper.gpg
EOF
sudo dnf install whisper
whisper --version

dnf checks both the package signature and the repo metadata (repomd.xml.asc) against the same RSA key as apt — one key, two package formats.

apk (Alpine)

Alpine's APKINDEX format needs its own abuild-style RSA key (a different key from the apt/dnf one, by Alpine convention):

wget -qO /etc/apk/keys/whisper-apk.rsa.pub https://get.whisper.online/apk/whisper-apk.rsa.pub
echo "https://get.whisper.online/apk" | sudo tee -a /etc/apk/repositories
sudo apk add whisper
whisper --version

This is the one that matters most for the container-image case — a FROM alpine:3.20 build stage that needs whisper baked in without pulling in Go or curl-piping a script into a Dockerfile.

go install / mise

Straight from source, no binary trust decision at all beyond the Go module checksum database:

go install github.com/whisper-sec/whisper-cli/cmd/whisper@latest
whisper --version

mise use -g "github:whisper-sec/whisper-cli[exe=whisper]"
whisper --version

go install verifies the download against the checksum database at sum.golang.org automatically (GOSUMDB, unless you've explicitly opted out) — the module proxy's transparency log is doing the same job GPG does for the other channels, just built into the toolchain.

aqua

The aqua-registry entry resolves {{.Version}} against GitHub Releases, so once merged upstream a new tag needs no registry change:

aqua g -i whisper-sec/whisper-cli
aqua i
whisper --version

Nix

# flake.nix or shell.nix
{ inputs.whisper.url = "github:whisper-sec/whisper-cli"; }

nix build github:whisper-sec/whisper-cli
./result/bin/whisper --version

The buildGoModule derivation pins both the source hash and the Go vendorHash — Nix will refuse to build if either drifts from what's declared, which is a stronger guarantee than a checksum file you have to remember to check.

Snap

sudo snap install whisper-cli --classic
whisper --version

--classic confinement is required because whisper connect runs a local egress proxy — it binds a loopback socket and opens outbound connections on arbitrary ports — which strict confinement's network interfaces don't permit.

MacPorts

sudo port install whisper-cli
whisper --version

AUR

yay -S whisper-cli-bin          # or: paru, or a manual makepkg
whisper --version

The -bin package installs the prebuilt, signed release asset directly (no local Go toolchain needed); a source-build whisper-cli variant is the fallback for anyone who prefers to compile.

Docker / GHCR

docker run --rm ghcr.io/whisper-sec/whisper --version
docker run --rm -e WHISPER_API_KEY ghcr.io/whisper-sec/whisper agent create --name shipping-bot

Multi-arch (linux/amd64, linux/arm64) — the same image works on a laptop and on Graviton CI runners without a tag change.

CI: GitHub Actions

- uses: whisper-sec/setup-whisper@v1
  with:
    version: latest
- run: whisper --version

Add api-key: ${{ secrets.WHISPER_API_KEY }} to the same step to have it export WHISPER_API_KEY for the rest of the job — every job step after that can whisper agent create / whisper connect without touching a config file. Other CI systems get the same result with any channel above (apt/apk in a container step, go install in a build image).

Why every channel matters: the payoff is identical everywhere

Whichever way you installed it, the CLI does the same thing: prove an agent's identity against records anyone can already query with stock tools, just in one command instead of three.

These commands resolve against our live public demo agent, scout — copy-paste them as-is and they return real answers.

With stock tools — no whisper binary anywhere on the machine:

dig +short -x 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
# -> ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online.
kdig +dnssec TLSA _443._tcp.ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
# 3 1 1 9EC1EF18A1F15E54...201940F28C422BB47D — usage 3 (DANE-EE), selector 1 (SPKI), matching 1 (SHA-256)
openssl s_client -connect [2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478]:443 -servername ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online < /dev/null

With Whisper, once it's on your $PATH from any channel above:

whisper verify 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478 --trustless
# chains PTR -> AAAA -> DNSSEC (RRSIG to the root) -> TLSA (RFC 6698) -> the live cert; prints PASS/FAIL

That's the whole point of getting the binary onto every machine: the verification is public and reproducible with dig/kdig/openssl alone — installing whisper doesn't add trust, it removes friction.

Next

See CLI reference for the full command surface, or Every channel, every tier for how the two-tier (keyless-verify / key-gated control) model shows up in SDKs, MCP, and CI beyond the raw binary.