Distributed compute: pools, jobs, and trust

Scellis has exactly one mechanism for distributed compute. A content-addressed Job is partitioned into Shards, the Shards are executed by a Pool of peers, the results are combined by a declared Reduction, and every result is verified before it is accepted. That is the entire model. A Pool of size one is an ordinary solo run — the same code path, fully offline. Federated learning is one configuration of the same mechanism, never a separate subsystem. What changes across that range is not the machinery but the trust around it, and this page states the limits as plainly as the capabilities.

One mechanism, many workloads#

Pooling is not a training feature. Parameter sweeps, Monte-Carlo simulations, ensembles, k-fold cross-validation, and batch analysis all ride the same Job → Shard → Reduction path, because they share one shape: independent pieces plus a declared way to combine them. Training rides it too — as one configuration, not a privileged one. And the work renders live as Shards land: a sweep's heatmap fills in cell by cell, a training run draws a converging loss curve that everyone in a shared session watches at once.

Everything strategy-shaped in this mechanism is content, never engine code. Partitioners, reducers, aggregation strategies — FedAvg, FedProx, SCAFFOLD, DiLoCo, and FedBuff ship as built-in content — and Pool topology are user-authorable entities like any block, never a hardcoded switch. If the aggregation strategy you need does not exist, you author it, and it travels the same catalog path as everything else.

Three trust regimes, never collapsed#

Who is in your Pool changes what is safe, so Scellis refuses to blur it. There are three trust regimes, and the platform never collapses them into one soothing setting.

The boundaries are enforced, not advisory. A safety-critical configuration refuses to launch on an open pool — loudly, by construction, in the same diagnostic format as every other refusal on the platform. And open data-parallel work is restricted to public input data, because strangers running Shards over private data is not a setting anyone should be able to reach by accident. The inverse is just as honest: a confidential model or dataset refuses the open pool, since executing peers necessarily hold what they compute on.

Verified on arrival, metered in receipts#

A remote result is never trusted on arrival. Depending on what the Job declares, it is checked against the deterministic CPU reference within a declared tolerance, spot-checked at an unpredictable fraction, or quorum-replicated across independent peers — and only then accepted into the Reduction. Freivalds probabilistic checks cut the verifier's cost on matmuls, and paid verifiers are themselves kept honest by planted canary shards with known answers. The full verification regime is the correctness story, extended across devices.

Accepted work mints a receipt in a hash-chained ledger, and contribution is metered in verified work-units, never wall-clock — wall-clock pays for slowness and is forgeable. Each unit carries a planner-derived cost the provider cannot inflate. Altruistic pooling — your own devices, volunteers, a consortium — is fully live today and involves no payment rails at all. The paid compute marketplace, with payouts, escrow, and staking, is the named forward path, built on exactly these receipts; it ships as one indivisible unit, because shipping payouts before the fraud-deterrents would make Sybil-farming profitable.

What scales — and what does not#

Synchronized training is a stable cohort's game, never an open swarm's: peers must exchange updates, and that exchange — not compute — becomes the wall, so churn rather than arithmetic is the dominant cost. A second limit hides behind “scaling” and deserves its own sentence: data-parallel pooling replicates the full model on every peer, so it multiplies throughput but cannot fit a model too big for one device. Fitting bigger models is a different path — the Relay path, where layers are relayed across devices, or sharded optimizer state. No numeric speedup multiplier is ever promised; the named mechanisms are the claim. The honest-limits page catalogs each of these, error-bar by error-bar.

Fair to the volunteer, honest about the network#

A Shard you execute for someone else runs as pure compute with no effect grants: it structurally cannot read your local data, your credentials, or your network. You keep a budget governor — a battery floor, a two-click stop. And contribution needs a foregrounded, plugged-in device, because the browser freezes background tabs: a tab in the background is not computing, and Scellis will not pretend it is.

Pooled compute is also not serverless, and this page will not call it that. A Pool session needs an online coordinator for the session's duration — “serverless” describes the data plane on cooperative networks, never the control plane. The coordinator schedules Shards and brokers connections; it never touches tensor bytes on the happy path (a coordinator object cannot sum a tensor — only peers reduce), and it is never required for solo work. On cooperative networks most home connections traverse directly peer-to-peer via STUN at zero relay cost; symmetric and corporate NATs fall back to a relay, which is then the honest steady state for that setting. Very large pools federate the coordinator into a hierarchical tree so control fan-out stays bounded.

Federated learning: what actually leaves a site#

Federated learning is the configuration where the data stays put and the model travels. Raw data never leaves a participating site as bytes. But model updates do leave — and an update is a lossy, sometimes-invertible function of the data it was computed from. Byte-exclusion alone is therefore not a privacy guarantee, and Scellis never presents it as one.

That is why accounted differential privacy with clipping is always engaged for any regime beyond your own devices, tracked by a monotonic privacy-budget ledger that refuses overspend — a live (ε,δ) meter sits in the round monitor. Secure aggregation is layered on where feasible, and is mandatory in cross-silo settings; it hides each individual update but releases the aggregate, so it does not substitute for DP. And the scaling claim stays honest here too: federated learning buys statistical power — more participating sites, more local examples behind the model — not a faster wall-clock.

One mechanism, three trust regimes, receipts instead of wall-clock, and limits printed on the datasheet instead of discovered in production. Reproducibility is declared two-tier — replayable on the oracle path and convergent within tolerance on the GPU path — so a distributed result cites committed versions, never a cross-device hash. And a Pool of size one is the same machine — running with the network cable unplugged.