Winding Down OMLA: How to Shut Down a Non-Profit

In plain terms: OMLA was a plan to let AI model creators get paid when companies build on their work, without any organisation sitting in the middle holding the money. I built the website and the system behind it, then decided not to continue, and this is an honest account of what it was and what it took to close it down properly. The full source is free to download at the bottom.

I retired OMLA on 26 August 2026, before it ever launched. I still think the idea is a good one. I simply do not have the capacity to execute and develop it — and other groups are now moving on the same problem, which made continuing hard to justify. This is what it was, what actually got built, and what closing it down properly involved, because that last part is the bit nobody writes about.

tl;dr

The idea: a way for people who release open-weight AI models to get paid by the companies that build on them, with no organisation in the middle holding anyone's money.
What got built: a 14-page site in 13 languages, 33 database migrations, three server functions, a signed public registry, and a settlement calculator with matching Python and JavaScript implementations.
What it earned: nothing. The registry shipped empty and stayed empty — zero models, zero payments, zero users.
Why I stopped: the idea outran what one person can build and run.
What you get: the whole thing, free, at the bottom of this page — plus the shutdown lessons that cost me the most to learn.

The idea

Open-weight AI models get released for free, then get built into products that make money. The people who made the model see none of it. There is no equivalent of the royalty a radio station pays when it plays a song.

OMLA — the Open Model Licensing Association — was meant to be that missing piece, and its central design decision was about what it refused to do:

A creator publishes a signed manifest for their model: who made it, what it descends from, and where to send money.
Non-commercial use is free. A commercial user above a revenue threshold self-assesses what it owes — 30% of the greater of attributable revenue or equivalent inference cost — once a quarter.
They pay the creators directly. Wallet to wallet.

OMLA never touched the money. It never even learned about it: no usage reports, no payer data, no accounts holding funds. That was deliberate. The moment an organisation takes custody of other people's money it needs money-transmitter licensing in every jurisdiction it operates in, and that alone would have been bigger than the rest of the project put together. Removing custody removed the single largest launch risk, and it meant nobody had to trust OMLA with anything: the registry is a signed public record, the calculator is open and deterministic, and you can check both yourself.

What actually got built

More than I expected, looking back at it:

A 14-page public site in 13 languages — licence, registry, resolver, FAQ, terms, privacy.
33 database migrations on Supabase, row-level security on every table, and a tamper-evident audit log chained with SHA-256 hashes.
Three server functions: registration, manifest updates, and registry status.
Hybrid post-quantum signatures (Ed25519 alongside ML-DSA-65) on the registry, so a signed record stays checkable if elliptic curves stop being safe.
A settlement calculator with a written specification and two independent implementations — Python and JavaScript — verified to produce byte-identical output, so nobody has to take my arithmetic on faith.
Independent security review of the schema, which found a real privilege-escalation path and several self-dealing holes. They were fixed.

And the honest number next to all of it: zero. Zero models registered, zero payments settled, zero companies onboarded. The registry was signed, correct, and empty. No payment rail was ever integrated. The corporation was formed but never applied for tax-exempt status, and was dissolved. I built the machine carefully and never found out whether anyone wanted it — which is its own lesson, and not a flattering one.

What shutting down actually took

I expected the shutdown to be an afternoon. It was not, and the reasons are the useful part of this article.

The notice and the thing it retracts have to change together. I put a "this project is shut down, never published, never used" banner across the site. The licence page underneath it still read "Operative — models may be validly licensed." For ten days my own site made two opposite claims about the legal status of my own licence, and I only caught it on a scheduled review rather than by looking at the page. If you retire something with legal text in it, the notice and the text are one change, not two.

Find out what else is standing on the same foundations, before you pull any of them out. The domain was not only serving OMLA — an unrelated private app of mine lived on a path under it. The credential store named after the project also held deploy keys for a completely different site. Neither could be deleted wholesale, and both looked perfectly safe to delete right up until I checked. The first step of my shutdown plan ended up being a list of things not to touch.

"Nobody was affected" is a claim you should be able to prove. Before writing that OMLA was never used, I checked the registry and confirmed it held zero real entries. It happened to be true. Had it not been, the shutdown would have needed a data-export and notification plan instead of a banner — and the time to discover that is before you publish the sentence, not after someone emails you.

Deciding to stop and finishing stopping are two different projects. The decision took a day. The wind-down became a runbook: export the data, publish the notice, retire the backend, close the mailboxes, retire the automation that watched them, prune the secrets. Three weeks later the public-facing part still needed a second pass. Budget for the tail.

A good idea you cannot staff is still an idea you should stop. This is the one I found hardest. OMLA did not fail on the concept — I would still argue the concept is right, and the fact that other groups are now working on the same problem is evidence for it rather than against. It failed on capacity: the gap between what it needed (legal filings, creator outreach, a payments story, sustained development) and what one person with a day job can carry. Recognising that early is cheaper than proving it slowly.

Where this leaves me

The site stays up as a historical record, the registry stays signed and empty, and the code is below for anyone who wants to take the idea further — it is more useful to someone else than it is sitting on my disk. If you are building in this space, the parts I would steal are the no-custody stance and the two-implementation settlement calculator.

If you are winding something down: write the runbook before you start deleting, and check what else is leaning on the walls.

Downloads

Download the OMLA archive (site + backend, zip, 1.2 MB) 1.2 MB

Free for personal use. If it saves you an afternoon, the coffee button's nearby.