RSL in Practice: From Idea to Implementation

When we first introduced the concept of RSL — a “Really Simple License” for the age of AI — it was framed as a possibility. A way to imagine a future where creators could decide how their work is used, and be compensated fairly when it fuels machine learning systems.

That vision is important. But vision alone doesn’t change anything. To move forward, we have to ask: what does implementation actually look like?

This is an attempt to sketch that answer. Not a standard yet, but a practical foundation for building one.

A License That Machines Can Read

At its heart, an RSL license isn’t a PDF, a legalese wall, or a human-readable footnote. It’s data. A tiny, machine-readable object attached directly to content.

That object might live in a <meta> tag on a blog post, a .json sidecar for a podcast, or an API response header for an image. The format doesn’t matter as much as the principle: the license travels with the content.

Here’s what one might look like in JSON-LD:

{  "@context": "https://rsl.org/context",  "@type": "License",  "id": "rsl:1234567890",  "author": "did:ethr:0xABC123...",  "permissions": {    "training": true,    "commercial_use": true,    "redistribution": false  },  "payment": {    "currency": "USDC",    "amount": "0.01",    "per": "1000-tokens"  },  "attribution": "Josh Restivo" }

The fields are straightforward:

• permissions — what’s allowed and what isn’t.
• payment — how much, in what currency, and by what unit (per token, per download, per scrape).
• attribution — who gets credit.
• id — potentially a contract address on-chain, linking words to enforceable rules.

Just as Creative Commons made licenses lightweight for the web, RSL would make them lightweight for the AI era.

Managing RSL at Scale

A single JSON snippet is easy. A million creators using it consistently is not.

That’s why management matters. An RSL ecosystem could include:

• License Registries: Like a domain registrar, but for licenses. Creators mint identifiers tied to their content.
• CMS Plugins: WordPress, Ghost, Substack, and others auto-attach metadata on publish.
• Content Hashing: Every license references a cryptographic hash of the file or text, preventing misattribution.
• Discovery APIs: AIs (or platforms on their behalf) query: “Does this content carry an RSL license, and under what terms?”

In other words: the same way RSS made distribution simple, RSL should make rights simple. If it isn’t that easy, adoption will stall.

Enforcement Through Smart Contracts

Metadata sets the rules. Smart contracts make them stick.

Imagine this workflow:

1. An AI encounters RSL-tagged content.
2. It resolves the license ID to a smart contract.
3. The contract encodes permissions and payment terms.
4. A micropayment transaction is triggered before ingestion.
5. The ledger records attribution and transfers funds.

Suddenly, every use of content leaves an auditable, immutable trail. Dashboards could show:

 

The creator’s wallet is credited. The AI system has clean rights. Both sides get clarity.

It’s not theoretical. NFT royalties have already shown that smart contracts can pay creators automatically. RSL builds on that precedent, but points it toward AI-scale usage.

Where Things Stand Today

We’re not there yet.

There is no universal RSL spec. No off-the-shelf tools. But the ingredients exist:

• Creative Commons + Schema.org proved licenses can be both human-readable and machine-readable.
• NFT metadata proved digital assets can carry rules with them.
• Web3 protocols like Lens or OpenSea showed what native monetization looks like.

What’s missing is a unifying layer. Something simple enough that a TikTok soap-carver or a janitor with a phone can click “RSL” the same way they click “share.”

Questions We Still Need to Answer

The path forward isn’t without challenges:

• How do you stop bad actors from ignoring RSL tags altogether?
• What currencies make sense — global stablecoins, local tokens, or credits?
• Who stewards the standard — a non-profit, a consortium, or a decentralized foundation?
• What does attribution mean when your video is one of ten million inside a model’s dataset?

None of these are trivial. But they’re not showstoppers either. They’re the kind of questions standards bodies, open-source communities, and creators can solve if given a clear frame.

flowchart LR
  %% --- Nodes ---
  C1["Content<br/><small>+ RSL</small>"]
  C2["Article<br/><small>+ RSL</small>"]
  C3["Image<br/><small>+ RSL</small>"]

  AI(("AI<br/>System"))
  K["Contract"]
  CR["Creator"]

  MR["Machine Readable"]
  AU["Automated"]
  FT["Fair &amp; Transparent"]

  %% --- Flows ---
  C1 --> AI
  C2 --> AI
  C3 --> AI

  AI --> CR
  AI --- K

  %% --- Bottom callouts (visual-only) ---
  MR --- AU --- FT

  %% --- Styling (approximate the look) ---
  classDef leftBlue fill:#6cb6ff,stroke:#4a90e2,color:#ffffff,rx:10,ry:10;
  classDef leftGreen fill:#17c9a3,stroke:#10a37f,color:#ffffff,rx:10,ry:10;
  classDef leftPink fill:#ff6fa6,stroke:#ff4f8b,color:#ffffff,rx:10,ry:10;

  classDef ai fill:#1f2937,stroke:#ff8a3d,stroke-width:3px,color:#ffffff;
  classDef creator fill:#10b981,stroke:#0ea371,color:#ffffff,rx:18,ry:18;

  classDef contract fill:#6366f1,stroke:#4f46e5,color:#ffffff,rx:6,ry:6;

  classDef footer fill:#ffffff,stroke:#ffffff,color:#111827;

  class C1 leftBlue;
  class C2 leftGreen;
  class C3 leftPink;

  class AI ai;
  class CR creator;
  class K contract;

  class MR,AU,FT footer;

  %% Optional: tweak link colors to match the red/green feel
  linkStyle 0 stroke:#ff5a5f,stroke-width:2px;
  linkStyle 1 stroke:#ff5a5f,stroke-width:2px;
  linkStyle 2 stroke:#ff5a5f,stroke-width:2px;
  linkStyle 3 stroke:#10b981,stroke-width:2px;
  linkStyle 4 stroke:#6366f1,stroke-width:2px,stroke-dasharray:3 3;

Closing

The internet has always moved in waves. First came distribution — RSS feeds, blogs, YouTube. Then came platforms — the networks and the streams. Now, in the age of AI, we need something else: balance.

RSL isn’t just about protecting creators. It’s about weaving accountability into the fabric of machine learning. It’s about making sure that the economy after “jobs” isn’t built on invisible labor, but on visible, valued contribution.

If the past era of the web was built on sharing, the next one must be built on responsibility. And responsibility starts small — with a snippet of metadata, a hash of content, a contract on-chain.

The question isn’t whether we can implement it. The question is whether we will.