WhisperDocs
SDKs & CLI

CLI & one-command setup

Wiring a project into a new identity system usually means an SDK, a bespoke config file, and an afternoon of docs - whisper collapses all of it into one binary and one line.

whisper init claude, and your project has a real, routable, DNSSEC-anchored identity before you've finished reading this sentence.

The pain this removes

Every coding agent, every automation runner, every CI job that needs a network identity has historically faced the same bad menu: install a Python package with native deps for one stack, an npm package for another, hand-roll a WireGuard config for a third, and hope the proxy environment variables you set actually get inherited by the child process. None of that is hard, exactly - it's just friction, repeated once per tool, per language, per environment. And friction is where identity systems die: an agent that's "supposed to" carry its address ends up talking out from whatever IP the host happened to have, and the whole point of a verifiable identity - that the network layer is the proof - quietly evaporates.

The whisper CLI is the fix: one MIT-licensed, cross-platform Go binary that does registration, connection, and verification without asking you to touch a config file, and a whisper init <tool> family that wires that identity into the specific tool you're already using - Claude Code, Gemini, aider, Zed, browser-use, and seven more - with zero manual setup. It is also, deliberately, not the only way in: everything it does is one HTTP call or one dig away (see the mappings below), so nothing about it is a black box.

Install

curl -fsSL https://get.whisper.online | sh      # reads before it runs; one binary, no daemon required

Prefer a package manager? The same signed binary ships on all of them - pick the one your platform already trusts:

brew install whisper-sec/tap/whisper                                  # Homebrew (macOS/Linux)
scoop bucket add whisper https://github.com/whisper-sec/scoop-bucket && scoop install whisper  # Windows
go install github.com/whisper-sec/whisper-cli/cmd/whisper@latest      # straight from source
mise use -g "github:whisper-sec/whisper-cli[exe=whisper]"             # mise
sudo apt install whisper   # after adding get.whisper.online/deb - see /docs/integrations

Source, issues, and the release signatures live at github.com/whisper-sec/whisper-cli. Every artifact is signed - whisper --version prints just the version number, so verify with the detached signature published beside each binary. Check the key's fingerprint against the pin before you trust it:

curl -fsSL -o whisper-pgp.asc https://get.whisper.online/dl/whisper-pgp.asc
gpg --show-keys whisper-pgp.asc    # must show EFF1663D992539682106A5EAD0F70908CF3B7929
curl -fsSL -o whisper.asc https://get.whisper.online/dl/linux-amd64/whisper.asc
gpg --import whisper-pgp.asc && gpg --verify whisper.asc "$(command -v whisper)"
# Primary key fingerprint: EFF1 663D 9925 3968 2106  A5EA D0F7 0908 CF3B 7929

What the installer verifies

The install script (and install.ps1 on Windows) always checks the binary against the sha256 published beside it, and a mismatch stops the install. Whether it also checks the signature decides which of two guarantees you get:

The public key is fetched from as219419.net, or from /dl/whisper-pgp.asc if that is unreachable, and either copy is used only if its fingerprint matches the pin, so the host serving the binary cannot also vouch for it. Replacing the pin with WHISPER_PGP_FPR is refused unless WHISPER_INSTALL_UNSAFE_KEY=1 is set too, and then every run warns that the key is not ours. A key rotation changes the pin and the published key in the same release; an older script then says the key is not its pin and stops at the sha256 level.

Sign in

whisper login                 # opens the console in a browser, drops a scoped key in your keychain
whisper login whisper_live_...   # or paste one directly (CI, containers, no browser)

A key is only needed for the control-plane half. Everything under whisper verify works with no login at all - that's the keyless tier, by design (see Verify an agent).

The commands, and what each one actually calls

Nothing the CLI does is proprietary to the CLI. Every command is a thin wrapper over either a public DNS/HTTP check or the one control-plane verb, whisper.agents. Here's the mapping, so you can reimplement any of it yourself or debug it when something looks wrong:

Command What it does Underlying call
whisper login store a scoped API key none - local only
whisper create --name my-agent claim the caller's own /128 identity (one key, one identity - create reuses it if the key already has one) CALL whisper.agents({op:'identity', args:{label:'my-agent'}})
whisper create --register --name my-agent mint a brand-new agent with its own key: address, forward name, PTR, DANE pin CALL whisper.agents({op:'register', args:{label:'my-agent'}})
whisper list your agents, their addresses and status CALL whisper.agents({op:'list', args:{kind:'agents'}})
whisper connect --agent my-agent [--tier auto\|wireguard\|socks5] bring up egress sourced from the agent's /128 - auto (the default) tries Tier-1 WireGuard first and falls back to Tier-1.5 SOCKS5 on any failure; an explicit tier is forced, no downgrade CALL whisper.agents({op:'connect', args:{agent:'my-agent', tier:'wireguard'}})
whisper run -- <cmd> connect (if needed), verify egress, exec <cmd> under it connect, then the keyless echo check, then execve
whisper ip --agent my-agent prove the current egress source address curl through the proxy to https://rdap.whisper.online/egress-ip
whisper verify <addr> keyless identity check GET https://rdap.whisper.online/verify-identity/<addr>
whisper verify --trustless <addr> the same check, re-derived locally from the DNSSEC root - Whisper's own API is never trusted local DNSSEC chain-of-trust validation, see Trustless verification
whisper kill --revoke my-agent tear down address, DNS, DANE pin, and egress in one step CALL whisper.agents({op:'revoke', args:{agent:'my-agent'}})
›

Every one of the right-hand-column calls is documented on its own in Control plane and Connect & egress. The CLI adds nothing to the protocol - it only removes the typing.

The same thing, with stock tools only

The table isn't aspirational - every call really is one curl or one dig. Provisioning an agent and proving an identity, with no Whisper software installed anywhere:

# mint a brand-new agent - POST the one control-plane verb; the key travels in the header, never the body
curl -s https://graph.whisper.online/api/query \
  -H "X-API-Key: whisper_live_..." -H "content-type: application/json" \
  -d '{"query":"CALL whisper.agents({op:'"'"'register'"'"', args:{label:'"'"'my-agent'"'"'}})"}' | jq .

# verify any agent's identity - keyless, no header at all
curl -s https://rdap.whisper.online/verify-identity/2a04:2a01:eb5a:ca74:cef2:2a:323d:40d4 | jq .

The CLI equivalents - whisper create --register --name my-agent and whisper verify 2a04:2a01:eb5a:ca74:cef2:2a:323d:40d4 - send the same bytes to the same endpoints. (--label still works as a legacy alias for --name, but --name is the documented spelling; and dropping --register sends op:identity instead - claiming the caller's own /128 on the key already in hand rather than minting a new one.) Nothing is hidden behind the binary; it only saves the typing. Full request and response shapes: Control plane.

whisper run - what actually changes in the child process

whisper run -- python agent.py does exactly three things, in order, and fails loudly rather than falling back silently if any of them don't hold:

  1. Connects, if the named (or default) agent isn't already connected, negotiating exactly as whisper connect does: Tier-1 WireGuard first (whisper.agents({op:'connect', tier:'wireguard'})), then Tier-1.5 SOCKS5 (tier:'socks5') if that is refused. Both run in userspace, so neither needs root or a kernel interface. --tier wireguard or --tier socks5 forces one, with no downgrade.
  2. Verifies the egress before handing off control: it fetches https://rdap.whisper.online/egress-ip through the new proxy and checks the answer equals the agent's own /128 - the same check whisper ip exposes standalone. A mismatch is a hard error, never a quiet fallback to your host's own address.
  3. Execs your command with ALL_PROXY and HTTPS_PROXY pointed at a local loopback SOCKS5 endpoint the CLI holds open for the life of the command - source-bound to the agent's /128, so no egress credential ever lands in the child's environment. On the WireGuard tier that endpoint is the front of the userspace tunnel, so the variables are the same on both tiers, and on both they carry TCP:
whisper run -- python my_agent.py
# child process env now includes:
#   ALL_PROXY=socks5h://127.0.0.1:1080
#   HTTPS_PROXY=socks5h://127.0.0.1:1080

Because ALL_PROXY/HTTPS_PROXY are a decades-old Unix convention, this needs no cooperation from your code: curl, git, Python requests/httpx, Node's fetch, and Claude Code's own tool-use network layer all already honor them. There is no SDK to import.

What the proxy does not carry is UDP, so a program's own DNS lookups, NTP and QUIC leave from the host's own address, and so does a program that ignores the variables and dials an address directly. That holds on both tiers, because the WireGuard tier's tunnel sits behind the same proxy. On Linux, sudo whisper run --enforce carries everything: the command runs in its own network namespace whose only way out is a WireGuard tunnel from its /128, so a program that dials directly still leaves from that /128, or is refused.

On Windows, whisper run --enforce from an elevated terminal runs the command without administrator rights, in a logon session of its own, and the Windows Filtering Platform lets that session reach exactly one thing: the local proxy, which leaves from the /128. A direct dial, on IPv4 or IPv6, by address or by name, is refused, and so is ICMP echo on the host while the command runs (Windows sends every ping as the system, so it cannot be refused for one program alone). If the CLI dies, the command dies with it. This is from a live run on Windows Server 2022:

Enforced as a9bc5ed83e85fc0af - 2a04:2a01:92bb:54a1:9bc5:ed83:e85f:c0af ✓ verified through the agent's only door, the local proxy; every other connection from the agent is refused, on IPv4 and IPv6
curl https://rdap.whisper.online/egress-ip            -> {"ip":"2a04:2a01:92bb:54a1:9bc5:ed83:e85f:c0af"}
curl --noproxy '*' https://1.1.1.1/                   -> curl exit 7
TcpClient.Connect("8.8.8.8", 443)                     -> forbidden by its access permissions
whisper ip                                            -> 2a04:2a01:92bb:54a1:9bc5:ed83:e85f:c0af ✓ egress verified (enforced)

curl.exe checks certificate revocation outside the proxy, so inside an enforced command give it --ssl-no-revoke; tools with their own TLS (Node, Python, Go, Git) need nothing.

Which agent. --agent <name> names one, --create --name <name> makes one, and --name <name> on its own uses the agent of that name. Otherwise whisper run takes the project's .whisper/config, then this host's saved agent (~/.config/whisper/agent), then a whisper connect already running on this host, then the one agent whose published identity key is a key this host holds, so a host that lost its saved agent file but kept its key gets its own agent back. With none of those it creates an agent named after this host, says so, and saves it for the next run; on the WireGuard tier the new agent publishes this host's identity key from its first connect. It never picks one of your account's other agents for you: on the WireGuard tier that would replace the tunnel another host holds for it. A .whisper/config your own whisper init did not write, such as one that came with a cloned repository, still picks its agent but runs it on socks5; to run it routed, pass --agent <name> --tier wireguard, or answer yes at the terminal, which is remembered. Bare whisper in a script uses your one agent only when this host saved it or it is the key's own. whisper connect follows the same order, except that it asks for --name before it creates, and sudo whisper run --enforce never creates one unless you name it. On a host whose home does not survive between runs (a CI job, a container), pass --name <name> so every run reuses the one agent of that name.

Who can use the local proxy

The proxy listens on 127.0.0.1, which every local user can reach, so it checks who is asking before it answers. Before replying to the first byte, it asks the kernel which user owns the connecting socket, looked up by that socket's exact address and port. Your own user's processes are let straight in, as they always were. Any other local user's process, and any connection the kernel cannot attribute to a user, has to present the session's credential: RFC 1929 username and password on SOCKS5, Proxy-Authorization: Basic on HTTP CONNECT. Each session gets a fresh credential, kept owner-only (mode 0600, or an owner-only ACL on Windows) in a .cred file beside the session record. It is never printed, logged, or put on a command line. Captured on a lab host, with one user holding the session and a second local user trying it:

$ whisper connect --agent 2a04:2a01:95c1:6c36:3776:186:794f:a43a --port 18322
Connected as a37760186794fa43a - 2a04:2a01:95c1:6c36:3776:186:794f:a43a ✓ verified via Tier-1 wireguard (routed /128) socks5h://127.0.0.1:18322

# the same user, SOCKS5 and HTTP CONNECT
$ curl -x socks5h://127.0.0.1:18322 https://rdap.whisper.online/egress-ip
{"ip":"2a04:2a01:95c1:6c36:3776:186:794f:a43a"}
$ curl -x http://127.0.0.1:18322 https://rdap.whisper.online/egress-ip
{"ip":"2a04:2a01:95c1:6c36:3776:186:794f:a43a"}

# another local user
$ curl -x socks5h://127.0.0.1:18322 https://rdap.whisper.online/egress-ip
curl: (97) No authentication method was acceptable.
$ curl -x http://127.0.0.1:18322 -v https://rdap.whisper.online/egress-ip 2>&1 | grep '^< '
< HTTP/1.1 407 Proxy Authentication Required
< Proxy-Authenticate: Basic realm="whisper", charset="UTF-8"
< Content-Type: text/plain; charset=utf-8
< Content-Length: 235
< Connection: close
< 

The session that refused it logs one line a minute per refused user, naming the fix: whisper: refused a process of another local user on 127.0.0.1:18322 (SOCKS5 without a username and password); this session is not shared with it. To use it, run as the user holding it, present its credential (the .cred file beside its session record), or have it shared with you: `sudo whisper service install --share-user <you>`. whisper connect --share credential asks everyone for the credential, your own user included, and --share any lets every local user in, which is how the proxy behaved before this check. A process running as your own user is trusted, and that includes a --network=host container running as your uid. Use --share credential where that matters.

Root and the system service. A proxy held by root (sudo whisper connect, or whisper service install as a system service) does not trust every root process: a default docker run --network=host container is root too. It lets in its own process and the users on its share list. sudo whisper connect shares with the user who ran sudo. sudo whisper service install records the user who ran sudo (on Windows, the installing account) in the service's config, --share-user <name> names others, and --no-share empties the list. A user who is not on the list gets a clear refusal instead of a second session, because a second session would replace the first one's tunnel. From whisper ip, run by such a user against a root-held session on the same lab host: whisper: a Whisper session for 2a04:2a01:95c1:6c36:3776:186:794f:a43a is live on 127.0.0.1:18324, but it is held by another user and is not shared with you. Ask its owner to add you (`sudo whisper service install --share-user <you>`), or run whisper as that user. A new session would replace that one's tunnel, so none was opened. The users on the list reuse it as their own: on the same host, the user who ran sudo got 2a04:2a01:95c1:6c36:3776:186:794f:a43a ✓ egress verified from whisper ip through it.

Upgrading a service installed before share lists. On its first start under the new release, the service shares with the account its install already records: the owner of the config it runs (a project install), or failing that the owner of the home it was installed with. It logs that once, and whisper service status shows it as adopted. Captured on a fresh lab guest: a project service installed by user alice with v0.249.0, then the binary replaced and the service restarted. alice keeps working, and another login user does not:

$ whisper service status
whisper-connect (linux-systemd): running
  serving: socks5h://127.0.0.1:21643
  egress:  2a04:2a01:c066:c0c3:f0f9:1cff:6edf:da2d
  use it:  export ALL_PROXY=socks5h://127.0.0.1:21643
  shared:  alice (adopted on upgrade from the owner of its config /home/alice/proj/.whisper/config; `sudo whisper service install` records it)

sudo whisper service install writes the list into the config, hands the config back to its owner, and restarts the service: shared: alice (other local users need the session credential).

A host install (sudo whisper service install --agent ...) keeps its config in /etc/whisper/connect.json, which is root's, and its home is /root, so it records nobody to adopt. After the upgrade it shares with nobody and says so. Its log line is whisper: this service's config has no share list and records no account that installed it, so its local forwarder admits no login user without the session credential. Re-run `sudo whisper service install` from the account that uses this connection (that records it), or add `--share-user <name>`. Status, from the same guest:

$ whisper service status
whisper-connect (linux-systemd): running
  serving: socks5h://127.0.0.1:1080
  egress:  2a04:2a01:c066:c0c3:f0f9:1cff:6edf:da2d
  use it:  export ALL_PROXY=socks5h://127.0.0.1:1080
  shared:  with no login user (this install predates share lists and records no installing account); run `sudo whisper service install` from the account that uses it
$ sudo whisper service install
installed and restarted whisper-connect (linux-systemd) - the unit or its share list changed, so the running process was replaced
  config:  /etc/whisper/connect.json
  shared:  alice (other local users need the session credential)
$ curl -x socks5h://127.0.0.1:1080 https://rdap.whisper.online/egress-ip
{"ip":"2a04:2a01:c066:c0c3:f0f9:1cff:6edf:da2d"}

Which binary a system service runs. A system service runs as root, so it only runs a whisper that root alone can change. A package install, or the installer run with sudo, already puts it there, and the service runs it in place. After the user install (curl -fsSL https://get.whisper.online | sh, into ~/.local/bin), sudo ~/.local/bin/whisper service install copies the binary to a root-owned location, checks the copy, and points the service at it. A root service running a file in the user's home would let that user replace what root runs, and on SELinux hosts systemd refuses to start it at all (status=203/EXEC). Captured on a fresh Rocky 9 guest with SELinux enforcing:

$ sudo ~/.local/bin/whisper service install --now --agent ...
installed and started whisper-connect (linux-systemd)
  config:  /etc/whisper/connect.json
  binary:  /usr/local/libexec/whisper/whisper (a root-owned copy of /home/alice/.local/bin/whisper, which a root service may not run from there; after upgrading whisper, run this install again)

After upgrading the whisper in ~/.local/bin, run the same install again. It refreshes the copy and restarts the service onto it: installed and restarted whisper-connect (linux-systemd) - the binary it runs changed, so the running process was replaced. whisper service status names the binary on its binary: line, and whisper service uninstall removes the copy along with the last unit that runs it. If the copy cannot be made, the install stops and says how to install system-wide, instead of writing a unit that cannot start.

--now means up, not started. whisper service install --now waits, for up to a minute, until the unit stays running and its proxy answers. If it does not, the install exits non-zero, says so, and prints the unit's own last log lines. A definitive refusal is reported within seconds. From the same guest, installing with an agent that had been revoked, after 5 seconds: whisper: installed, but whisper-connect did not come up: it is running but its session was refused: agent '...' not found. The service then holds that refusal (whisper service status shows tunnel: refused with the reason) and asks again every five minutes, so it never crash-loops. A transient fault, such as the control plane being unreachable, is shown as tunnel: down and retried every 30 seconds; on the same guest the service was serving again 16 seconds after the control plane came back, with no restart. The release before this printed installed and started over a unit that could not run at all. An explicit --agent is always the identity the service runs. On a host install it replaces the agent the existing config names, and the install says which one it replaced (agent: ... (the config named ...; --agent replaced it)). A project's own config is never rewritten: if it names a different agent, the install refuses and names both.

whisper init <tool> - wiring an identity into what you already run

whisper connect and whisper run are generic; whisper init <tool> goes one step further and speaks each target's own configuration surface, so the identity is there before the tool's first network call - no wrapper script, no env var to remember:

whisper init claude          # writes the proxy/network entry into ./.claude/settings.local.json
whisper init gemini          # same egress, Gemini CLI's own config surface
whisper init aider           # aider's local config, same proxy underneath
whisper init zed             # Zed's context-server settings
whisper init browser-use     # a browser-context proxy config for headless/agentic browsing

Twelve targets ship today - claude, python, zed, gemini, aider, ai-sdk, browser-use, discord, telegram, notebook, compose, k8s - each writing into that tool's native format rather than a Whisper-specific one. Run it with no argument and it detects the project (a .claude/ directory, a pyproject.toml, a docker-compose.yml) and picks the right target itself. Every target is provisioned against the same control-plane register + connect pair above; init only differs in where it writes the result. Before starting the target process, init confirms the local egress endpoint is already listening - so the tool's very first outbound call never races an unready proxy.

whisper init claude && claude    # the project now has an identity; Claude Code's traffic carries it

For everything that isn't a first-class init target - n8n, Zapier, Cloudflare Workers, Kubernetes - see the full connector catalog at Integrations; they use the same two calls, just via a platform-native connector instead of a CLI wrapper.

whisper whale ssh-authz - letting your fleet log in with its own keys

An agent's identity key is already an SSH key, and its fingerprint is already published as the agent's SSHFP record, DNSSEC-signed. So a node of your fleet needs no authorized_keys entry for another one. Run this once, as root, on the node that should take the logins:

sudo whisper whale ssh-authz install --write   # writes the sshd drop-in and checks it with sshd -t
sudo systemctl reload ssh                      # macOS: sudo launchctl kickstart -k system/com.openssh.sshd

Without --write it only prints what it would write, so you can read it or place it yourself. Every hosted agent sits in its own tenant (the t... label in its name), so your fleet is the set of tenants your agents are in. install reads that set from your roster with this host's key, the same list whisper whale status shows, and writes it to /etc/ssh/whisper-ssh-authz.fleets (root-owned, readable only by root and the account sshd runs the check as). It then writes two lines to /etc/ssh/sshd_config.d/50-whisper-ssh-authz.conf:

AuthorizedKeysCommand /usr/local/bin/whisper whale ssh-authz check --fleet-file /etc/ssh/whisper-ssh-authz.fleets -- %u %t %k %C
AuthorizedKeysCommandUser nobody

After you add an agent, run sudo whisper whale ssh-authz install --write again. It rewrites the list, and sshd reads it at the next login with no reload. If your roster cannot be read, a refresh leaves the list as it was. --fleet (repeatable: a tenant, a zone or a node name) names the fleets yourself, inline, instead of the roster. With no key on the host and no --fleet, only this node's own tenant is admitted, and install says so.

From then on sshd asks ssh-authz check about any key it does not already know, and gets the key line back only when all of this is proven from the IANA root, in that process, with no resolver's AD bit trusted:

  1. the address the connection came from has a validated PTR to a name directly inside one of your fleet's tenants, and that name's validated AAAA points back at it (through whisper connect --accept, the address is the caller's real /128, recovered with whale caller);
  2. the name's whisper-id1 TXT says status=active and names the tenant that name sits in, so a revoked agent stops logging in;
  3. the offered key matches the name's SSHFP type 2. Its TLSA 3 1 1 pin counts only with --allow-tlsa, because that pin names the key of the TLS service, and whoever terminates that service would then be able to log in too.

Anything less prints nothing, and sshd answers "Permission denied": an unsigned answer, a wildcard-synthesised one, a lookup still unanswered after 15 seconds, a key that does not match. sshd reads authorized_keys before it runs the command, so keys you added by hand keep working. root, or any account with uid 0, is never admitted unless the snippet names it with --user; --user limits the accounts, and --allow limits the agents. Every decision is one line in the auth log, and --from <address> asks the same question as a dry run that never prints a key. A caller outside the agent block is refused before any lookup at all:

$ whisper whale ssh-authz check --fleet t{your-tenant-hash} --from 2001:db8:aa::e1 -- you ecdsa-sha2-nistp256 AAAAE2VjZHNh...
DENY user=you from=2001:db8:aa::e1 source=dry-run key=SHA256:ON3u9PVTEbLFyNg+8QYWSasXlXX88if4nclwXLxb1xQ: 2001:db8:aa::e1 is outside 2a04:2a01::/32, where every hosted agent lives, so it is not a fleet member

One document for east-west and SSH

When your fleet's WhaleACL has an ssh block, the same document that decides who may reach what also decides who may log in where. A rule names a source, a node and the accounts:

"ssh": [
  {"action": "accept", "src": ["tag:ops"], "dst": ["tag:db"], "users": ["root"]},
]

whisper whale acl test tag:ops tag:db:22 --user root answers from the compiled view before anything is installed, and whale acl show says ssh enforced per node, after whisper whale ssh-authz install --write on each target. On the target, install --write fetches that node's view and writes it beside the fleets file, as /etc/ssh/whisper-ssh-authz.acl, and says what changed:

$ sudo whisper whale ssh-authz install --write --user root
  ssh ACL: flags-only -> governed by the WhaleACL, 1 source(s) may log in here
wrote /etc/ssh/whisper-ssh-authz.acl

A login then has to pass everything above and an admit line in that file, which names the caller's /128, its proven name and the account. The two halves are intersected, so adding a document can only narrow who gets in, and root still needs --user root in the snippet. Once a fleet has an ssh block it governs every node, so a node no rule names as a dst admits no fleet login, and install warns you before it writes a view like that. These captures come from a live run between two lab guests, with the names and addresses replaced by neutral ones:

ADMIT user=root from=2a04:2a01:9::e1 source=accept agent=ops-01.fleet.example key=SHA256:NJvKmiY1WTbF5nLhi21DGVBGz6d2hB2WCF7YEhHFYxg proof=sshfp: the key matched SSHFP 3 2 349bca9a... (ecdsa, sha256) for ops-01.fleet.example, validated from the IANA root; an ACL ssh rule admits ops-01.fleet.example as root

The file changes only when you run install --write again, and a login never calls the control plane. So when you remove the rule, the node keeps admitting until its next refresh. After the refresh it denies, and the auth log names the half that refused:

$ sudo whisper whale ssh-authz install --write --user root
  ssh ACL: governed, 1 source(s) -> governed by the WhaleACL, 0 source(s) may log in here
  WARNING: this node's ssh view admits NOBODY. After this refresh every fleet login here is refused (keys in authorized_keys still work). If that is not what you meant, add an ssh rule that names this node as a dst
DENY user=root from=2a04:2a01:9::e1 source=accept: acl: no ssh rule admits 2a04:2a01:9::e1 as root

A fleet with no ssh block, or no document at all, keeps the flags-only behaviour: install reports flags-only: the fleet's WhaleACL has no ssh block, and --user and --allow decide on their own (DENY ... flags: "labops" is not one of the accounts fleet agents may log in as (root)).

Uninstalling, cleanly

whisper kill --revoke my-agent   # first: kill the identity - address, DNS, DANE pin, and status-list entry, provably
rm $(command -v whisper)  # then: remove the binary, no other state left behind

whisper keeps no daemon running between invocations and no local database beyond the key in your OS keychain - revoking an agent and deleting the binary leaves nothing behind on either side.

Next

Connect & egress - the three tiers whisper connect and whisper run choose between, and how source-binding actually works · Integrations - every non-CLI way to wire in the same identity, from MCP to Kubernetes.