The protocol, not the product.

This week we rewrote our whitepaper. Version 2 lands today. The change looks structural on the surface. It is actually a positioning shift we should have made six months ago.

What changed

Whitepaper v1 opened like this:

Themisra is a sovereign blockchain purpose-built for AI provenance.

Whitepaper v2 opens like this:

Ligate Chain is a generic, permissionless attestation protocol. Themisra is the first flagship application built on top of it.

Those two sentences describe exactly the same code. They describe very different products.

Why it matters

The old framing made Themisra the hero. The chain was instrumental, justified by Themisra's existence. Which is fine, until you ask the question every investor asks eventually: what if Themisra doesn't work?

The honest answer under v1 was: then the chain doesn't work either, and $LGT is worth nothing. That is a bad answer. It is a bad answer because it is true, and it is true because we had built a product-chain, not a protocol-chain. Rewriting the whitepaper forced us to confront the difference.

What Ligate Chain actually is

It is a sovereign rollup (Sovereign SDK on Celestia) with exactly one application module in v0: attestation. That module exposes three primitives:

1. Register a schema, the shape of an attestation: who owns it, what it is called, which signers can sign under it, how fees route.
2. Register an attestor set, a quorum of M-of-N signers, immutable once registered.
3. Submit an attestation, a signed payload hash bound to a schema. Write-once per (schema_id, payload_hash), so replay is structurally impossible.

That is the whole protocol. Chain stores only hashes and signatures, never plaintext. The module does not know about AI. It does not know about Themisra. It does not privilege any schema over any other.

Themisra is a consumer of that protocol. It registers exactly one schema (themisra.proof-of-prompt/v1), operates the first attestor quorum, and ships SDKs in TypeScript and Rust. A third party could ship a competing Themisra tomorrow by registering their own schema with their own quorum. We win by being the default, by shipping the best SDK, and by operating the most trusted quorum. Not by closing the gate.

Why this matters for AI

Every AI interaction today is invisible. A ChatGPT response, a generated image, a model's training data, an autonomous agent placing a trade. None of it comes with a cryptographic record of what happened, with which model, under whose authority.

At small scale that was tolerable. At the scale AI is reaching in 2026 it is not. The EU AI Act is live. US disclosure mandates follow. Creators want attribution. Regulated industries deploying agents need defensible audit trails.

Every AI-generated artefact will eventually need a receipt. That receipt is a small data structure: who generated it, when, with which model, under whose authority, signed so it cannot be repudiated. Receipts compose into audit trails, royalty claims, regulatory filings.

Building this as a single closed product would re-fragment a market that benefits from openness. Anthropic, OpenAI, enterprises, regulators, creators, and thousands of downstream AI applications all have different attestation shapes. What is shared is the primitive: a signed, timestamped, on-chain record that someone authorised claims something happened.

That primitive is what Ligate Chain supplies. That, and nothing more.

What changes for builders

Under the old framing, "building on Ligate" meant building inside Themisra. Under the new framing, "building on Ligate" means registering your own schema and attestor set, then calling SubmitAttestation from your app. In ten lines. Your schema can describe anything:

• Subscription events (Kleidon does this)
• AI agent actions (Iris does this, via an MCP server)
• Research-agent source citations
• Autonomous-trade evidence
• Medical AI decision logs
• Content pipeline transformations

We do not need to approve your schema. We do not need to host your attestor set. We do not take a cut beyond the standard per-attestation fee, and you can route up to 50% of that fee back to yourself. The protocol is permissionless the way Ethereum is permissionless.

Three flagships, one substrate

Three applications ship alongside the protocol to prove the primitive is enough.

• Themisra, Proof of Prompt. AI provenance for humans using AI.
• Iris, MCP server + USD-billed relayer. Attestation for autonomous AI agents. Plugs into Claude Desktop, Cursor, LangGraph, OpenAI Agents SDK.
• Kleidon, Web3 SaaS suite. Subscriptions, gaming assets, tokens, marketplaces.

They all use the same attestation module. None of them is baked into the protocol.

What $LGT actually captures

Because the protocol is permissionless, any third-party schema pays the same fees that Themisra, Iris, and Kleidon pay. Every attestation in the ecosystem, across every app, accrues fee revenue to the same token. If Themisra underperforms but Kleidon wins, $LGT value accrues. If a third-party schema outgrows all three flagships, $LGT value still accrues.

The token is not a claim on a single product. It is the settlement asset for a category.

The honest part

Rewriting the whitepaper meant admitting we had been selling the narrower story. The narrower story was easier to tell. A product-chain is legible to investors: "a blockchain that does AI receipts." The broader story is harder on the pitch: "infrastructure that makes AI receipts a composable primitive." But it is more honest, and it is durable in a way the narrower version was not.

We are pre-launch. Devnet targets 2026. Every number in the whitepaper is an intention, not a metric. We are not here to claim victory on something we have not shipped. We are here to say: here is the thing, specified. Come build on it.

Read the whitepaper. Watch devnet. Email us if you want to talk about a schema you want to register.