§ Platform
Draw a workflow and it runs on the GPU already in your machine — through training, through collaboration, through publication. This page is the map; every stop on it goes one level deeper.
§ In short
01
The browser talks to the graphics card already in the machine in front of you — Apple, AMD, Intel or NVIDIA, laptop as readily as workstation. Nothing to install, no CUDA, no cloud meter: training runs where your data already is. On a device with no usable GPU the same work still runs, more slowly, and the app says so rather than pretending.
02
Colleagues open the same workflow and work on it live, each on their own machine — and many devices taking one job together, for when one machine is not enough, is in active bring-up: your own laptop and desktop, a partner lab's workstations, or an open pool of volunteers lending idle GPUs. Returned work is spot-checked against independent replicas, and a result no replica confirms is marked unverified and earns no credit.
03
Every saved result carries the exact workflow, inputs and settings that produced it. A finished run already travels as a login-free link carrying its frozen, content-hashed metrics and figures; the link a colleague — or a reviewer — opens to re-run a whole workflow on their own hardware, with the tolerance stated instead of assumed, is still being wired into the Studio.
Open a tab and the GPU already in your machine starts working. You draw a workflow; the Studio turns it into GPU code and runs it on the device in front of you, so your data never has to leave and training is a real workload rather than a demo. Everything you compute with — blocks, models, viewers, connectors — arrives from the catalog as you reach for it, which is why new capability shows up without an install.
Every result you commit gets a citable identity: the workflow, its inputs, the engine version, and the run, pinned together into a link you can put in a paper, a message, or a README. A colleague who opens a finished run's link today does not see a screenshot but its frozen, content-hashed metrics and figures, checked on open; the link that re-runs the same computation on their hardware is still being wired into the Studio. And because the whole platform is driven by one set of commands, what you click, what a script calls, and what an assistant does on your behalf are the same actions under the same guarantees.
And a workflow is not confined to one machine, or to one person. The same drawn workflow can be edited live by several people at once while each participant's data and computation stay on their own device — and when one machine is not enough, the work is built to split across a pool of devices: your own laptop and desktop, a partner lab's machines, or an open crowd lending idle GPUs, with a share of the returned results re-run on a second device and compared. The coordinator behind that is built and tested; running pooled work in real browsers is in active bring-up. A pool of one is an ordinary solo run on the same path, so nothing you build depends on anyone else showing up.
Seven commitments hold everything else in place — each one built into the architecture, most of them checked automatically.
| Parameter | Value | Note |
|---|---|---|
| Compute | your own GPU | The GPU already in your machine does the work — whatever make it is, with nothing to install — and every result is checked against a reference within declared tolerances. |
| Together | one workflow, many devices | Your own devices, a partner lab's, or an open crowd are built to compute one job together — a share of results re-checked on a second device, in active bring-up in real browsers — and a pool of one is simply a solo run. |
| Capability | arrives without an update | New blocks, models and viewers appear in your catalog as soon as they are published — nothing to install, and never a bulk download. |
| Identity | content-addressed | Work you commit carries an identity you can cite — a link, not a screenshot; re-running a whole workflow from it is still being wired in. |
| Training | first-class | Autograd, optimizers, schedulers, PEFT, mixed precision — in the tab, not beside it. |
| Access | click · script · assistant | Every capability is reachable all three ways, with no second-class route — one surface, full parity. |
| Cost of compute | never metered | Local computation is free on every plan — a rule of the architecture, not a limited offer. |
Draw, run, train, inspect — alone, at full power.
Everything one person needs to get from a blank canvas to a trained model and a result worth citing — with an assistant that holds exactly the tools you do, and nothing leaving the device unless you say so.
Where Scellis stops being a single-player tool.
Many people on one workflow, and many devices on one job — your own machines, a partner lab's, or an open crowd lending idle GPUs — while every participant's data and computation stay on their own device, and a share of the returned results is re-run elsewhere and compared. Live co-editing is built and tested; the pooled side is built and tested at the coordinator and in active bring-up in real browsers. It is not only for training: a parameter sweep, a Monte-Carlo run, or a batch analysis pools exactly the same way.
Not policies — construction.
Each promise below names the mechanism that keeps it — and it is the mechanism, not the promise, that gets checked. Where a guarantee has an edge, the edge is written down in the honest limits register rather than left for you to find.
The deepest bet: what you build here is not a second-class citizen.
Content you write runs through the same checks and the same dispatch as ours, down to GPU kernels and gradient rules — and the terms under which each layer is published, along with what the platform cannot do, are set out in plain language rather than in a footnote.
If you want the feel of it, the quickstart takes you from a blank tab to a committed first run. If you want the mechanics, the docs go from the core concepts all the way down to how a drawn workflow becomes GPU code. And if you want the terms, pricing is a single page with one rule at the top: local computation is never metered — on any plan, ever.