ProofMeta is an open protocol for machine-readable licensing, permissions and usage policies — so agents and autonomous systems can discover, verify and act on rights at scale. Apache 2.0. Chain-agnostic. Specification, not SaaS.
One signed file on your domain. No account, no server, no code. Your key never leaves the browser.
proofmeta.json, upload it to /.well-known/TypeScript SDK and validator CLI on npm. Signed envelopes, did:key, JCS hashing, fail-closed acceptance.
$ npm install @proofmeta/sdk-ts $ npx @proofmeta/cli validate proofmeta.json
Autonomous systems now consume datasets, call APIs, remix prompts, reuse generated outputs and chain tools together — often without a machine-verifiable answer to a basic question: is this allowed, under which terms, with what proof?
An agent ingests a corpus. The license is a PDF in a footer link. No scope tags. No training exclusion. No verifiable grant.
A workflow calls third-party endpoints. Terms of service exist — but not in a form a runtime can parse, compare or enforce.
One agent's output becomes another's input. Derivative rights, attribution and commercial use are ambiguous — even for humans.
Skills, plugins and capability registries multiply reuse. Permissions do not travel with the artefact. Verification does not compose.
Licenses are PDFs. Policies are fragmented. Permissions are human-readable. Machines cannot verify rights.
Rights, scopes and usage policies expressed as signed, machine-readable primitives — verifiable before action.
The agentic era needs programmable rights infrastructure — the same way the web needed HTTP, not another storefront.
ProofMeta is an open specification and reference implementation — not a hosted product, not a marketplace, not a take rate on your artefacts. Commercial applications built on the protocol are separate.
Status: v1 draft. The Tier-1 reference flow and npm packages work today; this is not yet a tagged v1 release.
npm install @proofmeta/sdk-tsThe license is a pointer, not a contract. ProofMeta references terms, scopes and proof — it does not replace counsel. It makes permission computable for machines.
Every ProofMeta artifact is a signed envelope: who wrote it, what exactly was written, when, and in what order. Agents verify before they act — no bare JSON, no implied consent.
ed25519 signatures, DID identity (did:key), JCS canonical hashing. Cryptographic foundation for every protocol message.
Eight core tags every agent understands — commercial, ai-training-excluded, attribution-required, … — plus URL extensions for anything provider- or jurisdiction-specific. docs/scope-vocabulary.md
Create envelopes, sign, verify, chain. Validate any ProofMeta artifact from your terminal.
The no-op free resolver is implemented for Tier 1. Payment, delivery and anchor resolver implementations remain planned and optional.
Was value exchanged? (external resolver)
Who acted? (DID + signature)
Was it allowed — under which terms, with what proof?
An agent discovers permission metadata attached to an artefact, requests access, receives a machine-readable grant or denial, and acts only inside the terms — with an auditable trail.
payload.items[] and payload.license_types[]. The complete manifest artifact is wrapped in a Signed Envelope.{
"payload": {
"items": [
{
"item_id": "training-corpus-v2",
"name": "Training Corpus v2",
"available_licenses": ["commercial-standard"],
"content_hash": "sha256:0da2a7cd70ea24dcbd53fa22c29528c99a71021248c5ab4c86ecd13a8f34a1d2"
}
],
"license_types": [
{
"id": "commercial-standard",
"terms_url": "https://example.com/terms/commercial-standard",
"terms_hash": "sha256:bcfd030a074d8f9b09c84fe7950537814ad72f511db0cac8a6495f67ffe59688",
"scope": ["commercial", "derivative-allowed", "ai-training-excluded"]
}
]
}
}
OPEN → PENDING → GRANTED
└────→ DENIED (terminal)
GRANTED → SUSPENDED → GRANTED (reinstate)
GRANTED → REVOKED (terminal)
SUSPENDED → REVOKED (terminal)
Every state is machine-readable. SUSPENDED is temporary and reinstatable; REVOKED is permanent. Expiry is derived from valid_until, not a stored status.
ProofMeta does not assume a single content type. Any resource an agent might discover, compose or execute can carry the same signed permission envelope — datasets, APIs, code, documents, media, model outputs and agent capabilities.
ProofMeta is written in public under Apache 2.0. Implement without permission. Fork without capture. No vendor account. No marketplace listing required.
I'm Daud — in software since the late 1990s, most of the last decade on licensing and IP. ProofMeta compounds that work into infrastructure for an era where agents, not lawyers, need to parse what is allowed.
An open spec and reference implementations — not a hosted product with a take rate.
Chain-agnostic. Platform-agnostic. Policy interoperability without platform capture.
Machine-readable permission metadata references legal terms — it does not replace them.
No fake testimonials. No inflated claims. The Tier-1 reference flow and npm packages work today; the tagged v1 release and its remaining acceptance evidence are still open.
The protocol and schemas are the specification — open, Apache 2.0. The TypeScript SDK and CLI are the reference implementation. PANDR builds commercial applications on top. There is no marketplace and no requirement to use any commercial layer.
No. ProofMeta makes permission computable for agents and apps. Legal agreements still exist — the protocol gives machines something parseable to point at.
Any runtime that can fetch JSON and verify signatures. SDKs are convenience — not a lock-in layer.
Agents are already composing tools, datasets and outputs at scale. Rights metadata has not kept pace. Without machine-readable licensing, every autonomous workflow is a liability waiting to be discovered — not because agents are malicious, but because permissions were never designed for them.
The specification is Apache 2.0 and open for implementation. Clone it. Run the demo. Attach permission metadata to your first artefact.
# 1. use the SDK in your agent or API $ npm install @proofmeta/sdk-ts # 2. check any manifest or envelope chain $ npx @proofmeta/cli validate proofmeta.json # 3. read the spec, run the reference provider and consumer $ git clone https://github.com/bettabeta/proofmeta # build from source: CONTRIBUTING.md (pinned install, then npm run e2e)