Your SOC doesn't need another console. Your fleet needs an identity it can prove.
Detection tools stack up, each one another dashboard an analyst babysits, and none of them stops abuse that passes auth or a source that rotates across three clouds. Whisper isn't another console. It's one primitive, the address is the identity, expressed as three planes that plug into the SOC you already run.
dig. That one primitive becomes three planes: identity, an attribution graph that survives IP rotation, and per-agent governance, standing on real routable space at AS219419, anchored at the IANA root. Our API is never in the trust path.
whisper verify --trustless · anchored at the IANA DNS root. Our own API is not in the trust path.
Everything below derives from one line: the address is the identity.
A routable IPv6 /128 out of 2a04:2a01::/32 (announced by AS219419), deterministically derived from a key, DNSSEC-anchored, DANE-EE pinned, RDAP/WHOIS-registered: re-derivable and verifiable by anyone with dig.
Most security tooling starts from an observation, a packet, a log line, a source IP, and tries to infer who is behind it. Whisper starts from the other end: it gives the thing an identity that is its address, cryptographically bound to a key you already hold, and publicly verifiable without trusting the issuer. Point it at a tractor, an implement ECU, a drone controller, or an AI agent, and the question "who is this?" stops being an inference and becomes a fact anyone can check. Three products fall out of that one primitive: not three integrations you wire together, three faces of the same address.
One address, three jobs: who is this, who's really behind that, and what may talk to what.
Identity answers who is this, provably. The attribution graph answers who's really behind a source that rotates. Agent governance answers what may talk to what. Each plane is useful alone; together they close both gaps every equipment-API attack leans on.
A machine identity your backend authorizes on, not a bearer token anyone can present.
This is the plane that closes the gap the equipment-API attacks live in: abuse that passes auth. Bind authority to the machine, not to a secret that whoever holds it can replay.
Point the primitive at machines. Derive each tractor's, implement's or ECU's /128 from the hardware key it already holds in its secure element or TPM, with the 17-character equipment PIN or an implement/ECU serial as the domain separator. The private key never leaves the secure element; the address is a one-way function of its public half and the PIN. The backend then authorizes on the machine's pinned identity, not a stealable token, and a harvested grant with no leaf key behind it authenticates to nothing.
"A leaked API key or a valid partner session looks legitimate; how do you catch abuse that passes auth?"
You bind authority to the machine, not the bearer. State-changing commands terminate mutually-authenticated to the target machine's /128, the machine co-signs, so a platform or partner session can't reach a serial it can't cryptographically address. A request that passes auth but can't prove the identity never had authority in the first place.
NAME, self-declared over J1939/CAN framing, and nothing on the bus can cryptographically verify it; AEF Guideline 040's ISOBUS security principles name exactly this class of gap. Whisper never touches the bus: it anchors the machine↔cloud IP boundary, where the same machine's derived /128 is provable by anyone against the IANA root. The PIN stays the public index; the /128 is bound to the device's key as well, so PIN alone yields nothing, and there is no enumerable directory.Attaches to what you already ship: the secure element or TPM, the ISOBUS NAME, the X.509 device-cert mTLS your equipment cloud already runs, as the publicly verifiable, DNSSEC/DANE-anchored layer on top. No bespoke CA trust store to push to every machine; revocation at DNS-TTL speed instead of CRL/OCSP soft-fail. Standards mapping →
Attribution that survives IP rotation, because it fingerprints the operator, not the exit.
This is the plane that closes the other gap: the data broker who rotates across Amazon, Google and Azure or a residential-proxy swarm until your SOC only ever logs a meaningless last IP.
A live internet-infrastructure graph, 7.44B nodes and 39.3B relationships of fused BGP, DNS, WHOIS, TLS, hosting and threat intelligence, answering in under 300 ms, pulls two levers, kept honestly separate. For cloud rotation it clusters shared ASN, hosting and certificate lineage into one infrastructure genealogy. For a residential-proxy swarm, where a subscriber IP gives an infra graph nothing to grab, a JA4/JA3 client fingerprint travels with the tooling regardless of the exit and collapses the swarm to one operator. The egress IP is the one thing this plane never relies on.
"When they rotate residential proxies and fresh cloud IPs, can you actually attribute them, or just rate-limit an IP and move on?"
Track them. Infrastructure genealogy collapses the cloud rotation; a JA4 client fingerprint collapses the residential swarm. Every answer returns a reproducible evidence chain: signed, replayable JSON your SOC, your auditors and a regulator can hand around.
identify(ip)
Who really operates a host, even behind a CDN, across any cloud.
origins(prefix) + walk(node,depth)
Cluster rotating IPs into one infrastructure genealogy.
history / watch
A timeline of an operator and a standing sentinel, plus variants(domain) to catch typosquat OEM and FMIS domains before they activate.
read-only Cypher
Express "one source touching N distinct machine-identities in a window" as a query your agent runs, not a ticket your analyst files.
Additive to the SOC and SIEM: the same fingerprints power external attack-surface mapping and dependency blast-radius (if a cloud region goes dark, which farms lose telemetry). Trace the full back-trace →
The same primitive governs the autonomous machines and AI agents your fields already run.
Autonomous 9RX-class tractors work fields with nobody in the cab, ag drones fly under FAA Remote ID, and agronomy copilots read and write farm data on a grower's behalf. Each is an agent making network calls, and today "which one did this" is a shrug at a shared NAT address. Whisper does it with identity instead of trust.
Which agent did this is the source address
Every autonomous machine, drone controller and agronomy agent egresses from its own routable /128: attribution, not a guess.
Every query and connection is logged per-agent
Queryable live via op:logs: a per-agent record, not a shared firehose. The trail the farmer can be shown.
Policy on every query
A graph-first resolver and bound egress enforce category, geography, ownership and routing: default deny, allow or block by name or subdomain. An autonomous tractor that should only ever reach its OEM's ops endpoints simply can't reach anything else.
Inbound agents are verifiable
FCrDNS, RDAP, whisper verify: "trust the bearer token / the description field" becomes a checkable fact. Per-agent budgets, a kill-switch, one revoke.
The autonomy, farm-API, MCP and LLM surface the incumbents are only now reaching for, governed by the same address-is-identity primitive, from day one.
The three planes drop into the systems your fleet already runs, at the IP and cloud boundary, never inside the bus.
Whisper anchors the cloud, not the hitch. Each row below is a proposed integration onto a system you already operate; the machine-identity /128 is the one capability that is shipped and live today. Every one is additive: it complements whatever authenticates the message, and it never reaches into the closed, safety-critical layers: the ISOBUS/J1939 bus, tractor-implement (TIM) functional safety, the drone's Remote-ID broadcast.
| Surface / standard you run | Where a plane plugs in: identity /128 · attribution graph · egress governance | Complements, does not replace |
|---|---|---|
| John Deere Operations Center (the keystone FMIS surface) | Identity + attribution. Every sanctioned data consumer calling the Operations Center APIs becomes one verifiable /128 the platform can allowlist, so an OAuth grant (12-hour access, 365-day refresh) replayed from an unknown address is separable from the real integration; the graph back-traces whoever scraped before that. |
Complements the platform's OAuth 2.0: authorization stays where it is; Whisper adds the network fact behind the grant. |
| Secure element / TPM in the telematics gateway · shipped & live | Identity. Derives the routable /128 from the same non-exportable device key in the gateway's secure element or TPM, and publishes a globally resolvable, DANE-verifiable, RDAP-registered name bound to it: the machine-identity spine, silicon projected onto the public namespace. |
Complements the hardware root of trust; it makes an otherwise un-routable, un-discoverable key resolvable and verifiable. |
| ISOBUS · ISO 11783 / AEF Guideline 040 | Identity. The 64-bit ISOBUS NAME is a self-declared claim on the CAN bus; AEF Guideline 040 names the gap. Whisper gives the same machine a cryptographically provable public counterpart at the IP boundary: NAME on the bus, DANE-pinned /128 on the wire. |
Complements ISOBUS; Whisper never touches the J1939/CAN bus or TIM functional safety. |
| Cross-brand data exchange (DataConnect-style, four OEM/FMIS clouds) | Identity + attribution. When machine data moves between brand clouds, each party in the chain carries a verifiable /128, so "who accessed this grower's data, from which cloud" survives the brand boundary and can be shown to the farmer. |
Complements the exchange's contracts and consent model; Whisper anchors the transport identity on each side. |
| Ag drones (FAA Remote ID, Part 89) | Identity + egress governance. The ground control station, the fleet backend and the USS endpoints each get a verifiable /128; the drone fleet's command-and-telemetry egress is policy-bound and attributable per aircraft controller. |
Complements Remote ID: the Part-89 broadcast stays untouched; Whisper anchors the internet-facing ground half. |
| Irrigation & LPWAN sensor networks (LoRaWAN gateways, cellular telemetry) | Identity + egress governance. The gateway that concentrates a thousand field sensors gets one provable /128 with default-deny egress, so a hijacked irrigation controller can't quietly talk to anything but its own platform. |
Complements LoRaWAN's own OTAA keys; Whisper anchors the gateway↔cloud IP boundary above them. |
Read together, these are the doors the EU Data Act (in force since 12 Sep 2025, and reaching connected farm machinery) forces open to user-chosen third parties, at the exact moment ISO 24882 asks the industry to monitor and control its machine connectivity. The Data Act makes you open the doors; Whisper is the doorway that knows who walked through and can shut it on one: per-/128 egress logs and the attribution graph become ready-made monitoring and forensic evidence. Standards mapping →
Five things you can't stand up overnight, and a competitor can't clone from a slide.
A platform is only as durable as what sits underneath it. Whisper's three planes rest on five load-bearing pillars, each a real, checkable fact rather than a claim on a roadmap.
Real routable space, not a namespace we invented
AS219419 and 2a04:2a01::/32 are announced to the global routing table. You cannot allocate verifiable identities from address space you don't hold and can't announce, which is why this can't be reproduced with a database and a domain.
A graph you accrete, not one you query once
7.44B nodes and 39.3B relationships of BGP, DNS, WHOIS, TLS, hosting and threat intel, built over years. Attribution across rotation is only as good as the history behind it, and history is the one thing you can't buy this afternoon.
A per-identity CA, so blast radius is one
One deterministically-derived leaf per machine, ECU or agent: DANE-EE pinned, never a shared intermediate. The single-CA-breach failure mode is removed by construction, not by policy.
Registry-anchored and root-anchored
Every /128 is a real RDAP/WHOIS object, and the whole chain validates through DNSSEC to the IANA root. whisper verify --trustless checks an identity without trusting Whisper: public accountability and a trust anchor you already run.
"Agtech startups fold and strand their customers. Will you still be here in five years, and is this real or a checkbox?"
It's infrastructure, and it's built by people who ran the internet's plumbing. Real routable address space at AS219419, run by a team that operated one of the internet's regional address registries and one of its root DNS servers. The moat is real space, an accreted graph and open standards, not a slide. You can verify every claim on this page yourself, today, without an account.
Exercise all three planes yourself; our API isn't in the trust path.
Two tiers, by design. No key: verify a machine's identity, the identity plane, trustless, anchored at the IANA root. Your key: back-trace a suspicious host across any cloud, register a machine, govern its agents, revoke it worldwide.
# plane 1: re-derive and verify any machine's identity, trustless
$ whisper verify --trustless 2a04:2a01:1c0::a6f1
✓ DNSSEC chain valid to the IANA root
✓ DANE-EE (TLSA) leaf matches the identity's key
✓ RDAP: registered under AS219419 · 2a04:2a01::/32
identity: VERIFIED, and our own API was never trusted
# the address is the machine: reverse DNS names it
$ dig -x 2a04:2a01:1c0::a6f1 +short
pin-1agcm82633a.farm.example-oem.whisper.online.
# plane 2: with your key, attribute who really operates a host via the public graph API
$ curl -s https://graph.whisper.security/api/query -H "X-API-Key: whisper_live_xxx" \
-H 'content-type: application/json' -d '{"query":"CALL whisper.identify(\"34.90.x.x\")"}'
operator: <fingerprinted> · seen across AWS / GCP / Azure
residential swarm collapsed by JA4: same tooling, 41 exit IPs → 1 operator# plane 1: give a machine a name it can prove
$ export WHISPER_API_KEY=whisper_live_xxx
# --pin/--from-secure-element are on the roadmap; today the 17-char PIN rides the live control-plane vin arg (see docs)
$ whisper register --pin 1AGC… --from-secure-element
→ identity 2a04:2a01:1c0::a6f1 DNSSEC + DANE live
# plane 3: govern what its agents may reach, and read the per-agent log
$ whisper policy set --default deny --allow ops.example-oem.com,updates.example-oem.com
$ whisper logs --identity 2a04:2a01:1c0::a6f1 --tail
$ whisper revoke 2a04:2a01:1c0::a6f1 # owner-thrown, publicly verifiable, at DNS-TTLThree planes, and all three exit into the stack you already run, not a new silo.
Feeds your SIEM, not another console
A machine-readable feed into your SIEM: the Splunk, Microsoft Sentinel and OpenCTI connectors ship today. Findings map to CEF and ECS fields and arrive as a signed, replayable JSON evidence chain you can hand a regulator, with STIX 2.1 over TAXII export on the roadmap.
Speaks your compliance language
Maps to ISO 24882 and AEF Guideline 040 evidence, the EU Data Act's authorized-party line, and the Ag Data Transparent promise. Usable in your risk assessment and your certification file, not just a dashboard.
In your auth path, and safe there
If your backend authorizes against the DANE/verify path, that plane is built to fail open: a Whisper outage never parks a tractor mid-harvest; checks degrade to your existing anchors. Anycast on AS219419, no single node in the path.
Flat, predictable pricing
Per-machine/year and flat: not per-transaction, not usage-metered, not per-acre. A line item you can forecast. See pricing →
On-prem or your own tenant
Data residency and GDPR by construction: the graph and the per-agent logs stay where your regulator, and your growers, need them.
Where it fits vs. what you run
Depth on top of your behavioral SOC and threat-intel: it makes them sharper, it doesn't replace them. See the comparison →
One primitive. Three planes. Give every machine an identity it can prove.
Identity, an attribution graph that survives IP rotation, and per-agent governance: additive to your SOC, mapped to your standards, priced so you can say yes. Keyless to try, one call to provision, one more to revoke.
Or run whisper verify --trustless right now.