Trust isn’t a schema field: how machines decide to believe you

You cannot declare that you are credible in markup. A retrieval system infers it from signals it collects about you across the web. Let’s look at the mechanism.

Most practitioners get trust wrong in exactly the same way, and the mistake costs them every time they try to optimise for AI-powered retrieval. They treat trust as something you say. Add industry-leading to the homepage, set the schema job title to AI expert, write a confident About page, and assume the machine reads all of it as evidence. It does not. It reads it as self-assertion, which is to say, as evidence of nothing.

Here is the fact that reorganises everything. The number of schema properties that directly declare trustworthiness to a retrieval system is zero. Not one. And this is not an oversight in the vocabulary that someone will patch in a later version. It is correct design, because self-declared trust cannot be verified, and a value that cannot be verified is worthless to a system trying to decide how much weight to give your claims.

So if trust is not a field you fill in, what is it? It is a probability. A retrieval system is quietly estimating one number about your entity: given everything I have indexed about this source, how likely is it that a claim attributed to it is accurate, unambiguous, and safe to cite? Your job is not to assert credibility. It is to make the signals that already exist about you coherent, numerous and consistent, so that estimate comes out higher. Let’s dive into how the number is actually computed.

Three signal categories, and their weights are not equal

The probability is derived from three independent categories of signal, and the distinction between them is the whole game. First, structural signals: your schema, your type declarations, your ID, your sameAs links, the entity relationships expressed in JSON-LD. These are medium weight — necessary, but not sufficient on their own. Second, corroboration signals: third-party sources independently referencing your entity with a consistent name, role and attributes. Crunchbase, Wikidata and a trade publication all describing the same company with the same founding date. This category carries the highest weight, because cross-source agreement is the strongest evidence of accuracy a system can find.

Third, behavioural signals: publication history, topic consistency, recency, authorship patterns. An author who has published on one topic for three years and is linked from domain-relevant sites builds a behavioural trace. Medium weight, and it has a temperament — it accrues slowly and it degrades with inconsistency. When evidence converges across all three categories, confidence rises. When the signals disagree, confidence falls, and the system simply selects a different source. That last clause is the one to sit with: your competitor does not need to beat you, you only need to be ambiguous enough to skip.

The asymmetry: what you say weighs almost nothing

There is a fundamental asymmetry in how systems treat what you say about yourself versus what others say about you, and it maps exactly onto Google’s E-E-A-T. A page that calls its author an industry expert tells the system nothing it can check. A Wikipedia entry, a conference speaker bio, or a citation in a Reuters article making the same claim from an independent source is weighted substantially higher. Same claim, radically different weight, purely because of who is making it.

Which gives you one clean test to run on every claim that matters: is there an independent, indexable source that says the same thing? If the answer is no, the claim produces a low-confidence signal regardless of how beautifully it is marked up. Consider Dr Sarah Voss, whose schema announces her as a leading authority on supply chain risk. The system checks: does a person entity for her exist in an indexed knowledge graph, do third-party sources independently attribute that expertise to her, is her publication history consistent with the claim? If the external record shows a single article published once in 2019, the confidence is very low, and no amount of schema rewriting moves it. The schema is not the evidence. It can only be a pointer to evidence that has to exist somewhere else.

This is why I tell people to stop spending on language and start spending on records. Speaking at a documented conference with a published programme builds authority. Being cited by name in trade press builds it. A Wikidata entity with occupation declared, a LinkedIn profile with verified employment, a Crunchbase or ORCID entry — all build it. Updating your own schema with a more impressive title, adding expert to your bio, linking your own pages to each other, posting testimonials on your own site: none of these produce independent corroboration, and some actively signal inconsistency if they contradict a record that already exists.

Depth of corroboration beats breadth of declaration

Here is the sentence I would tattoo on a whiteboard if I could. A single well-corroborated attribute — a founding date confirmed by three independent sources — is worth more to a confidence score than twenty uncorroborated schema properties. Depth of corroboration beats breadth of declaration. The practical consequence is a reordering of your effort: get a small number of your most important factual claims confirmed by outside sources before you spend another hour adding properties no one else can verify.

Two more things follow from the mechanics, and both surprise people. The first is that authority does not transfer. It is contextual, a set of separate confidence estimates each attached to a specific topic. General organisational prestige does not carry into a new domain. Take one organisation across four topics: in semantic SEO, seven years of history, conference records, a Wikidata entry, industry citations — high confidence. In AI in marketing, two years and some mentions but no domain database — medium. In sustainability, four articles and no third-party citation — low. In cryptocurrency, no trail at all — effectively zero, treated as a brand-new entrant. Same organisation, four honest estimates, all computed correctly. Three deep topic trails outperform fifteen shallow ones.

The second surprise is that contradictions cost more than gaps. A missing founding date is neutral — the system notes an absence and moves on. But a founding date that reads 2011 in your schema, 2013 in a press release and 2012 on LinkedIn is an active conflict the system cannot resolve, so it drops the attribute from high-confidence status entirely. Pair that with employee counts of 320, over 200, and 51–200, and every attribute on the entity falls at once. Gaps are neutral. Contradictions are negative signals. The fix is unglamorous and permanent: one audit pass to align the unchanging facts character-for-character everywhere, and ranges expressed as QuantitativeValue for the facts that genuinely change, so 150 to 250 employees cannot conflict with over 200 in prose.

Trust is checked again at query time

Everything so far concerns confidence built at indexing time. But there is a second moment, and it catches weak signals that survived the first. When an agent retrieves your content in answer to a query, it does not simply fetch the top-ranked page. It assembles several sources in one session and cross-checks specific claims against each other. This is inference-time verification, and it is where uncorroborated self-assertion finally gets caught.

The worked example is a CRM comparison. The agent fetches vendor pages and independent reviews. The vendor’s own page (source A) says pricing starts at €12 per user per month, suited for teams under 200. An independent review (source B) says €12 per user, for teams of 10 to 50. A competitor page (source C) says €19. The cross-check fires: A and B independently agree on €12, so that claim survives with high confidence; C disagrees but has a conflict of interest, so it loses. But under 200 appears only on the vendor’s own page — source B says 10 to 50 — so that claim is not corroborated and drops. The synthesised answer states €12 per user per month with confidence and describes the product as suited for small teams, with no employee ceiling, because the vendor’s own sizing claim did not survive.

The lesson is direct. Claims that appear only on your own pages are treated as unverified self-assertion. Claims that appear identically on independent sources survive. This is why getting your pricing, sizing and capability claims onto third-party review sites matters — not for the backlink, the backlink is irrelevant to this mechanism, but because an independent indexable source now contains the same specific value, and the agent can retrieve it in the same session. And corroboration cannot be rushed. It has to already exist when the query fires.

Run the corroboration self-test today

You can run the diagnostic yourself in an afternoon, and it is uncomfortable in a useful way. Pick your three most important factual claims — price, use-case fit, company size, founding year, whichever ones you would hate an AI answer to get wrong. Search each one. Count how many independent, non-promotional sources confirm the exact same value. If the answer for a claim is zero, that claim will be qualified or dropped in generated responses even if it is completely accurate, because accuracy is not sufficient. Corroborated accuracy is what survives the cross-check.

That test tells you where you stand. It does not, on its own, tell you the order in which to fix things, and the order matters more than people expect — structural fixes that show up at the next crawl come first, external alignment that only moves the Knowledge Graph API score comes second, and each entity you are recovering needs its own tracked trail over three to six months. That sequencing, with the phased tracker and the Knowledge Graph API score as a leading indicator, is what I walk through in the course. Once you internalise that trust is computed rather than declared, the whole optimisation problem changes shape — you stop writing about yourself and start engineering the record other people can see. If you want the neighbouring pieces, consistency beats completeness covers why consistency beats completeness in your structured data, and robots.txt, the silent killer of AI traffic covers the infrastructure that lets an agent read you at all.