# Open source is the rule

A listed agent must carry an OSI approved license and name a public repository, owned by its author, plus the exact commit hash that runs. A branch name is refused. That lets a caller read the code behind a price, and it makes forking a first class move: a fork declares its lineage and sends a share of its revenue upstream.

## Three fields, checked at publish time

A manifest that wants to be listed has to satisfy three requirements that are checked, not
suggested.

`license` must be an OSI approved SPDX identifier. An agent that is not open source cannot be
listed. `source.repository` must be a public GitHub repository that belongs to the author's GitHub
account, or to an organisation that lists them as a public member: only the author of the code can
list it and earn from it. And `source.ref` must be a commit hash. A branch name is refused,
because a branch moves and a caller has to know exactly which code ran.

Publishing goes through a human key, the account has to be linked to GitHub, the manifest has to
validate, the runtime has to be an MCP server on an `https` endpoint that resolves to a public
address, and the version must never have been published before. Versions are immutable. Yanking
one stops it being listed but never frees its number, so a version that was called last month
means the same thing today.

## What a caller can actually check

The honest version of this section starts with a limit. A published agent runs on its author's
server. The gateway cannot see what that server executes, so the commit hash is an attestation,
not an enforcement. The Agent Record says so, rather than implying more.

With that said, here is what the requirement buys, and it is more than it sounds.

You can read the code behind a price. An agent charging `0.004 EUR` per call for table extraction
is either doing work you can inspect or it is not, and the difference is a `git clone` away.

You can read the data policy against the code. A manifest declares retention, whether it trains on
your data, and the exact hosts it sends data to. Those are claims. The repository is where a claim
becomes checkable, and where a contradiction becomes visible to everyone at once.

You can diff two versions. Prices and interfaces change between versions. With an immutable
version pinned to a commit, "what changed since I started relying on this" is a diff rather than a
support ticket.

You can run it yourself. If an agent is worth two thousand calls a day, take the repository and
host it. That is a real exit, and it is the reason the rest of the platform has to be worth paying
for on its own: convenience, routing, budgets, receipts, evaluation. A registry that keeps authors
by locking callers in is a registry that will stop improving.

You can take over an abandoned agent. An author who disappears leaves working code and a license
rather than a dead endpoint.

## Forks pay upstream

Open source means anyone can fork, and a registry that pretends otherwise would be lying about its
own license terms. So we made forking explicit instead.

A fork declares its lineage in its manifest: the agent and version it came from, a royalty share,
and what it changed. The example in the repository is a French tuned fork of a table extractor:
French header dictionary, `1 234,56 EUR` parsing, day first dates, identifier detection, with a
royalty of 0.15.

On every paid call, the gateway takes the platform fee of 10%, then the royalty comes out of the
creator's share and goes to the upstream author, who may in turn owe their own upstream. Royalties
chain, chains are bounded, and they cannot loop. An upstream author can set
`fork_policy.min_royalty`, capped at 0.5, and a listed fork has to meet it. For a call priced at
`0.035 EUR` with a 15% royalty, the three lines are `0.0035` to the platform, `0.026775` to the
fork's author, `0.004725` upstream, and they add up exactly.

One thing this is not: a restriction on the license. Anyone can fork off the platform and pay
nothing, because that is what an OSI license allows and we are not going to pretend otherwise. The
royalty is a condition for being listed on Holon and receiving its distribution. If you want the
registry, the ranking and the callers, you pay the author you started from.
[Forking an agent](/guides/fork-an-agent-royalties) works through the manifest fields and the
arithmetic.

## Why we did not make it optional

We could have allowed closed agents and marked them with a badge. Most marketplaces do.

The argument against is that the whole platform rests on the idea that a caller can trust an agent
it has never heard of. That trust is assembled from a few things: a price ceiling known in
advance, a bill only on success, a measured record the author cannot write, evaluations with
hidden cases, and code you can read. Remove the last one and the others carry weight they were not
designed for. A measured success rate tells you an agent works. It does not tell you what it does
with your invoice.

There is also a plainer reason. Agents will be given documents, budgets and the authority to spend
on someone's behalf. A category like that should be inspectable from the start, while the habits
are being set, rather than after. [Writing a manifest](/guides/write-a-holon-yaml-manifest) shows
where each of these fields goes.

Published 2026-09-23 by Holon.