The hours went in. The revenue never did.

ProofMeta is an open licensing protocol for agent-consumable work. Machine-readable terms. Chain-agnostic. Apache 2.0. You ship the skill. The wrapper does the negotiating.

For the builder whose best work is sitting in a public repo, earning stars instead of revenue. You didn't ship it to get rich. You shipped it because the problem was worth solving. Then it got scraped into training sets, folded into someone else's product, and quoted back to you without attribution.

ProofMeta gives you what open source didn't build: a wrapper agents can parse. A license file that sits next to your skill, defines the terms, and holds when an agent asks to use it. Chain-agnostic. Machine-readable. Apache 2.0.

Ten minutes to wrap your first skill. Zero to read the spec.

But first, the ledger.

01 / THE LEDGER

Your skills live on GitHub. Your margin lives somewhere else.

If you shipped a reusable skill in the last year — a Claude agent, a prompt pack, a dataset, an orchestration kit — your work is already being consumed. The part that pays for it isn't you.

SkillWhere it livesDownloadsEarned
onboarding-flow.mdGitHub2,341€0
agent-orchestrationplugin directory1,502€0
prompt-chain-kitpersonal newsletter4,721€0
TOTAL8,564€0
// illustrative — swap in your numbers
02 / WHY THERE'S NO WRAPPER YET

Agents don't pay because there's nothing to pay to.

Open source taught the last decade how to share code. It didn't teach the next one how to price an agent-consumable skill. So the default is still: publish, get scraped, watch it compound into someone else's product.

A model can't negotiate with a README. It needs terms it can parse, request, and obey. Until that layer exists, every skill you ship is subsidy.

03 / THE STORY

A decade on the licensing problem. Then the consumer changed.

I spent most of the last decade on licensing and IP — co-building license.rocks, and then working alongside enterprises and creators whose output was the IP. Music and art especially: world-class craft, almost no licensing scaffolding around it. For a long time, the job was building that scaffolding for humans to read.

Then the consumer changed.

A model doesn't read a PDF. It doesn't care what's in your footer. An agent deciding whether to use your skill runs at thousands of requests per minute. Either the terms are in a format it can parse, or the terms might as well not exist. Every document built for human readers goes invisible the moment an agent is in the loop.

Look at the licensing surfaces that exist today — all built for human readers. A LICENSE.md in the repo: models ignore it. A clickwrap on a distribution page: agents don't click. A platform-specific agreement: solves one surface, leaves every other exposed.

The durable fix had to be a neutral protocol. Not a platform. Not a storefront. A file format and a status lifecycle any skill can ship with, any agent can parse, and any chain can verify.

That's ProofMeta Protocol.

04 / HOW IT WORKS

A manifest. A request. A grant.

ProofMeta wraps a skill in a machine-readable license. Agents discover it, request access, get a decision, and act inside the terms you set. The wrapper is the surface. The skill stays yours.

# proofmeta.manifest.yaml
item:     prompt-chain-kit
license:
  type:     commercial-use
  price:    "€0.02 / call"
  duration: 30d
  chain:    any
status:   OPEN
OPEN PENDING GRANTED | DENIED REVOKED

Every state is machine-readable. Every transition is auditable. Every revoke is enforceable.

05 / WHAT'S IN THE PROTOCOL

Four parts. All open. Shipping in the open — what's ready and what isn't.

The protocol is a specification, not a product. Everything below is covered under Apache 2.0, versioned in public, and shippable without asking. Status badges mark what's written down, what's in progress, and what's planned — no vaporware.

COMPONENT 01 SPEC'D

The manifest schema

YAML or JSON. Defines the item, the terms, the price, the chain. Under 40 lines for most skills. v0.1 schema file is the next milestone in the repo.

COMPONENT 02 SPEC'D

The status lifecycle

Five states: OPEN → PENDING → GRANTED | DENIED → REVOKED. Transitions mapped. Auditable trail by design. Revokes are enforceable at the wrapper.

COMPONENT 03 PLANNED

The reference implementation

A runnable reference under Apache 2.0 that wraps a skill, serves the manifest, and handles the status lifecycle end-to-end. The exact architectural shape — server, client, or something thinner — is a call to make once the schema lands.

COMPONENT 04 PLANNED

The SDK

Python and TypeScript first. Rust and Go after. Every primitive the reference implementation uses, packaged for drop-in. Ships after the reference implementation is real.

06 / EARLY RESPONSES

Honest disclosure: pre-launch.

ProofMeta Protocol is pre-launch. There are no customer quotes yet — and we won't invent them. The placeholders below will fill as builders wrap their first skills. If you want to be one of them, the spec is below.

[PLACEHOLDER — needs real quote from a skill-builder who wrapped a skill]

Name · Role · Location

[PLACEHOLDER — needs real quote from a technical founder shipping agent-consumable work]

Name · Role · Location

[PLACEHOLDER — needs real quote from an agent platform implementer]

Name · Role · Location
07 / QUESTIONS WE GET

The honest objections, answered honestly.

"Too early. There's no buyer side yet."

Correct. Agents aren't paying for much of anything right now. That's exactly why the protocol needs to exist before the demand wave lands — not after. The alternative is watching an incumbent bake their version into a closed platform and finding out what their take rate is.

Wrap early while the surface is cheap. Wait, and the terms get set without you.

"Anthropic or OpenAI will just build this in."

They might. They'll build it vendor-locked, chain-specific, and tuned for their economics. ProofMeta is chain-agnostic, AI-first, and Apache 2.0 — infrastructure, not a storefront. If a platform adopts it, builders keep portability. If a platform forks it, builders keep the option.

Neutral layers tend to outlive the platforms that try to replace them.

"Why wrap work I'm giving away for free?"

You don't have to price it. The wrapper is the record — that you shipped it, on what terms, and under what conditions it can be reused. Free becomes a policy choice instead of a default you cannot reverse later.

"How long does it take to wrap a skill?"

About ten minutes for a first skill. Write a manifest. Point the reference implementation at it. Done. Production-grade wrappers take longer — but that's an engineering choice, not a protocol requirement.

"Which agent runtimes does this work with?"

Any runtime that can make an HTTP call and parse YAML or JSON. That's effectively every agent framework shipped in the last two years. There's no SDK lock-in — the SDKs are convenience, not a dependency.

"Is this on a chain?"

It can be. It doesn't have to be. Chain-agnostic means the protocol works with or without on-chain settlement. Builders pick their stack. Some items benefit from on-chain verification. Most don't.

08 / WHO'S BEHIND IT

One person. A decade on the licensing problem.

I'm Daud. I've been in software since the late 1990s and spent most of the last decade on licensing and IP — co-building license.rocks, then working alongside enterprises and, more often, creators whose output was the IP but who had no licensing layer to hold it. Music and art especially: the craft was world-class, the rights scaffolding around it was almost always missing.

That's the pattern ProofMeta is built on. Agents are the next consumer, and they need the same thing those creators needed — a wrapper the surface can actually read. Not a leap into a new category. The compounding of a decade of work into the era where models, not lawyers, are the parsers.

ProofMeta is a one-person protocol project today. Apache 2.0, written in public, open to anyone who wants to build on it.

09 / GET THE SPEC

Wrap one skill. Watch the ledger move.

The spec is Apache 2.0 and open for implementation. No waitlist. No permission. No sign-up wall.

# 1. read the spec
$ git clone https://github.com/bettabeta/proofmeta

# 2. install the reference SDK + run the end-to-end demo
$ cd proofmeta && npm install && npm run e2e

# 3. wrap your own skill — see examples/provider for a 20-line starting point

Low-volume updates as the spec moves. Nothing else. Unsubscribe in one click.