How Vouched KYA verifies agents

The evidence Vouched KYA checks, hardest to forge first, what each kind can and cannot prove, and what the class, confidence, and risk score in a result tell you

Every surface, from the DNS gateway to the SDKs and the Pixel, Beacon, and API routes, runs the same detection engine. It examines many independent signals in layered checks, cross-checks what a client claims against how it behaves, and gives verified cryptographic identity precedence over heuristics. Every result records which kind of evidence it rests on, so you can tell an agent that proved its identity from one that only claims a name.

The evidence, hardest to forge first

EvidenceWhat the engine checksWhat it provesWhat it cannot prove
Vendor signatureRFC 9421 signature and Signature-Agent against the vendor's keyThe vendor's key signed this requestWho it acts for, or that you allow it
KYA-OS identityA signature by its DID's key, then any delegationThe agent holds its DID's key, and who granted it whatThat your policy allows what was granted
Vendor networkClient IP in published ranges, plus the matching user agentThe request came from that operator's addressesWhat the request is for
TLS handshakeWhether the connection matches the client the user agent claimsA browser user agent came from a non-browser clientWho the client is
User agent and headersKnown-agent intelligence, and header consistencyOnly what the client claimsWho sent the request
BehaviorBrowser and runtime integrity, interaction, and request rateDisclosed automation, or bot-like volumeThat a quiet client is human

Cryptographic proof

Vendor signatures. Some agents sign each request with HTTP Message Signatures and name themselves in the Signature-Agent header from the Web Bot Auth draft; OpenAI's ChatGPT agent does. The engine checks Signature, Signature-Input, and Signature-Agent together against the vendor's published key: the signature must verify, Signature-Agent must name the same vendor as the key, and the signature must be current. A verified request is classified ai_agent.

A signature that fails verification earns no trust and blocks nothing by itself: the engine evaluates the request on its other evidence, and the result records why the signature failed.

KYA-OS identity. A KYA-OS agent signs with the key its DID names (did:key or did:web), in a signature that is valid for at most 300 seconds and, when the request has a body, covers it. It can also present a delegation credential, a signed grant from a user or organization; the engine checks the issuer's signature on it, that it names this agent and this site, its expiry, its scopes, and whether it was revoked. KYA-OS requests over MCP connections get the same DID, signature, revocation, expiry, and scope checks. See KYA-OS Enforcement and Delegations.

The assurance field records the strongest identity proof: key-bound for a KYA-OS DID signature, delegated when a delegation verifies on top of it, and anonymous for a vendor signature, which proves the vendor but binds no user.

Network evidence

Vendor IP ranges. The engine checks the client IP against the IP ranges that AI and search operators publish for their agents and crawlers, and counts a match only when the user agent is one the operator publishes for those ranges. The ranges are regularly updated. The check is only as good as the client IP your integration resolves: behind a load balancer, set a trust profile.

TLS handshake. The engine cross-checks how a client connects against what its user agent claims: a client that claims to be a browser but connects with a non-browser TLS stack is classified bot. This evidence reaches the engine from the DNS gateway, or from your own edge with Forward edge evidence.

User agent and headers

The engine matches User-Agent against regularly updated intelligence on AI agents, AI crawlers, search engines, automation tools, and developer tools, and checks the request's headers for signs of automation. A user agent names an agent but proves nothing: anyone can send ChatGPT-User. By default, a user-agent match never blocks on its own; your policy decides.

Behavior

The Pixel and Beacon report browser and runtime integrity and interaction from the visitor's browser. A browser that reports it is under automation control is classified bot.

The DNS gateway, the Pixel and /detect routes, and the .NET and Java SDKs also measure each client's request rate, and classify an otherwise unidentified client that sustains a bot-like rate as bot.

What a result tells you

  • Class is one of human, ai_agent, bot, or incomplete_data (see Detection Classes). A named crawler such as GPTBot is bot, even when its IP is in OpenAI's published ranges. No agent evidence yields human or incomplete_data at low confidence, which means nothing matched, not that a person did.
  • Confidence (0 to 100) measures how strongly the evidence indicates automation. A verified signature puts it in the very_high level. It is a score, not a measured probability; Confidence Scores has the levels.
  • riskScore (0 to 1) is a separate, uncalibrated estimate that the request is automated, reported with riskScoreSource: "uncalibrated", or null when none was computed.

Your policy then decides what happens: verification identifies the caller but never authorizes it, so a verified signature still goes through your policy. The Response Object documents every field.