§ Platform / Honest limits
We publish what it cannot do.
An instrument that publishes its error bars is one you can publish with. Scellis keeps a register of the limits it cannot eliminate — forty-five entries in four classes, each paired with the platform rule that bounds it. It binds engineering decisions and this website alike, which is why nothing on these pages runs ahead of what the engine actually does.
An instrument that states its error bars
A thermometer that claims perfect accuracy is a toy; the one a lab calibrates against ships a datasheet with operating ranges and error bars. Scellis is built for work that must survive review, so it holds itself to the instrument's standard: a register of honest limits — forty-five entries in four classes — each stating something the platform cannot eliminate, in writing, next to the features it qualifies.
An entry qualifies only if the limit is physics, protocol, or platform reality — something no vendor could engineer away, whatever their landing page implies. What can be fixed is a defect, and gets fixed; what cannot is printed. Each entry is therefore paired with the rule that bounds it: not an apology but an engineering answer, stating exactly how far the guarantee extends and what holds the line there.
The qualifiers are the fact. “A background tab computes nothing” is true of an *untended* one — a contributor who has said yes to lending their device holds the browser's freeze exemptions and keeps computing, which is what makes pooled compute work at all. And that bound is honestly a heuristic: the operating system's sleep still wins. Strip either qualifier and you get a cleaner sentence and a false one — which is the whole reason this page exists as a product surface rather than a blog post.
Headline claims ship with their boundaries attached
| The claim | Its printed boundary |
|---|---|
| “Raw data never leaves the device” | True of the bytes. Model updates do leave — so beyond your own devices, a differential-privacy floor with clipping is always on, and its budget is tracked. |
| “Pool devices and go faster” | Near-linear only for work that splits into independent pieces — sweeps, ensembles, simulations. Synchronized training waits for the slowest device and flattens at roughly tens of stable peers. |
| “Enough laptops equal one big GPU” | Pooling replicates the model on every device — it multiplies throughput, never memory. A model too big for one device needs a split or relayed path; an impossible fit is refused up front, explicitly. |
| “Serverless collaboration” | True of the data itself on cooperative networks. Coordinating who joins still needs a server at every join and reconnect; solo, offline work never does. |
| “Reproducible, bit for bit” | Bit-for-bit means the cited, committed bytes. Re-running on a GPU agrees within the tolerance the run declared; bit-exactness across different devices takes the CPU reference path. |
| “Strangers can lend you compute” | Under verification that is probabilistic, economic, and auditable — never cryptographic and absolute. The browser has no secure enclave; confidential work stays out of the open pool. |
| “Idle devices keep computing” | A contributor who has consented keeps computing while the tab lives; an untended one is frozen by the browser and earns nothing, because only verified, accepted work is counted — never wall-clock time. |
The boundary column is quotable as written: these same entries govern engineering decisions and this site's copy alike.
A qualifier dropped in a brochure resurfaces as a surprise in a lab. The table below is the short form — the claims people quote, each with its boundary printed beside it, in the words we would use in a methods section.
None of these boundaries is unique to Scellis. Every distributed system has a control plane; every GPU rounds floats in its own order; every browser freezes background tabs. What differs is where you learn this: printed on the datasheet before you design the study, or discovered in production after you have committed to it.
What pooling compute buys — and what it cannot
When many devices pool compute, the mechanism is the claim — never an invented multiplier. Work that splits into independent pieces — parameter sweeps, Monte-Carlo simulation, ensembles, k-fold — parallelizes near-linearly to thousands of peers, because the pieces never wait on each other. Synchronized training does not: every step waits for the slowest device, so throughput flattens at roughly tens of stable peers. You extend that by trading synchrony — local steps, buffered updates — never by pretending the physics away.
Federated learning scales along a third axis entirely: participants and statistical power — fifty samples per site become ten thousand across two hundred sites — never wall-clock. And all of it needs a coordinator: a browser tab cannot accept an incoming connection, so a server stands at every join and reconnect. It is never load-bearing for correctness or for solo, offline work; for sustained pooled throughput, it honestly is.
Trust among anonymous peers is bounded, not solved. The browser has no secure enclave, so Scellis cannot cryptographically prove that a stranger ran real work on the hardware they claim, or that they are a distinct person. The working guarantee is probabilistic, economic, and auditable — unannounced spot-checks, agreement across independent peers, a tamper-evident record of every contribution — which is why the three trust regimes are never collapsed into one, and regulated work runs in the vetted-consortium regime only. The mechanism map is in the distributed-compute guide.
Privacy, stated at both levels
The register's sharpest entry is the one an industry keeps rounding up. In any federated or pooled setting, “raw data never leaves the device” is true of the bytes and false of the information unless real machinery is engaged: model updates do leave — that is the mechanism — and an update is a lossy, sometimes-invertible function of the data it was computed on. Reconstructing training data from gradients is a demonstrated attack, not a thought experiment. A sentence that ends at “never leaves” is selling comfort, not a guarantee.
So the boundary ships with machinery, not a disclaimer. For any pool beyond your own devices, an un-noised individual update is not sendable: differential privacy with per-update clipping is the always-on floor, governed by a budget ledger that refuses to overspend rather than quietly degrading. Secure aggregation layers on where the cohort and its churn permit — mandatory for a vetted consortium — and regulated cohorts run in that regime only. What the host can and cannot see is laid out on security.
The same two-level candor covers the rest of the class. Erasure on append-only records works by destroying the key that makes the personal data resolvable — the data is genuinely gone while the sync log stays replay-safe — but content you *published* is kept under an anonymized author tombstone rather than shredded, because the server cannot know who depends on it and retaining is the safe direction. And revoking a share is forward-effective: bytes someone already synced cannot be recalled, which is exactly why a regulated document can demand identity-bound, non-cached viewing instead.
The tab's operating range, printed
| Condition | Designed behavior | Never |
|---|---|---|
| No WebGPU (~15% of devices) | Whole workflows run on the CPU behind a loud, persistent banner; training a large model is limited. | A blank canvas, or a silent slowdown. |
| Neither GPU nor CPU path | The Studio opens to view and author: compose, inspect, share. | A crash or an error page. |
| Tab moves to the background | A consented contributor keeps computing; an untended tab freezes. The uptime kit raises the odds and is documented as a heuristic. | A pretended background run. |
| Storage pressure | A meter surfaces it; unpinned objects are evicted oldest-first; what you are using is never collected. | Silently lost results. |
| Connection drops | Everything you have keeps running indefinitely; edits queue and reconcile on reconnect. | A feature wall or a lost edit. |
The rule behind every row: a degraded state announces itself, loudly, in the moment — never a silent fallback, never an invisible substitution.
The browser is the instrument, and instruments have operating ranges. An untended background tab is frozen by the browser itself — it computes nothing, and Scellis never pretends otherwise. A tab you have consented to contribute from holds the browser's freeze exemptions — a wake lock, an installed app window, a leader tab — which raises the odds and is documented as a heuristic, because the operating system's sleep always wins. There is no unattended local run and no scheduled one: a closed tab runs nothing; your own always-on device, joined to your own pool, is the honest answer to “run it nightly.”
Storage is budgeted, not assumed: the local database asks the browser to keep its data, meters what it holds, and surfaces pressure instead of losing anything quietly — unpinned caches are evicted, while what you are using (weights in flight, saved workflows and everything they need) is never collected. The GPU is checked, not presumed: on the roughly 15% of devices without WebGPU, whole workflows run on the CPU behind a persistent “running on CPU — slower” banner; with neither path, the Studio still opens so you can compose, inspect, and share. Degradation is loud, by construction.
f32-first, with the fine print in the headline
The GPU works in single precision: true double precision lives only on the CPU reference path — and instead of hiding that, the engine designs around it in the open. Statistics kernels use compensated summation, because naive f32 accumulation cancels catastrophically at large N; f16 training keeps f32 master weights and scales the loss; and extended-precision op families are content anyone can author, conformance-checked, buying back precision at a stated cost.
Float arithmetic on a GPU depends on the order it is done in, so the register refuses bitwise magic: a normal run reproduces within the tolerance it declared; a strict run buys bit-exactness on the same device at a real throughput cost; bit-exactness across *different* devices takes the CPU reference path. Every run wears the strictness it ran at — never silently defaulted — and a declared tolerance has to be justified against what the operation actually does: a matmul cannot claim a loose tolerance to dodge conformance.
Even performance is stated with error bars. Training runs step by step so the gradient is correct, not fused, while kernel fusion fires on the inference pass — and the honest number a practitioner needs, the overhead that costs, is measured on the conformance corpus and republished with every engine version, never invented. The discipline generalizes: where we cannot measure, we do not quote.
Calibration is a feature you can build on
Publishing limits is what makes the guarantees usable. A stated boundary is one you can design a study inside; an unstated one is a landmine in your methods section. Reviewers, ethics boards, and your team do not need the platform to be limitless; they need to know exactly where its envelope sits. That is what a datasheet is for.
And none of it asks for faith. Where a bound can be checked automatically, it is checked automatically, and every failure surfaces through one loud channel instead of a silent fallback. Where it cannot — a browser's freeze heuristics, an operating system's sleep — the qualifier is printed instead, which is the same discipline by other means. The permissively licensed interchange ring — the schemas, the conformance corpus, the CPU reference — lets anyone, including a competitor, re-verify every correctness claim without asking us.
The limits are printed this precisely because the freedoms are absolute. Computation is never tier-gated, and paid content gates delivery, never execution. A register this exact cuts both ways: when this platform says *cannot*, it means physics; when it says *never*, it means a rule it cannot bend. Design your study inside the envelope we printed, and cite it without a footnote walking it back.