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.
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.
npm i @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.
Chain-agnostic license semantics. Scope tags, pricing models, ready-made templates. One JSON object per permission surface.
Create envelopes, sign, verify, chain. Validate any ProofMeta artifact from your terminal.
Payment, delivery and anchoring are plug-in concerns — not protocol requirements. Pick your stack; permission logic stays portable.
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.
// Permission metadata — pointer to terms, not the contract itself { "artefact": "urn:proofmeta:dataset:training-corpus-v2", "scope": ["inference-allowed", "training-excluded", "commercial-use"], "terms_url": "https://example.com/terms/corpus-v2", "terms_hash": "sha256:a1b2c3...", "proof": { "envelope_id": "env_...", "status": "GRANTED" } }
Every state is machine-readable. Every transition is auditable. Revocation is expressible — not implied.
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 spec is live; implementations are early.
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. read the spec $ git clone https://github.com/bettabeta/proofmeta-primitive-core # 2. install the SDK + run the end-to-end demo $ cd proofmeta-primitive-core && npm install && npm run e2e # 3. browse license templates $ git clone https://github.com/bettabeta/proofmeta-license-contracts # 4. wrap an artefact — see examples/ for starting points