Open specification

Kinetic Gain Protocol

Attach signed, hash-reproducible provenance to any web claim, in a form search crawlers and answer engines can verify and follow back to a named standard.

v0.1 · draft MIT spec ed25519 + sha256

Verify a claim → Quickstart → Use cases → Machine manifest → llms.txt → Signing key →

What it is

The Kinetic Gain Protocol (KGP) is not a new format. It is an open, versioned conformance profile, a lockfile over a small set of pieces, that lets any website say, in one machine-verifiable way, "the claims on this page carry reproducible, signed provenance conforming to a published standard," and make every conformant page point a crawlable edge back at this canonical spec.

KGP unifies three things into one profile: the AI Evidence Format (the evidence object), the Evidence Bundle manifest, and ed25519 signing published under /.well-known/, a pattern Kinetic Gain already runs live at /.well-known/kg-pubkey.json (key kg-2026-06).

The problem it solves

Answer engines and search crawlers cannot tell an authored, accountable claim from synthetic filler. A page that emits a KGP evidence object gives a machine three things at once: a content hash it can recompute to confirm the exact text, an ed25519 signature proving which entity stands behind it, and a conformsTo pointer to a named standard. That is a verification path, not just an assertion. The incentive to adopt is self-interested: your own claims become more citable and more defensible. The link back to this spec is a byproduct of that, not the pitch.

Conformance levels

Level 1

Attach

A machine-readable evidence object accompanies the claim, with a schema.org conformsTo edge to this spec.

Level 2

Verify

The evidence object carries a reproducible sha256 content hash of the exact claim text.

Level 3

Sign

The content is ed25519-signed over the RFC 8785 canonical form; the public key is published under the site's /.well-known/.

A minimal, verifiable example

The content hash is a plain sha256 of the exact claim text, so anyone, human or machine, can reproduce it. This example is real:

$ printf '%s' 'The Eiffel Tower is 330 metres tall.' | sha256sum
→ 22d55b4f4a196374a8444337fc5005edc190b7724912c00e0ecf7b5c22201e67

A conformant page emits the claim's provenance as JSON-LD plus an evidence object:

<link rel="describedby" href="https://acme.example/.well-known/kgp/index.json">

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "CreativeWork",
  "conformsTo": { "@id": "https://kineticgain.com/protocol/kgp/0.1.json" },
  "publisher": { "@type": "Organization", "name": "Acme Inc", "url": "https://acme.example" },
  "text": "The Eiffel Tower is 330 metres tall.",
  "subjectOf": { "@type": "WebPage", "url": "https://kineticgain.com/protocol/" }
}
</script>

<script type="application/ai-evidence+json">
{
  "evidence_version": "0.1",
  "claim_text": "The Eiffel Tower is 330 metres tall.",
  "verification": {
    "content_hash": "sha256:22d55b4f4a196374a8444337fc5005edc190b7724912c00e0ecf7b5c22201e67",
    "signing_key_uri": "https://acme.example/.well-known/kgp/pubkey.json",
    "signed_by": "acme.example"
  }
}
</script>

How it gets found and followed

Every conformant page creates several crawlable, machine-followed references to this canonical spec, layered so no single one is load-bearing:

conformsTo edge — a schema.org property in JSON-LD pointing at kgp/0.1.json. A semantic edge crawlers resolve, not a decorative link.
<link rel="describedby"> — in the page head, to the site's own /.well-known/kgp/, whose spec field is this URL.
A visible badge — a human-readable "verified with the Kinetic Gain Protocol" mark that links here, earned because the page genuinely conforms.
subjectOf / sameAs — on the CreativeWork, a third path through the entity graph.

The badge and the verifier are hosted here, so every adopter's verification action resolves to this canonical URL. This is the ordinary way an open standard spreads, publish the reference implementation, host the validator, own the canonical URL, applied honestly.

The badge

A "Verified with Kinetic Gain Protocol" badge is CSP-safe (inline SVG, no third-party script, no tracking pixel), links back here, and is backed by a real signature, not a vanity graphic: it is emitted only from a valid, signed evidence object, and a public verifier checks the ed25519 signature. If it does not verify, the verifier says so. The badge never says "certified" or "trusted." It says evidence present, signature valid, here is how to check.

Embed it with a real backlink (adopters who genuinely conform):

<a href="https://kineticgain.com/protocol/" rel="noopener">
  <img src="https://kineticgain.com/protocol/badge.svg"
       alt="Verified with the Kinetic Gain Protocol" width="222" height="38">
</a>

Use the verifier → to recompute a claim's content hash and confirm it matches its evidence object, entirely in your browser.

Versioning and governance

Profile: KGP/0.1 · canonical id https://kineticgain.com/protocol/kgp/0.1.json, frozen, never rewritten · SemVer · editor Miz Causevic · steward Kinetic Gain LLC. Superseded versions stay served with status: superseded, never deleted, because a dead canonical URL breaks every page that linked it. The profile pins exact component versions, so a component bump forces an auditable profile bump.

How KGP differs from adjacent standards

KGP does not replace C2PA (media provenance), sigstore / SLSA (software artifacts), or schema.org ClaimReview (fact-check claims). Those are real, larger standards for their domains. KGP's niche is the web-discoverable, schema.org-tied, badge-linked evidence layer for arbitrary web claims, self-hostable via /.well-known/, human-readable and answer-engine-citable.

Honest status. KGP is a draft. Reference implementations across the Kinetic Gain estate are rolling out. There are no external adopters yet, and this is an open specification with reference implementations, not an established industry standard. Signatures prove who stands behind a claim, not that the claim is true: KGP makes dishonesty detectable, not impossible. It is tamper-evident, not tamper-proof, and it never asserts "certified" or "compliant."

Implement it

The quickstart has copy-paste blocks for static HTML, WordPress, and Webflow. The short version: publish an ed25519 key at your /.well-known/kgp/pubkey.json, emit an evidence object per claim at the level you can support, add the conformsTo edge and the badge. Reference implementations and a public verifier are being published under the Kinetic Gain GitHub org. Start from the machine manifest and the llms.txt. See the use cases for where each conformance level fits, with the level each scenario needs.