§ Platform / Openness & ownership
Every claim is verifiable. Everything you author is yours.
Ownership questions deserve exact answers, so here is the whole map. The surfaces the world checks us against are permissively licensed. The engine you extend is published as source under fair-code terms — free for research, teaching, and personal and internal use, including inside a company — and each release later converts to the permissive license. What stays ours is named. And everything you author is your own, under a license you choose.
A license map, not a license slogan
“Is it open?” has no useful single answer — the useful answer is always “which layer?”. Scellis answers layer by layer, and the layers are peers, not nested: what the world verifies and builds against is permissively licensed; the engine you extend is published source converging to permissive, release by release; the hosted service and our own commercial packs are proprietary, and say so. Nothing is left in licensing twilight.
Each ring exists because the architecture claims something only that license can make true. Correctness claims are worth exactly what a stranger can re-derive, so verification is unconditionally open. A platform whose users build on equal terms with the people who made it cannot turn every user into a tenant, so the engine's source is published. And a hosted business has to fund the work, so what is ours is named outright — never hidden behind a vague “core”.
Check every claim without asking permission
| Surface | What it is | What anyone may do |
|---|---|---|
| Schemas | every entity's machine-readable definition | validate, generate, re-implement |
| Export files | .scellis-workflow · -pack · -block-pack · -model · -dataset | read and write every format — imports verify their hash |
| Conformance corpus | the cases plus the declared tolerance classes | re-run every correctness claim |
| CPU reference | the anchor all numerics are proven against | check any GPU result against the reference |
| Client libraries | typed clients for every action the platform exposes | build your own tools and clients |
| Agent tools | what an external AI agent sees — derived from the same actions | audit it — or build against it |
Permissive means permissive: no permission, no partnership, no reciprocity condition — a competitor may use all of it. That is deliberate; it is what makes the conformance regime worth citing.
The interchange ring is everything a third party needs to check us, or to work with us: the schemas every entity is defined by, the portable .scellis-* export files, the conformance corpus with its declared tolerance classes, the CPU reference implementation that anchors every numeric claim, the client libraries, and the tool surface external AI agents talk to — all under a permissive Apache-2.0-class license. Anyone, including a competitor, may use them, for anything, without asking permission.
This is what turns honesty from a promise into a property. Every number on correctness can be re-derived by re-running the corpus against the reference; the export files can be read and written by software we have never met; the API can be built against without a partnership contract. A conformance regime anyone can run is one you can cite in a methods section without asking us for anything.
Fair-code: published source, honestly not open source
The engine — the training compiler, the automatic differentiation, the hand-built kernel library, the reproducibility machinery — is published as source under fair-code terms. From day one it is free for research, teaching, personal use, and internal use inside an organization, commercial ones included: a company may run Scellis on its own work, a lab may build a course on it, a group may fund the work through a third-party grant. You can read every kernel your results depend on, and fix or extend what you find.
One right is reserved: commercial resale by others — selling the engine on, or building a competing commercial service from it — for a fixed term per release, with commercial grants available by separate agreement inside the term. When a release's term ends, that release converts to the permissive license. Every release starts its own clock, so the engine is converging to permissive, permanently and by design.
We never call this open source, because it is not: fair-code is source-available with a delayed permissive conversion, and those are different things. The page that prints what the platform cannot do is not going to blur the most-blurred word in software licensing. You get the exact terms, not the warm label.
What stays ours, said in one breath
Three things are ours and stay that way: the platform server — coordination, sync, billing, relay — our own regulated and commercial content packs, and the signing and commerce infrastructure. That is the business. It funds the engine, and it prices hosted services, never computation: running your own work on your own device is unlimited on every plan, including no account at all.
The same plainness governs the edges. Some hosted internals stay server-side trade secrets, but they enter the product only as consent-gated, cataloged hosted services — content like any connector, never a privileged part of the engine; the on-device substrate stays fully yours to extend. And selling on the marketplace starts with us as the only seller — because selling *through us* carries operational duties (identity checks, payout rails, VAT liability, refund exposure), not because the license forbids it. Opening it wider is a decision, not a rebuild.
Authored by you, owned by you, licensed by you
| You… | The posture | The mechanism |
|---|---|---|
| author content | yours — your copyright, your license choice at publish | one authoring path: yours and ours are the same |
| fork public work | the upstream license is inherited and displayed | the lineage stays visible on the fork |
| buy content | yours to run and inspect — delivery is gated, running never | signed Packs; we make no copy-protection claim |
| export your work | portable files that verify their own hash | .scellis-workflow · .scellis-model · .scellis-dataset |
| walk away | your data was on your device all along | the local-first database — nothing to request back |
“Delivery, never execution” is also an honesty statement: once bytes are on a device, redistribution is deterred — by watermark, signature and license — not prevented. No copy-protection theater.
The deepest ownership fact is structural: what you author and what we author run as one class. The engine cannot tell your op from ours when it runs them, what you author passes the same checks our own content passes, and nothing we can compute is reserved from you. A platform built that way cannot treat its users as tenants — the blocks, kernels, models, viewers and connectors you write are your own.
Ownership becomes concrete at publish time: nothing goes out without an SPDX license you choose — the flow offers curated defaults such as MIT, Apache-2.0 and CC-BY-4.0 — and a fork inherits and displays the license it came from. This is a gate at publish, not fine print: unlicensed public work is all-rights-reserved by default, which would make the sharing you intended legally void.
The exit door is part of the design
Leaving is a supported feature. Your work exports as .scellis-* files — reproducible byte for byte, hash-verified on import — and those formats sit in the permissive ring, so anyone may write a complete reader without asking us. Your data is in a local-first database on your device to begin with; export is a format decision, not a data request. Even content you bought keeps running locally if its listing disappears.
And time works in your favor. Each release's reserved term ends in permissive conversion, so the platform only opens further as it ages; a versioned engine runs old work indefinitely; and where a guarantee has a boundary, it is printed in honest limits rather than rounded up. None of this asks for trust — the rings are published, and the corpus re-runs.