Whalenet mesh
A fleet mesh where every node is a routable IPv6 /128 with a name anyone can check from the IANA root - and where the tool tells you, per peer, whether the path it is drawing actually exists.
Whalenet is the fleet view of something Whisper already had: an agent is an address, the address is the identity, and the identity is published in DNS where a stranger can validate it without an account. Whalenet adds the part a fleet needs - who else is in it, whether you can reach them, and what the path between you actually is.
The verbs, flags and argument order mirror tailscale, so what you already know transfers. What differs is said out loud rather than left to be discovered.
What is true today
Read this section before the commands. Every line of it is enforced by the tool's own output, so you will meet these facts anyway; meeting them here is cheaper.
| Fact | What it means |
|---|---|
| East-west is relayed by default | Traffic between two of your nodes is carried by the Whisper box both peers terminate on, unless that pair has a direct path and this host's own tunnel has seen the handshake land. The round trip through the box includes the hairpin: 23.8 to 24.3 ms relayed against 0.13 to 0.28 ms direct, about 130x. We hold the plaintext for that hop, which is categorically weaker than a relay that only ever carries ciphertext, and it is the reason a direct path is worth having. No customer pair has been measured on one yet: a node has to declare its private endpoints at connect before it is eligible, and whale status prints relayed for every peer that has not. |
| A cross-box pair has no path at all | Two nodes that terminate on different boxes cannot reach each other. whale status says so per peer rather than drawing a row that implies reachability. |
| Traversal is deliberately small | No STUN, no DERP, and no third party anywhere in it. The cases covered are the ones that need no traversal at all (two nodes on a shared segment, or a peer whose public endpoint nothing rewrites) plus a punch where both ends handshake at the endpoints a box observed them arriving from. A pair where BOTH ends sit behind a NAT that varies its port per destination still relays, and a punch that fails costs latency and nothing else. |
| The namespace is public | Agent names live in public DNS and the reverse tree is walkable. Anyone can enumerate what you publish. |
| Mobile is not supported | There is no iOS or Android Whalenet client, and no date to promise. |
| Direct paths will move the boundary | Once a pair talks directly, revocation depends on both ends applying it, and a peer entry's lifetime is not bounded yet. That is a cooperative boundary, not an enforced one, and it is worth knowing before you rely on it. |
The verbs
$ whisper whale
whisper whale - the Whalenet command shell.
The verbs, flags and argument order mirror `tailscale`, so what you already know
transfers. What differs is said out loud rather than left to be discovered:
status this node, your fleet, and the path between them
ip this node's address (Whalenet is IPv6-only today)
ping a real round trip to a peer, and what it proves
netcheck what works between this host and the fleet, measured
whois who holds an address, keylessly, validated from the IANA root
dns the resolver in effect, a query with the graph's view, your records
route subnet routes: what this node carries, and what advertising needs
exit-node the ways out, ranked on the graph rather than on latency alone
ssh SSH to a node, host key proven from the IANA DNSSEC root
caller who an accepted connection really came from, for sshd to ask
ssh-authz let your fleet's agents log in here with their own key, DNSSEC-proven
migrate move a Tailscale tailnet here, plan first, nothing silently widened
serve put a local port in front of your fleet, pinned by the published TLSA
funnel the same port, answered for the whole internet, deliberately
syspolicy the settings your MDM manages here, and the profile that sets them
acl the document that decides who in your fleet may reach what
nodes who has joined, and what each join key allows
approve admit a pending node to east-west
deny hold a node out of east-west again; it keeps its name and its egress
approval the fleet's join rule: admitted at once, or held for approval
A node joins with a key minted for it: `whisper create --register --name db-01
--tag tag:prod`, then `whisper connect` on the node with that key. Those two
commands are the whole join. Everything here reads before it writes, `migrate
plan` changes nothing at all on either side, and `acl test` answers from the
artifact the wire reads.
(Trimmed at the same place the tool stops describing itself: the usage, the per-verb summaries and the global flags follow, and whisper whale <verb> --help is the better place to read them.)
Every transcript on this page is real output from the binary https://get.whisper.online/dl/linux-arm64/whisper serves, whisper version 0.217.2. Nothing here is a mock-up. Two things in it are rewritten rather than captured, and it is worth knowing which: API keys are redacted, and every tenant label is replaced by a placeholder of the form t00000000000000000000000000000001. The addresses are rewritten to match: their routing half is zeroed the same way the tenant label is, so a block here shows you the shape of a real record while resolving to nothing. That matters more than it looks - an address is the PTR and RDAP lookup key, so publishing a real one alongside a redacted label would hand back the label the redaction removed. To check a real one, run whisper whale whois against an address you hold.
Joining a node, and who may reach it
A node joins with a key minted for it. The key carries its join settings, so they are decided once, by whoever holds your account key, and a node can never change them about itself.
$ whisper create --name db-01 --tag tag:prod --single-use
whisper: identity ready
agent agent-a0000000000000a01
address 2a04:2a01:0000:0001:0000:0000:0000:0a01
API KEY (shown once - store it now):
whisper_live_…
join tags tag:prod, single-use
next on the node: WHISPER_API_KEY={the key above} whisper connect
(The name and ptr lines are trimmed; they carry the account's domain.)
| Flag | What the key does |
|---|---|
--tag tag:prod |
The node's tags, repeatable. Fixed for the key's life: a connect may restate them, and one that states different tags is refused naming both. |
--single-use |
The key establishes one node. A second connect is 409 CREDENTIAL_SPENT, on either box, even when two connects race. |
--ephemeral |
The node is released by itself once it holds no connection for 15 minutes: its /128, its names and its tunnel go. |
--preapproved |
Admitted to east-west at once, even under a manual join rule. |
--ttl 24h |
The key expires. Not with --tag: a tag's authority outlives whoever minted it, so the two are refused together. |
Each of them implies --register. On the node, whisper connect with that key is the rest of the join, and nothing else is needed.
$ whisper whale nodes
NODE ADDRESS TAGS KEY CONNECTS LIFETIME EAST-WEST
agent-a0000000000000a02 2a04:2a01:0000:0002:0000:0000:0000:0a02 tag:prod reusable 0 - admitted
agent-a0000000000000a01 2a04:2a01:0000:0001:0000:0000:0000:0a01 tag:prod single-use 0 - admitted
A node minted with no join settings writes no join record and is not listed here; whisper list shows every agent.
Approval gates east-west and nothing else. A held node keeps its /128, its name, its resolver and its internet egress from the moment it joins. What it does not get is reachability to and from its siblings. whisper whale approval manual holds every new node until you approve it; deny holds one that is already in.
$ whisper whale deny agent-a0000000000000a02 --reason "maintenance"
NODE ADDRESS TAGS KEY EAST-WEST
agent-a0000000000000a02 2a04:2a01:0000:0002:0000:0000:0000:0a02 tag:prod reusable pending_approval
$ whisper whale nodes --pending
NODE ADDRESS TAGS KEY CONNECTS LIFETIME EAST-WEST
agent-a0000000000000a02 2a04:2a01:0000:0002:0000:0000:0000:0a02 tag:prod reusable 1 - pending_approval
1 node(s) pending approval: they resolve and reach the internet, but not their siblings. `whisper whale approve <node>` admits one.
$ whisper whale approve db-02 --reason "maintenance"
NODE ADDRESS TAGS KEY EAST-WEST
agent-a0000000000000a02 2a04:2a01:0000:0002:0000:0000:0000:0a02 tag:prod reusable admitted
What that did on the wire, measured from the two nodes themselves (two routed WireGuard nodes on the same box, 2026-11-06):
| State of node 2 | node 1 to node 2 (ping6, and a TCP echo) |
node 2 to node 1 | node 2 resolves | node 2 to the internet |
|---|---|---|---|---|
| admitted | 3/3, echo returned | 3/3 | yes | yes |
| denied | 0/3, timed out | 0/3 | yes | 200 |
| approved again | 3/3, echo returned | 3/3 | yes | yes |
A decision is in force on the wire within about 15 seconds: a deny took 17 seconds and an approve 12, each counted to three consecutive probes agreeing. The read-back is immediate and identical on both boxes.
The approval verbs take your account's own key: a node's key is refused (WHALE_OWNER_ONLY), for itself or any other node. A name is matched in your fleet exactly and never through public DNS, and a name two nodes answer to is refused rather than guessed. whisper whale approval manual needs dns:whale:write, a grant nobody holds by default, because who joins a fleet is a fleet-wide decision.
These transcripts are from an unreleased build of the commit that adds these verbs, run against the live control plane on 2026-11-06. Beyond the redactions described above, the two nodes' labels, their tag and the audit reason are renamed too.
Where am I, and what can I reach
netcheck measures rather than asserts. It is the first thing to run on a host that is behaving oddly, and it needs no key.
$ whisper whale netcheck
NETCHECK
ipv6 yes
ipv4 yes
udp yes
anchor box ns1.whisper.online 25.0 ms
mtu client 1280
mtu server 1340
BOX FAMILY ADDRESS UDP/53 TCP/443 NOTE
ns1.whisper.online ipv6 2a05:f480:1400:ab7::fe45:10c 38.4 ms 25.0 ms -
ns1.whisper.online ipv4 78.141.218.153 38.5 ms 25.1 ms -
ns2.whisper.online ipv6 2001:19f0:5000:15f6::fe45:110 35.4 ms 35.4 ms -
ns2.whisper.online ipv4 45.32.186.184 35.4 ms 30.5 ms -
mtu: client is this host's tunnel interface; server is the wg-agents interface on the box (the fleet's published value, not measured from here). The smaller of the two governs.
A v4-only host can still join: the WireGuard endpoint is resolved over both families, so the tunnel rides IPv4 while the identity inside it stays IPv6.
PATH relayed: east-west traffic is carried by the box both peers terminate on. direct-local means the two nodes share a segment and the packets never touch a box; direct-public means the peer's endpoint is reachable as-is; direct-punch means a path was opened through a NAT by both ends handshaking at the endpoints a box observed them arriving from. A punch that fails costs latency and nothing else - the relay carries the peer throughout, and the line under this table says so in those words - and a pair where BOTH ends sit behind a NAT that varies its port per destination still relays. A pair split across two boxes has no path at all. Nothing here is measured until you run `whisper whale ping <peer>`.
The two MTU numbers are the usual cause of "it connects and then large transfers hang": 1280 is the client netstack default, 1340 is what the wg-agents interface on the box publishes, and the smaller one governs.
The fleet, and the path to each peer
$ whisper whale status
NODE
host build-vm
address 2a04:2a01:9::50
tier -
connection not connected
key set (WHISPER_API_KEY)
PEER ADDRESS STATE PATH RTT NAME IN DNS
agent-a0000000000000b01 2a04:2a01:0000:0001:0000:0000:0000:0b01 active relayed - a0000000000000b01.t00000000000000000000000000000002.agents.whisper.online
agent-a0000000000000b02 2a04:2a01:0000:0002:0000:0000:0000:0b02 active relayed - a0000000000000b02.t00000000000000000000000000000002.agents.whisper.online
PATH relayed: east-west traffic is carried by the box both peers terminate on. direct-local means the two nodes share a segment and the packets never touch a box; direct-public means the peer's endpoint is reachable as-is; direct-punch means a path was opened through a NAT by both ends handshaking at the endpoints a box observed them arriving from. A punch that fails costs latency and nothing else - the relay carries the peer throughout, and the line under this table says so in those words - and a pair where BOTH ends sit behind a NAT that varies its port per destination still relays. A pair split across two boxes has no path at all. Nothing here is measured until you run `whisper whale ping <peer>`.
agents.whisper.online snapshot age: ns1.whisper.online 49m, ns2.whisper.online 49m. Every node is answering from the same recent snapshot.
this host is pinned to 2a04:2a01:9::50, which is not in the fleet this key can see - the node half and the peer half are describing different accounts
(The peer table is trimmed here; the run it was captured from listed the whole fleet.)
Three things worth noticing in that output.
The PATH column is relayed, not a hopeful direct. A direct form is printed only when this host's own tunnel records a handshake that landed, because the handshake never touches a box and the box's answer therefore cannot settle it.
The snapshot age line is how stale each authoritative node's copy of the zone is, asked of each nameserver directly rather than through a resolver. That distinction is the point: the question is not what some node said, it is whether the nodes agree. Who may log in to a node is decided on that node from a signed record, and a node that has lost contact with the primary keeps serving the copy it holds with nothing bounding how long, so two nodes on different snapshots means whichever one replies decides what you are told. When that happens the line says so in those words. It never invents a number it cannot stand behind either: a serial it cannot reliably read as a time, or a nameserver that did not answer, is reported as unknown with the reason rather than dropped.
And the last line is the tool refusing to paper over a mismatch: this host is pinned to an address the presented key cannot see, so the node half and the peer half are describing different accounts, and saying that is more useful than rendering a tidy table that quietly means nothing.
Proving a path rather than believing one
status draws the topology. ping is the one that measures it.
$ whisper whale ping 2a04:2a01:0000:0003:0000:0000:0000:0b03
reply from 2a04:2a01:0000:0003:0000:0000:0000:0b03 tcp/443 in 39.8 ms path=relayed
reply from 2a04:2a01:0000:0003:0000:0000:0000:0b03 tcp/443 in 25.6 ms path=relayed
reply from 2a04:2a01:0000:0003:0000:0000:0000:0b03 tcp/443 in 26.1 ms path=relayed
3 sent, 3 answered, path relayed, rtt min/avg/max 25.6/30.5/39.8 ms
the path exists and it is relayed by a Whisper box, so this round trip includes the hairpin out to the box and back.
Who holds an address - with no key at all
whois is the verb to hand somebody outside your organisation. It needs no account, and it does not ask you to trust our answer: the name is validated in the client process, from the IANA DNSSEC root trust anchor compiled into the binary, because our own resolver never sets the AD bit and a tool that read AD would be trusting the wrong thing.
$ whisper whale whois 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
WHOIS
target 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
address 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
name ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
name proof DNSSEC-validated here, from the IANA root
forward confirm AAAA(ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online) contains 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
rdap handle ae3b051ff3bf7f478
rdap name scout
range 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
country NL
status active
trust anchor: IANA DNSSEC root -> ip6.arpa -> the delegation that holds this /128
validated by this client, in-process (our resolver never sets AD). Pass --json for the verbatim RDAP object.
forward confirm is the half that matters: a PTR alone proves nothing, because whoever holds the reverse tree writes it. Resolving the name it gives back and finding the original address in the AAAA is what makes it FCrDNS.
Naming, and what the resolver did with your query
$ whisper whale dns query whisper.online
DNS QUERY
question whisper.online A
resolver 127.0.0.53:53 via the system resolver, no Whisper profile applied on this host
rcode NOERROR 43.1 ms
answer whisper.online. 300 IN A 78.141.218.153
whisper.online. 300 IN A 45.32.186.184
policy none the resolver answered normally and attached no policy signal
graph NONE coverage known-clean
policy is the resolver's own signal, read off the wire. graph is the assessment the resolver consults, not a second verdict computed here.
policy and graph are deliberately two fields. One is what the resolver did; the other is what the graph knows. Collapsing them into a single verdict would hide the case where they disagree, which is exactly the case worth seeing.
Ways out, and what ranks them
$ whisper whale exit-node list
CANDIDATE ASN DENSITY RTT NOTE
ns2.whisper.online AS219419 unknown 35.3 ms the graph holds no routed space for this ASN, so there is no density to compute - absence of a signal, not a clean bill of health
ns1.whisper.online AS219419 unknown 35.3 ms the graph holds no routed space for this ASN, so there is no density to compute - absence of a signal, not a clean bill of health
These are the Whisper egress points this node can use today. A PEER-advertised exit node is kernel-tier only and needs a direct node-to-node path to EVERY node that would use it, which this build does not have for the general case: many pairs get one, but a pair with a port-varying NAT at both ends still relays and a pair split across two boxes has no path at all. Density is the graph's listed-IP ratio for the ASN, read from asnThreatDensity().densityRatio and explain().breakdown.graphDensityRatio - never from the prose in an explanation.
unknown is a deliberate value, not a missing one. An ASN the graph holds no routed space for has no density to compute, and rendering that as 0.00 would read as a clean bill of health for something nobody has looked at.
Subnet routes
A Whisper agent peer is bound to exactly one /128, and that is a security property rather than a limitation to flag away: it is what stops one agent sourcing another's identity. A subnet router is therefore a separate class of peer, kernel-tier only, and direct-path only - two customers routinely advertise the same 10.0.0.0/8, and one shared box cannot hold both.
$ whisper whale route list
PREFIX SOURCE DIRECTION
- - nothing routed
Nothing is connected, so this node routes nothing into a tunnel. Run `whisper connect` first.
No subnet route is advertised, and none can be in this build: run `whisper whale route advertise <prefix>` to see exactly what is missing.
SSH without trust-on-first-use
whale ssh checks the host key in this process against the SSHFP record published for the node, validated from the IANA root trust anchor compiled into the binary. It is not ssh -o VerifyHostKeyDNS=yes: that reads the AD bit, our resolver never sets AD, and it would print a DNS match and then prompt you anyway.
There is no trust-on-first-use. If no SSHFP is published, or the offered key does not match one, the connection is refused and the message says which. Who may log in is decided on the target, by whisper whale ssh-authz check: an active agent of the fleets written into that host's sshd snippet, offering the key its SSHFP publishes, both proven from DNSSEC there. When your WhaleACL has an ssh block, a login must also be admitted by a rule naming the caller, the node and the account, compiled into the node's view at its last ssh-authz install --write (see the CLI page), so one document governs east-west and SSH. A revoked agent is denied, and the denial lands in the target's auth log. --explain names both halves without connecting.
Reaching a node: accepting on its /128
On the userspace tier a node's /128 exists only inside the whisper process that holds its tunnel - there is no TUN device and no kernel route - so nothing answers SSH on it, however healthy the tunnel is, until the node opens the port. --accept does that. It is off by default, it admits your fleet only, and each connection it admits is passed to a service on the node's own loopback. The service installer keeps it up across reboots: it writes the ports into the config the unit already runs, which is the same mechanism on every platform the service installs on. This capture is from a Mac (launchd):
$ sudo whisper service install --config /etc/whisper/connect.json --no-sensor --accept 22 --now
installed and started whisper-connect (darwin-launchd)
config: /etc/whisper/connect.json
status: whisper service status
accept: 22 -> 127.0.0.1:22 (your fleet only)
For a session you hold yourself the flag is on connect: whisper connect --accept 22, or --accept 2222=127.0.0.1:22 to map one port to another. The target is always this host's loopback, because passing fleet connections on to another machine would make the node a way into its network. --accept-from admits extra addresses or prefixes, down to a /32; anything wider is the internet in all but name, so it has to be --accept-public, which asks you to type yes the way funnel does and records the consent. whale status lists what a host accepts, from any shell. This is its ACCEPTING table; the node and peer tables above it are left out:
ACCEPTING TO WHO ON
22 127.0.0.1:22 your fleet only 2a04:2a01:9::b08
From a fleet node, whale ssh proves the host key from the published SSHFP and sends the connection through that node's own Whisper session, so it arrives from a /128 the target's fleet knows rather than from the caller's ordinary address. These captures are from a live run, with the node, user, key and addresses replaced by neutral ones:
$ whisper whale ssh you@db-01 uptime -- -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes -o BatchMode=yes
host key: checked as it is offered, against the SSHFP validated from the IANA root
host key matched SSHFP 3 2 c1711c67059bea127fb1fd98ca0ad03c338a2c956281f40b172108c00f82eb4e (ecdsa, sha256), validated from the IANA root
0:18 up 2 days, 18:54, 2 users, load averages: 9.14 9.04 8.42
A port the node has not opened is named, with the command that opens it, instead of a bare timeout. Through a session every failed dial comes back the same way, so the message names the other possibility as well:
$ whisper whale ssh -p 2222 you@db-01 hostname -- -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes -o BatchMode=yes
host key: checked as it is offered, against the SSHFP validated from the IANA root
whisper: the connection to port 2222 of db-01's /128 was refused or could not be made: either db-01 is not accepting 2222 (On db-01, run `whisper connect --accept 2222`, or keep it up across reboots with `whisper service install --accept 2222 --now`), or it is not connected right now.
Connection closed by UNKNOWN port 65535
The node logs every connection with the address it came from. A caller outside the fleet - here an ordinary internet address that reached the /128 directly - is refused before anything on the host is dialled, and a fleet member whose agent is revoked loses the session it already has at the node's next fleet refresh, within a minute:
whisper: accept :22 from 2a04:2a01:9::b09 -> 127.0.0.1:22
whisper: accept :22 from 2a04:2a01:9::b09 closed after 1s (closed by both sides; 2754 bytes in, 3621 out)
whisper: accept :22 refused 2001:db8:77::6d86: not permitted to reach 127.0.0.1:22
whisper: accept :22 from 2a04:2a01:9::b09 -> 127.0.0.1:22
whisper: accept closed an open connection from 2a04:2a01:9::b09: it is no longer permitted
What an accepted connection cannot carry is its source address. It reaches sshd from loopback, so sshd logs 127.0.0.1, and an AuthorizedKeysCommand that binds a key to the caller's /128 would be handed the wrong one. The node knows the answer, because it made that loopback connection itself, and whale caller gives it back while the connection is open:
$ whisper whale ssh you@db-01 'echo $SSH_CONNECTION; whisper whale caller $SSH_CONNECTION' -- -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes -o BatchMode=yes
host key: checked as it is offered, against the SSHFP validated from the IANA root
host key matched SSHFP 3 2 c1711c67059bea127fb1fd98ca0ad03c338a2c956281f40b172108c00f82eb4e (ecdsa, sha256), validated from the IANA root
127.0.0.1 56198 127.0.0.1 22
2a04:2a01:9::b09
In an AuthorizedKeysCommand run as /usr/local/libexec/check-key %u %k %C, the caller's address is $(whisper whale caller "$3"), and the command fails when the connection did not come in through an accept. It matches the whole loopback connection, never the port alone, so another local user cannot borrow a fleet member's address. Two limits: an AuthorizedKeysCommandUser without privileges can read the answer only when the installed service holds the connection, and the answer names the node the caller connected from, not a person on it.
You do not have to write that command yourself. whale ssh-authz is it, shipped: it asks whale caller for the real /128, proves the caller's PTR, AAAA, whisper-id1 status and SSHFP from the IANA root, and prints the key line or nothing. sudo whisper whale ssh-authz install --write wires it into sshd; the CLI page has the details.
Coming from Tailscale
whale migrate plan reads their tailnet and writes a plan file. It changes nothing, on either side. Read the plan before you apply it: it enumerates every write in the order it will happen, and names what mapped exactly, what mapped approximately, what mapped to something strictly broader than their rule, and what cannot map at all. A rule that would widen is refused until you pass --accept-widening, and that consent is written into the plan file so it can be audited later.
The Tailscale credential is read from the environment (TS_API_KEY, or TS_OAUTH_CLIENT_ID + TS_OAUTH_CLIENT_SECRET), never from a flag. It is never written to the plan, never logged and never echoed.
Serving a port to your fleet, or to the internet
serve puts a local port behind this node's own /128, on the TLS leaf the published TLSA record already pins - a caller verifies it from the IANA DNSSEC root, no CA and nothing to install. By default only your fleet is answered; the port is still globally routable, so a stranger who reaches it gets a 403 and nothing else.
$ whisper whale serve 8123 --yes
SERVING
scope fleet - your fleet only
url https://a0000000000000b04.t00000000000000000000000000000001.agents.whisper.online/
origin http://127.0.0.1:8123/
address 2a04:2a01:0000:0001:0000:0000:0000:0b04
name a0000000000000b04.t00000000000000000000000000000001.agents.whisper.online
identity headers on
since 2026-08-30T05:21:53+01:00
pid 2617173
callers outside your fleet get a 403. Ctrl-C stops it.
A caller outside the fleet gets exactly that, with a reason rather than a bare status line:
$ curl https://a0000000000000b04.t00000000000000000000000000000001.agents.whisper.online/
this port is served to its fleet only, and 2001:db8::dedb is not in it
Every request that does reach the origin carries who called, established by Whisper rather than claimed by the caller: Whisper-Client-Address always, and Whisper-Agent-Address/-FQDN/-Owner plus Whisper-Assess-Band/-Coverage when they could be proven. Every Whisper-* and Tailscale-* header the caller itself sent is stripped first, so an origin can trust Whisper-Agent-FQDN by its presence alone; --compat-headers also emits the Tailscale-User-* spellings, for an app mid-migration. whisper whale serve status shows what a host is serving; whisper whale serve off stops it immediately.
This is what an origin was handed for one request from another node of the same fleet, captured with whisper version 0.247.0 on 2026-11-05. The caller sent a forged Whisper-Agent-FQDN header of its own, naming somebody else; it is gone, and what stands in its place was proven from the network and from DNSSEC. The two nodes were registered under a bring-your-own domain, shown here as example.com, with their addresses rewritten as above:
Whisper-Agent-Address: 2a04:2a01:0000:0001:0000:0000:0000:0b05
Whisper-Agent-Fqdn: a0000000000000b05.example.com.
Whisper-Agent-Owner: Whisper Security Abuse
Whisper-Assess-Band: UNKNOWN
Whisper-Assess-Coverage: no-data
Whisper-Client-Address: 2a04:2a01:0000:0001:0000:0000:0000:0b05
Whisper-Identity-Proof: client-address=socket; agent-address=cryptokey-routed; fqdn=dnssec-ptr+forward-confirmed; owner=control-plane; assess=graph
Whisper-Serve-Scope: fleet
Whisper-Identity-Proof says how each value was established. A name or owner that could not be proven inside the request's budget is left out and the proof line says why (fqdn=absent(lookup did not finish inside the budget)), which is what the very first request from a new caller can see; it is never filled with a guess.
The leaf on the port is the one the TLSA pins, checked with nothing but the published record:
$ openssl s_client -connect '[2a04:2a01:0000:0001:0000:0000:0000:0b04]:443' -servername a0000000000000b04.example.com \
-dane_tlsa_domain a0000000000000b04.example.com -dane_tlsa_rrdata '3 1 1 7D199D6CC0B96B8ED76D06D6322DA2B8EBBEB581609784A36EF47FB358F003B6'
DANE TLSA 3 1 1 ...609784a36ef47fb358f003b6 matched EE certificate at depth 0
Verify return code: 0 (ok)
That leaf is signed by the agent's own identity key, so the node that serves must hold it. An agent created by its owner starts with a key Whisper holds, and serve on such a node says so and names the fix, whisper connect --adopt-key --agent <agent>, which moves the agent's TLSA, SSHFP and OPENPGPKEY to this host's key.
Once the host holds the key, rotating it is one command on that host. Every key event commits to the next key, and that next key never leaves the host, so a stolen serving key cannot move the identity:
$ whisper identity rotate 2a04:2a01:fc25:7870:9ce8:d50:3162:fe62
whisper: rotated 2a04:2a01:fc25:7870:9ce8:d50:3162:fe62: key fcb52ea8c0f33f40, the old key serves until 2026-11-05T08:31:05Z
$ whisper identity history 2a04:2a01:fc25:7870:9ce8:d50:3162:fe62
2a04:2a01:fc25:7870:9ce8:d50:3162:fe62 a9ce80d503162fe62e1793866999176 chain committed
0 icp adopt key fb96ad3c7108d5d8 commits ee75d90e3f16 2026-11-05T08:24:30Z proven
1 rot key key fcb52ea8c0f33f40 commits 77f69a88fb1e 2026-11-05T08:25:05Z not yet proven
The old key keeps serving until the new one has reached every DNS cache, then the new key serves alone; proven appears once the event's inclusion proof is in the transparency log. A host that has lost the next key cannot rotate. The account owner runs whisper identity recover <agent> on the agent's host instead, which mints a fresh key and is recorded as a visible break in the chain.
funnel is the same mechanism with the fleet check removed: the whole internet is answered, not just your fleet. Because the /128 is already globally routable there is no propagation wait and no certificate-authority rate limit to hit - going public is a decision, not a deployment, which is why it asks you to type yes (or pass --yes) rather than just doing it. One caveat: a caller that is itself a Whisper /128 in another tenant is still governed by the east-west plane above, so it can be refused before it ever reaches you while the rest of the internet is answered normally.
Both verbs serve on :443 because _443._tcp.<fqdn> TLSA is what makes the leaf verifiable, and both accept a target liberally - 3000, :3000, localhost:3000, [::1]:3000, http://127.0.0.1:3000/api all work. The three /.well-known/ identity paths stay Whisper's own and are never proxied through.
Installing, and removing
One command in, one command out, and the same pair on Linux and macOS:
curl -fsSL https://get.whisper.online | sh # install
curl -fsSL https://get.whisper.online/uninstall | sh # remove
On Windows:
irm https://get.whisper.online/install.ps1 | iex # install
irm https://get.whisper.online/uninstall.ps1 | iex # remove
macOS also has a signed and notarized installer package, for people who would rather double-click than paste a command. The uninstaller above knows that layout too: it removes the /opt/whisper payload, stops the host sensor through the CLI's own service uninstall, forgets the package receipt, and withdraws this machine's /128 first so nothing keeps routing after the software is gone.
Next
Connect & egress - the three tiers a single agent uses to put its traffic on the wire · Verify an agent - the same checks whale whois runs, done by hand with dig and curl.