WhisperDocs
Concepts

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.