Credential discovery in the agentic web: a credential not legible to agents is invisible

The discovery layer is breaking. For decades, credential discovery has meant a human browsing a course catalog, an admissions officer reading a transcript, or an HR clerk scanning a resume. That layer is shifting to agents. As software agents increasingly mediate discovery, routing opportunities, matching candidates to roles, and assembling trusted contexts, the unit of discovery changes. A credential that an agent cannot resolve — because it is a PDF, an opaque wallet display, or a brand with no machine-readable claim — is invisible to the layer that increasingly mediates discovery. Invisibility here is not a UX problem; it is a structural non-existence.

This piece is the learn-side companion to the thesis that catalogs built for human browsing are invisible to agents. The strategy layer maps the market break: agents don’t browse your course catalog, so your catalog-dependent discovery is failing. The protocol reasoning, which belongs here, is what makes a credential agent-legible. If a credential is not legible to agents, it will not be discovered by the layer that matters.

The shift: from catalog browsing to programmatic resolution

Historically, credential discovery required a human to translate a document into a mental model of trust. A hiring manager reads a degree on a resume, recognizes the university’s brand, and assigns a rough trust weight based on institutional reputation. The credential is a signal, but the discovery and validation are human-mediated cognitive processes.

The agentic web dissolves this human bottleneck. Agents route queries, match profiles to opportunities, and assemble trusted contexts at machine speed. They do not read resumes; they parse claims. They do not rely on institutional brand; they resolve cryptographic signatures. When an agent evaluates a candidate for a high-trust task, it needs to verify the competencies claimed. If the credential asserting those competencies is a PDF on a server, the agent cannot read it without a brittle OCR pipeline. If it is an opaque display in a proprietary wallet, the agent cannot extract the claim. If it is a brand assertion with no machine-readable proof, the agent has nothing to resolve.

A credential that an agent cannot resolve is invisible. Not metaphorically, but structurally. The agent’s context window or reasoning loop will never include it. In the agentic discovery layer, if you are not legible to the resolver, you do not exist.

What “agent-legible” concretely requires

Agent-legibility is not a vague aspiration for “machine-readable” data. It is a specific protocol bet. A credential that an agent can resolve has, at minimum, five structural properties. A credential missing any of them is partially invisible — the agent either cannot verify, cannot check freshness, cannot see evidence, or cannot parse the claim.

1. A resolvable issuer identity. The agent must be able to verify WHO signed the credential. This requires a Decentralized Identifier (DID) or a resolvable public key. The agent resolves this identifier to retrieve the public key needed to verify the signature. Without a resolvable issuer identity, the agent has no cryptographic anchor for the claim. It cannot distinguish a legitimate credential from a fabricated one.

2. A signed verifiable credential. The credential must be a cryptographic proof that the claim is the issuer’s and unaltered. This is the verifiable credential (VC) spec in practice: a payload signed by the issuer’s private key. The signature guarantees provenance and integrity. Issuer identity and custody are the hard parts of this equation. If the issuer’s key management is opaque, the signature is technically valid but practically untrustworthy. (Why we didn’t use a blockchain covers the custody half.)

3. A live revocation endpoint. An agent must be able to check, in real time, whether the credential is still valid. A credential signed five years ago might have been revoked yesterday. The agent needs a live revocation endpoint — often implemented via a status list, such as the W3C Bitstring Status List — to verify that the credential has not been revoked or suspended. Without this, the agent is forced to rely on stale trust, accepting the risk that the credential no longer represents a valid claim.

4. Evidence pointers. A credential is a claim, but agents increasingly need to inspect what the claim actually attests. Evidence pointers are links to the work, assessment, or artifacts that back the claim. If a credential asserts competency in a specific protocol, the evidence pointer links to the assessment results or the validated artifact. An agent evaluating a candidate for a high-stakes task will weigh the evidence. If the credential is just a bare assertion with no evidence pointers, the agent has no way to inspect the substance of the claim, limiting its ability to trust the credential in complex resolution scenarios.

5. Machine-readable semantic structure. The credential’s claims must be structured in a way an agent can map. This means competency alignment using shared vocabularies or schemas, not prose a human has to read. The agent needs to know that “Proficient in Rust” maps to a specific node in a competency graph. If the credential is a blob of unstructured text, the agent cannot reason over it. Semantic structure allows the agent to compare competencies across different issuers, assemble complementary skill sets, and map the credential to the requirements of a task.

These five properties — resolvable issuer, signed VC, live revocation, evidence pointers, and machine-readable semantics — are the agent-legible protocol. A credential missing any of them is partially invisible.

Why this is a protocol bet, not a feature

You do not “add agent discoverability” to a credential the way you add a feature to a software product. Agent-legibility is a property of the credential’s design from issuance forward. The issuer either emits a resolvable, signed, revocable, evidence-linked, machine-readable credential, or does not.

Retrofitting agent-legibility onto a credential that was issued as a PDF or a proprietary-wallet display is impossible. The provenance was not captured at issuance. You cannot cryptographically sign a credential after the fact and have that signature mean anything, because the signature must come from the issuer at the moment of attestation. You cannot attach live revocation to a static PDF. You cannot inject semantic structure into a visual display. The protocol must be baked into the issuance pipeline.

The bet is to design for agent-legibility now. The credential issued today will be discovered by agents tomorrow. The agentic discovery layer is not a distant theoretical construct; it is assembling in real time as agents gain the ability to query, resolve, and reason over structured data. A credential that cannot be discovered by agents in an agent-mediated discovery layer is a credential that effectively doesn’t exist for the layer that matters. Issuing a credential today without the agent-legible protocol is issuing a credential into a void.

The receiver-side dependency

Agent-legibility is necessary but not sufficient. A credential can be perfectly agent-legible and still not be discovered if no agent infrastructure resolves it. The protocol bet requires both sides.

The agent-legibility described above is the supply-side (issuer) half. The issuer has emitted a credential that satisfies the five requirements. But the adoption graph breaks at the receiver. Here, the agent is a specific kind of receiver, and agent-legibility only matters if agents actually resolve the credential. That requires the resolver and verification infrastructure to exist on the demand-side.

An agent must have a mechanism to discover the credential’s existence, query the wallet or holder, resolve the issuer DID, verify the signature, check the revocation endpoint, and parse the semantic structure. If the agent layer does not implement these resolvers, the credential remains invisible — not because it lacks cryptographic integrity, not because the issuer is unknown, not because the semantic content is missing, but because nothing in the receiver layer resolved it into the agent’s working context.

This is the two-sided dependency that makes agent-legibility a protocol bet rather than a one-sided design choice. The supply side: issuers must emit credentials with resolvable issuer identity, signed VCs, live revocation endpoints, evidence pointers, and machine-readable semantic structure. The demand side: the resolver and agent layer must actually query, fetch, verify, and act on those credentials. Either half alone leaves the credential invisible. A perfectly agent-legible credential sitting in a wallet that no agent infrastructure resolves is functionally equivalent to a PDF in a filing cabinet — structurally sound, semantically complete, and operationally absent from the discovery layer.

The agent is a specific kind of receiver. When we argued in verifiable credentials as protocol that the adoption graph breaks at the receiver — that the value of a verifiable credential depends on someone being willing and able to verify it — that argument applies with particular force here. Agents are not generic receivers. They are receivers that operate at machine speed, with no human in the loop to compensate for illegibility. A human verifier can look at a PDF credential, squint at the issuer logo, click through to a website, and make a judgment call. An agent can’t. An agent either resolves the credential through its available interfaces or it doesn’t. The adoption-graph break becomes a hard structural boundary, not a soft friction.

This means the protocol bet is genuinely two-sided. Issuers who invest in agent-legible credentials are betting that the resolver and agent layer will mature to meet them. Agent infrastructure builders who invest in credential resolution are betting that issuers will emit credentials worth resolving. Neither side can deliver the discovery layer alone. The credential that an agent can’t resolve is invisible; the agent that has no credentials to resolve is useless. The protocol succeeds when both halves are built to the same contract — the five properties on the supply side, the resolution and verification infrastructure on the demand side.

The honest caveat

The agent-mediated discovery layer is still forming. There is no agreed agent-to-credential protocol. Agents’ reliability at evaluating credentials is uneven, and the agent space itself is volatile — frameworks, vendors, and interface standards shifting month to month. (The broader caveat about the discovery layer’s immaturity was laid out in the discovery-layer-breaks piece; I won’t repeat it here.)

The bet is directional, not prescriptive. You don’t know whether agents will query credentials via W3C DID resolution, a marketplace API, an agent plugin schema, or some agent-framework standard that doesn’t exist yet. You don’t know whether the verification call will be a DID resolution, an HTTP GET to a revocation endpoint, or a GraphQL query against a credential registry. What you know is this: whatever the interface, it needs a resolvable issuer, a verifiable signature, freshness, evidence, and machine-readable semantics. Those five properties are the invariant layer. They’re portable across any plausible wire format, any agent framework, any resolution mechanism the ecosystem converges on. Build the invariant; stay portable on the variable.

But don’t pretend the exact interface is settled. Don’t pretend agents reliably resolve credentials today. Don’t pretend that emitting an agent-legible credential guarantees discovery — it doesn’t, because the demand side may not exist yet. What it guarantees is that when the demand side arrives — when a resolver queries for issuer identity, when an agent fetches the revocation status, when a verifier follows the evidence pointer — the credential is there, legible, resolvable, and ready. The credential that wasn’t built agent-legible at issuance can’t be retrofitted. The PDF can’t grow a revocation endpoint. The opaque wallet blob can’t sprout evidence pointers. Legibility is a design property from issuance forward, or it isn’t there at all.

Coda

A credential not legible to agents is invisible — structurally, not metaphorically. Not hard to find, not slow to discover, not poorly ranked. Invisible. Absent from the working context of the layer that increasingly mediates discovery, because that layer has no interface through which to resolve it.

Build the agent-legible protocol: resolvable issuer, signed VC, live revocation, evidence pointers, machine-readable semantics. Build the receiver-side resolver and agent layer that resolves it. Or accept that the credential won’t be discovered by the layer that increasingly mediates discovery.

The protocol bet is to design for agent-legibility at issuance, because you can’t retrofit visibility onto a credential that was never legible. You can add a revocation endpoint to a credential that was designed to have one; you can’t add one to a credential that wasn’t. You can point an agent at a semantic structure that exists; you can’t point it at one that doesn’t.

In an agent-mediated discovery world, legibility is existence.