The end of landing pages

>_GET /blog/the-end-of-landing-pages

Once Blake knows that Sam is really Sam, the next question is the obvious one: what does Sam actually do? Today the answer lives on a landing page, a document built to persuade a human. Headlines, a hero image, three logos, a "trusted by 5,000 teams" bar, and a button that says Book a demo. None of it survives contact with an agent.

A landing page is an argument. It is designed to move a person from doubt to desire. Blake does not have doubt or desire. It has a brief, a budget, and a mandate it has to answer for. So the page that wins Sam a human customer feels, to Blake, like an empty room. Better copy will not fix that. Blake needs a different kind of object entirely.

The manifest is that datasheet: a signed, machine-readable description of what the product does, with what parameters, under what limits, and with what proof. This post is about what goes inside it, why one section is the real bottleneck, and how Blake turns it into a yes or a no.

What OpenAPI and schema.org leave out

The temptation is to say "we already have this." We do not. We have the layers above and below it:

• OpenAPI / Swagger. Describes how to call an API: endpoints, types, auth. It says nothing about business value. It is the layer below the manifest.
• schema.org Product. Describes a product for search engines and humans. Its job is rich-result rendering; buyer-agent evaluation needs a different layer.
• llms.txt. A thin hint for models reading a page. Useful, but it is a pointer, not a spec.

A fair follow-up: if models read markdown so well, why is the manifest JSON at all and not another .md file? Because a manifest is a set of commitments, not a text to comprehend. A claim has to be signable, measurable, and disputable, and a sentence is none of those. The boundary between the two layers gets its own cross-cut: A sentence can't be signed.

There is a sharper version of this objection: we didn't just have pieces of this, we tried the entire vision. The Semantic Web promised a machine-readable web twenty years ago, RDF and ontologies included, and it went nowhere. But look at why it died. It asked millions of publishers to mark up data for a reader that did not exist, while the reader that did exist, Google, rewarded human-readable pages instead. The incentive loop never closed. This time the order is reversed: the machine reader arrives first, carries a budget, and rejects whoever it cannot parse. And the part that made ontologies brittle, the long tail no schema ever covers, is exactly the part an LLM can now bridge. The Semantic Web didn't fail because the schemas were bad. It failed because there was nobody to read them.

The capability manifest fills the missing middle layer: what the product does in business terms, with which parameters and limits, and with evidence attached. It points down to OpenAPI ("here is how to call it") and up to identity ("here is who signed it").

What is actually inside

Strip away the framing and a manifest is a few blocks that each answer a question Blake is already asking:

{
  "manifest_version": "2.1",
  "issuer": "did:web:sam.example",
  "updated": "2026-07-01T10:00:00Z",
  "capabilities": [
    {
      "id": "workflow_automation",
      "inputs": ["documents", "webhooks", "api_events"],
      "outputs": ["structured_records", "actions", "audit_logs"],
      "languages": ["en", "de", "pl"],
      "regions": ["EU", "US"]
    }
  ],
  "claims": [
    {
      "metric": "extraction_f1_en",
      "value": "0.90",
      "definition": "F1 of field extraction vs a human-labeled set of 5,000 docs",
      "status": "self-asserted",
      "verify": "https://sam.example/.well-known/sandbox?test=extraction"
    },
    {
      "metric": "soc2_type2",
      "status": "attested",
      "attestor": "did:web:auditor.example",
      "proof": "vc://soc2-2026"
    }
  ],
  "does_not": ["video_analysis", "on_prem_deployment"],
  "pricing": "https://sam.example/.well-known/pricing.json",
  "fit": "https://sam.example/.well-known/fit"
}

It is signed by the key from the identity layer>_Identity chainFive linked questions: domain control, legal entity, delegation, session authenticity, mandate and scope.defined in Are you really you? →, so Blake knows the manifest is authentically Sam's and not a forgery. The capabilities say what Sam does, in typed fields. The claims carry the numbers, each one tagged with how it can be checked. The does_not block draws the boundary. And fit and pricing point to the next two layers. Three things inside this look small and are not.

A shared vocabulary, or nothing compares

The manifest is useless if workflow_automation, structured_records, and extraction_f1 do not mean the same thing to Blake as they do to Sam. If every vendor invents its own words, Blake cannot compare anything. It sees incompatible dialects where a market needs shared terms.

So the id of a capability has to come from a shared, open taxonomy per industry: something like schema.org, but for capabilities, maintained by industry consortia. In practice it will be a mix:

• A core ontology. A shared vocabulary for a category (say, "document intelligence"), so the same word means the same measurement everywhere.
• Vendor extensions. Custom fields for the long tail a standard never covers.
• Semantic reconciliation. An LLM maps "their" terms onto "mine" for the edges. It is fuzzy and risky, so Blake treats it as a fallback, never the foundation.

This is the bottleneck of this layer. The format is the easy part; agreeing on what the words mean is the hard part, and without it the whole machinery of agent-to-agent buying does not compose. Who governs that vocabulary, and what an agent should do with a word that resolves against no dictionary? That turned out to be a big enough question to earn its own post: Who owns the words?

"Self-asserted" and "attested" are not the same word

A manifest is a claim by the vendor. On its own it is worth exactly as much as a promise. So every claim has to carry its proof status, and Blake weights the two very differently:

• Self-asserted. Sam says so. Blake treats it as a hypothesis to test in the sandbox, hence the verify link. Measure, do not believe>_Measure, don't believeEvery claim is a hypothesis until tested — the operational rule of the whole stack.defined in Measure, don't believe →.
• Attested. Backed by a signed credential from a third party: an auditor, a vLEI issuer. Here Blake can trust on sight, because the signature chains back to the identity layer from the previous post.

This split is what lets Blake trust hard facts (compliance) while empirically checking soft promises (performance). A claim with no status is treated as the weakest possible self-assertion, or ignored.

The negative space sells

The does_not block looks like an admission of weakness. For Blake, it is the most valuable section, because it lets it reject fast. If the company needs video analysis and the manifest plainly says does_not: ["video_analysis"], Blake is gone in milliseconds. There is no conversation, no trial, and no wasted sandbox.

A vendor that hides its limits does not look stronger. It looks expensive to evaluate, and it loses trust the moment Blake discovers the gap in a sandbox instead of in the manifest. Honest boundaries are a gift: they save both agents time, and saving Blake time is how Sam earns the first sliver of trust.

How Blake reads it

End to end, consuming a manifest is fast and mechanical:

1. It fetches the manifest and verifies the signature against Sam's did:web>_did:webGET /.well-known/did.jsonThe cheapest identity rung — recycle TLS and domain trust into a resolvable agent key.defined in Are you really you? →, so it can verify that the document really came from Sam.
2. It runs a hard filter on does_not and on parameters against the company's must-haves, and eliminates Sam immediately if something critical fails.
3. It maps capabilities through the shared ontology onto the brief.
4. It separates attested claims from self-asserted ones, accepting the first, queueing the second for measurement.
5. It hits the verify links and tests the self-asserted claims on the company's own data.
6. It follows fit and pricing to the next layers.
7. It keeps the manifest version and watches the change feed, because it does not buy once. It monitors.

The tension: manifests will be gamed

The moment manifests rank in registries, vendors will write them for the algorithm, not the truth: AEO-spam, the SEO of the agent era. Capabilities get padded, claims get inflated, and the negative space quietly shrinks. The defense is the same one that runs through the whole stack: measurable claims plus sandbox verification plus a reputation penalty for any gap between what was declared and what was measured, the claim-versus-measurement gap>_claim_vs_measured gapThe delta between what Sam declared and what Blake measured — honesty as a meta-signal.defined in Reputation as capital → that feeds reputation. A claim Blake cannot check is a claim it discounts.

The second tension is freshness. A manifest is not carved in stone: products change, a language gets dropped, retention shrinks. So it carries a version, an updated timestamp, and ideally a change feed. Blake does not re-read everything on every visit. It watches for diffs, and a meaningful change (a limit tightened, a claim lowered) triggers re-evaluation on its own.

Bets worth placing

A manifest is a bet you can hedge: publish it beside the landing page, not instead of it. It costs a schema and an afternoon, and it doubles as documentation a human can read. If you run the experiment, two rules from this post are worth keeping even as hypotheses: tag every claim with a proof status and under-promise the self-asserted ones. A positive surprise compounds while a negative one destroys. Fill does_not generously, because the fastest thing an agent can do with you is leave correctly. The speculative end of the layer is the shared vocabulary: someone will steward the schema.org of capabilities, and whoever does owns a chokepoint. Taxonomies, manifest validators and registries, semantic reconciliation for the long tail, and generate-sign-version tooling are all still empty chairs.