The Registry
One signed JSON manifest per model: who made it, what license it carries, where it sits in the lineage, and where to pay. That's it. No dashboards, no earnings calculators, no accounts — the manifest is the entire compliance surface.
Current registry state
Read directly from the signed static registry at /registry/v2/index.json, verified in your browser against OMLA's pinned Ed25519 key before anything below is trusted.
The index is not the source of truth
Worth being clear about, because it decides whether any of this works before OMLA is well known: the manifest is the artifact, and it is self-contained. A creator signs one and publishes it next to their weights. A commercial user reads it, checks the signature, runs the resolver, and pays the wallets named in it. Nothing in that loop requires this page, an account, or a network call to OMLA.
What the index adds is convenience and tamper-evidence: one signed, sequenced file listing every manifest submitted, so you can find them in one place and prove none was quietly edited. Useful — but if it vanished tomorrow, every published manifest would keep working exactly as before.
Consequence worth stating plainly: a model that has no OMLA manifest carries no OMLA obligation. This license is opt-in, and it makes no claim over open models that never adopted it. See what a commercial user does about models with no manifest.
The manifest
Roughly twenty fields, signed end to end. A commercial user's lawyer checks three things: is the license real (license_uri), who created this (signature, key_fingerprint), and where does the money go (payee pointers).
{
"id": "<uuid>",
"name": "ExampleLM-7B",
"description": "One-line summary from the creator.",
"source": "https://huggingface.co/example/ExampleLM-7B",
"created_at": "2026-07-01T00:00:00Z",
"license_version": "OMLA-PL-2.1",
"license_uri": "https://omla-ai.org/license.html",
"sig_algorithm": "ed25519",
"public_key_b64": "<creator Ed25519 public key, base64>",
"key_fingerprint": "sha256:<sha256 of algorithm || public key>",
"manifest_hash": "<sha256 hex of the canonical payees + split>",
"signature": "ed25519:<signature over the OMLA-MANIFEST-v1 message>",
"weight_hash": "sha256:<hash of the published weight artifact>",
"lineage": [
{ "parent_id": "<uuid of parent model, if any>", "relationship": "fine-tune" }
],
"split": {
"retain_bp": 500,
"upstream": [
{ "parent_id": "<uuid>", "share_bp": 9500 }
]
},
"generation_weight_bp": 10000,
"safety_certifications": {
"no_harmful_use": true,
"not_for_minors": true,
"no_csam": true,
"safety_tested": true
},
"payees": [
{
"address": "omla1<bech32m-encoded wallet>",
"share_bp": 10000,
"pointers": [
{ "rail": "lightning", "value": "alice@getalby.com" },
{ "rail": "btc", "value": "bc1…" }
]
}
]
}| Field group | What it's for |
|---|---|
| Identity | id, name, description, source, weight_hash — what the model is and how to verify you have the right bytes. |
| License | license_version, license_uri — which license text governs, and where to read it. |
| Signature | sig_algorithm, public_key_b64, key_fingerprint, manifest_hash, signature — cryptographically binds this manifest to the creator's key. The normal browser flow is Ed25519; see the publish page for how a creator generates and holds that key, and what exactly gets signed below. Anyone can check a manifest with the verifier. |
| Lineage & split | lineage, split.retain_bp, split.upstream — the derivation graph and how much of the royalty this model keeps vs. sends upstream, in integer basis points. The declared split governs; License §6 suggests 500 bp = 5% for a fine-tune. A parent that never adopted OMLA is recorded as external:<source> — signed provenance, never a payable split.upstream entry. This is lineage: one model built from another. |
| Generation weight | generation_weight_bp — this model's declared attribution weight, in integer basis points, when it's used together with other independent models in a single output (a base model plus adapters, say) rather than derived from one. Defaults to 10000 (full weight) if omitted; a LoRA or adapter typically declares 1000 (10%). This is a stack, a different axis from lineage — see how stacks are split. |
| Safety certifications | safety_certifications — four boolean attestations required at publication: not designed for harmful use, not for minors, not for sexual content involving minors, and reasonably designed and tested against those outcomes (Terms §6.2). Part of the signed manifest, not a one-time form field. |
| Payees | payees[].address, .share_bp, .pointers[] — who gets paid, in what proportion, and at which public payment pointer (Lightning, on-chain, Stripe link, PayPal.Me, or an invoicing URL). |
What exactly gets signed
A signature is only worth something if you know what it covers. The creator's key signs this exact UTF-8 string — domain-separated and newline-delimited, so no field can be shifted into another:
OMLA-MANIFEST-v1
<id>
<name>
<source>
<created_at>
<license_version>
<license_uri>
<weight_hash>
<sig_algorithm>
<public_key_b64>
<generation_weight_bp>
<canonical JSON of lineage, sorted by parent_id>
<canonical JSON of safety_certifications>
<manifest_hash>The last line is the load-bearing one. manifest_hash is the SHA-256 of the canonical JSON of payees (with their pointers) and split — the money fields — defined in the resolver and computed the same way by every implementation. Binding it here means the signature covers where the money goes, not just the model's name. Edit a payment pointer after the fact and verification fails.
key_fingerprint is SHA-256(utf8(sig_algorithm) || public_key_bytes), the same derivation the registry database applies, so a fingerprint minted in a browser matches the one the registry computes.
Everything above is checkable offline with nothing but the manifest and a public key — no OMLA service involved. Paste one into the verifier to see it run.
What OMLA serves
In plain English: the registry is one tamper-evident file that anyone can copy, mirror, and check — if a single byte of it were altered, the signature check at the top of this page would fail and show nothing.
A signed, sequenced snapshot of every published manifest — /registry/v2/index.json plus the per-model artifacts it points to — and nothing else. No search backend, no user accounts, no write path beyond a signature-gated publish. The index is a self-contained artifact: a Merkle root over every manifest, a hash chain to the previous sequence, and an Ed25519 signature from OMLA's registry key. Anyone can mirror it; anyone can verify it offline.