§ Platform / Marketplace
A marketplace where computation is never for sale.
Blocks, models, datasets, kernels — everything in Scellis is content, and the Marketplace is where content changes hands: browse what exists, install what is free, buy what is not. Two rules frame every transaction: computation is never tied to a plan — unlimited local compute on every plan, even with no account — and paid content gates delivery, never execution. What you buy is really yours to run and to read.
Everything that exists, one install away
Everything in Scellis ships the same way — blocks, models, datasets, kernels, viewers, connectors all arrive as signed, versioned packs — so one marketplace can carry all of it. This is the shop window for everything that exists but is not on your device yet: built-in content, community work, and paid listings side by side, every card showing where it came from, how trusted it is, which version it is, and whether its numbers were checked. One search box puts it beside your own catalog, and each result says which side it came from.
One thing this page is *not*: a place to buy computing power. Scellis sells content — packs, models, datasets — and never compute. Sharing and renting *computing* is a separate story with a separate mechanism, and the part of it that involves money is not built yet; it is described honestly on distributed compute.
Install is the only door. The marketplace holds nothing of its own: installing fetches the bytes, checks them against their hash, and moves them into your catalog through the same signed-pack path every install uses — one way in, no special cases. From that moment the thing is local, works offline, and is indistinguishable from something you wrote yourself. Publishing goes the other way through the same door: make something of yours public and it becomes findable here, beside the built-ins — because what people write themselves is first-class by architecture, not by courtesy.
Computation is never tied to a plan
One rule frames everything Scellis will ever charge for: plans buy platform services — cloud storage, sharing, collaboration capacity, relayed compute — never the math. A visitor with no account can write and run any computation on their own device, unbounded. No trial cliff, no metered GPU-seconds, no operators reserved for a paid plan. If it computes locally, it is yours on every plan, including the free one.
The limits that do exist are metered services, and they refuse out loud: storage, how many people can join at once, relay minutes. Hitting a cap gives you a clear refusal and a way forward — never a silent slowdown, and never a ceiling on what your own GPU may compute. Even the checking is honest: what each plan includes is looked up in a table the server owns, and anything the client shows you is decoration, assumed forgeable. A feature locked only in a browser would be free to anyone who opens the developer tools — so no feature ever is.
A purchase is an auditable chain, not a leap of faith
A paid thing here is a Listing: a commerce record that prices exactly one released version. The pack itself never sees a price — the engine cannot read one — so a paid block is structurally identical to a free one, with no privileged path through the code. A listing also has to earn the purchase before it can take one, and that pre-purchase contract lands with early access in exactly this shape: long-form docs, media, a changelog, seller trust signals, reviews only from verified buyers, and — for anything that computes — a demo you can watch run as a real, reproducible result without logging in. A paid listing with no docs and no demo or media is refused at creation.
The purchase itself is engineered like the rest of the platform. Confirming mints a one-time token, issued by the server and pinned to exactly this product, price, and currency — a price cannot change under you mid-checkout. The right to download is granted only when the payment actually settles, written by exactly one path, and every reversal — refund, chargeback, cancellation — takes it back the same way. Enforcement is on the server end to end; checkout runs on Stripe, so card data never touches Scellis, and Scellis keeps its own record of the sale, from the consent you gave at checkout to the invoice.
Ownership is durable and shaped like real institutions: what you buy can belong to you or to a workspace with pooled seats — team, course, and campus licensing is the same mechanism with a different owner, not a second system. If a listing is later withdrawn, you keep what you bought; when a new version ships, what you pinned keeps resolving exactly as it did.
Delivery is gated. Execution is yours.
| Scenario | Posture | Mechanism |
|---|---|---|
| Unauthorized download | prevented | One checked chokepoint in front of the bytes: knowing a paid file's hash fetches nothing without the purchase. |
| Passing on bytes you hold | deterred, not prevented | Per-buyer tracing (best-effort, defeatable — we say so), signature trust, and the license. |
| Client-side DRM | never claimed | A browser cannot keep a key from its own user, so no such promise is made. |
| De-listing | you keep it | What was purchased survives; installed bytes keep running. |
| Refund or revocation | forward-effective | Local bytes keep running; updates and re-downloads stop after a grace period — never a remote kill. |
| Running paid content | never gated | Paid packs run as first-class content, identical to free ones — no privileged path through the code. |
The vocabulary is deliberate: “prevented” where the server can enforce it, “deterred” where it cannot. The platform never claims a stronger guarantee than it performs.
Scellis prevents exactly one thing: downloading what you did not buy. The contents of a paid release are served only through one checked chokepoint, so knowing a paid file's hash fetches nothing without the purchase. Everything past delivery is said with the same honesty: once the bytes are on your device they run as first-class content you can read and fork — identical to free work and to work you wrote yourself. There is no DRM here, and no pretence of one: a browser cannot keep a secret from its own user.
Passing on bytes a buyer already holds is deterred, not prevented — and the deterrents are named. Per-buyer provenance can trace a leak back to its buyer (best-effort, and defeatable; we say so). Signature trust means only the bought copy runs as official — a re-imported leak visibly runs unverified. The license you accepted still binds. Encrypting packs on the client is theatre: a key that has to reach the same untrusted browser protects nothing. Anything that genuinely cannot survive on the client ships as a hosted service you consent to, plainly labeled — and the full list of what we cannot promise is on honest limits.
Your assistant can browse everything — and buy nothing
The Copilot can do everything you can, with exactly one commercial exception — and it is structural, not a policy promise. Buying, payouts, tips, refund requests, raising a budget: every action that moves money refuses any caller that is not a human clicking in the app, and each one needs a fresh one-time token that only a real click can produce. A prompt-injected assistant, a leaked key, a script running unattended — none of them can spend a cent, because the refusal happens on the server, not in a checkbox in your browser.
The same bar extends to agents outside the app: the agent surface is specified so that an outside agent's permissions cannot even express “spend money”, and the money-moving actions are left out of what it is given and refused again if it tries — two independent layers, by design. What remains is genuinely useful: the Copilot browses, compares, recommends, and installs free content with your consent. It advises on the market. It never acts in it.
Reportable, reviewable, appealable — and honest about selling
| Duty | Who invokes it | What happens |
|---|---|---|
| Report | anyone | Free or paid, every listing feeds one review queue — the same one that governs all public content. |
| Takedown | the operator — decided on the server | De-listed and closed to new installs; buyers keep the bytes they hold. |
| A written reason | every affected author | What was actioned, under which rule, and how to appeal it. |
| Appeal | the affected author | A first-class path back through the same queue — never a dead end. |
| Transparency | published periodically | Aggregate report, action, and appeal counts — plus a trusted-flagger channel and a published point of contact. |
Suspension removes platform services and publication. Local computation on content you already hold continues unconditionally — moderation never reaches the math either.
A marketplace is infrastructure other people stand on, so its governance is built as product machinery rather than promised in a policy PDF. Every listing — free or paid — can be reported and reviewed; a takedown is decided on the server and removes the listing without reaching into anyone's device, so buyers keep what they bought. Every action comes with a written reason naming the rule and the way to appeal, transparency reports are published, and a trusted-flagger channel is triaged first. This governance surface — the EU Digital Services Act's notice-and-action duties, built as real queues rather than promised beside the product — lands with early access.
Selling is stated just as plainly. Paid listings start with the platform and its licensees — but the machinery beneath is seller-agnostic by construction: there is no privileged path for the house, eligibility is just a record, and opening it wider is a decision, not a rebuild. A “become a seller” application ships in the product; payouts to sellers arrive only together with the identity checks and payout protections they require, never before. How the engine is licensed — and why commercial selling starts with the owner — is laid out in openness & ownership.