The marketplace: buying, owning, selling

Scellis keeps a hard line between what you have and what exists. What you have is your Catalog — local, instant, offline. What exists is the Registry — the server's record of every published pack release. The Marketplace is the discovery surface over that registry: the free and paid things you do not have yet. This page walks the loop end to end — finding, buying, owning, reviewing, selling — and is precise about what a purchase actually gives you. Paid listings activate at launch; what follows is the architecture they activate into.

Three layers, never blurred#

The marketplace holds no entities of its own. It is a lens over the registry, and installing is the only way content enters your catalog — there is no second door, no side channel that puts something on your device past the one install pipeline everything uses.

Search does not make you choose a lane. One search box runs both: local results return instantly from your device, remote results merge in as they arrive, and every card wears a provenance chip — installed, available, or paid — so you always know whether you are looking at something you have or something on offer.

Layer	Question it answers	Where it lives
Catalog	What do I have?	Your device — local, instant, offline
Registry	What exists?	The server — every published pack release
Marketplace	What could I get?	A discovery surface over the registry — free and paid

The commercial object is the Listing: it prices a specific, immutable release of a pack. The pack itself carries no price, and the engine never reads one — commerce sits entirely outside the compute path. Nothing in a pack's contents knows it is for sale. Selling a standalone model or dataset needs no special machinery either: it is auto-wrapped as a single-entity pack. One install pipeline, one gate — for everything, free or paid.

A paid Listing also cannot be a bare price tag. The pre-purchase contract is enforced: docs, media, a changelog, and seller trust signals are required, and a paid listing without them is refused. Many sellers add a login-free “watch it run” demo — a committed run artifact you can open and reproduce before you buy, so the claim is on the datasheet, not just in the copy.

Buying: settled server-side, pinned at intent#

Checkout runs through a payment provider with EU-grade compliance: SCA and 3-D Secure where required, SEPA, VAT handled properly, and real invoices Scellis issues itself. Card data never touches Scellis servers.

Two guarantees define the moment of purchase. The entitlement — the server-side record that you own this release — is granted only when payment actually settles, never on an optimistic client signal; the settlement webhook is the single writer of that truth. And the price is pinned at intent: the amount you saw when you opened checkout is the amount you pay, so a listing's price change can never bait-and-switch an open checkout.

Fig. 1 — What you own is decided by the payment actually clearing, not by your browser saying it did. Only the processor's confirmation records the purchase — and only then do the bytes arrive. From then on they are yours, whatever happens to your subscription.

Note

The Copilot may browse the marketplace, recommend, and — with your consent — install free content. It can never purchase, pay, tip, or move money. That is structural, not a setting: the server refuses money-moving requests from anything that is not a human gesture in the interface. A prompt-injected Copilot, a leaked API key, or a headless session still cannot buy.

Owning: bought once, yours#

A purchase ends with bytes on your device — not a streaming right, not a license pointing at a remote endpoint. Bought content lands in your catalog as first-class content: inspectable, forkable, runnable offline, exactly like everything else you have. An entitlement can also belong to a Workspace, seat-pooled across a team, so licensing a course or a lab is one purchase, not a spreadsheet.

Ownership survives the marketplace's later decisions. A de-listing never breaks what you bought. Versions are immutable and coexist: when v3 ships, you keep the v2 you bought — nothing is swapped out from under your work. Cancelling a subscription tier ends services, never your installed content. And refunds exist — a buyer-initiated request path plus your EU consumer rights; on refund the entitlement is revoked forward, so you can no longer fetch the content, but bytes already on your device are not remotely killed. Scellis does not pretend it can reach into your machine.

Honest about bytes: what is protected, what is not#

Two platform rules frame everything money touches. Tiers buy platform services and never gate computation — a login-free user runs anything on their own device, unbounded. Paid content gates delivery, not execution: the gate stands between you and the bytes, never between the bytes and the GPU. Both rules are enforced server-side; anything the client shows is cosmetic and assumed forgeable.

Fig. 2 — The question is asked once, at the door. Whether you own something decides whether you get it — and after that, nothing stands between those bytes and your GPU. Running your own work is never metered, never checked, never billed.

The delivery gate is real: paid blobs are handed out only against an entitlement, and even knowing a blob's content hash fetches nothing without one. What Scellis does not claim is copy-protection of bytes a buyer already holds — no such scheme survives contact with a machine its owner controls, so Scellis does not sell you one.

Deterrence is stated for what it is: per-buyer provenance, so a leaked copy traces to its buyer — best-effort and strippable, and labelled as such; signature trust, so only the bought copy runs as official and a leaked re-import shows unverified; and the license. Client-side encryption of packs is rejected as theater — the key would have to reach the same untrusted browser it is meant to defend against. A capability that cannot survive being on a client ships as a hosted service instead.

Reviews, discussions, and becoming a seller#

Ratings run 1–5 with written reviews, and both are verified-purchase-gated: only an entitled buyer reviews, and the seller may respond. Public discussions are separate and open to every reader — anyone can file an issue on any published entity, where the author sees it. The marketplace is a two-way surface, not a shop window. Every listing is reportable and takedown-able too, with statements of reasons and an appeal path — the buyer keeps what they already bought.

Selling starts narrow, and says so. At launch, selling is owner-licensed: the engine is published under fair-code terms (source-published; commercial resale reserved for a fixed term per release), and commercial selling on it requires a commercial grant. The machinery underneath is seller-agnostic by construction — a “become a seller” application path exists in the app, and opening selling wider is a data-and-configuration decision, not a rebuild. Plainly: seller payouts ship together with KYC and escrow — never before, because shipping payouts first would make fraud profitable.