The world’s AI runs in data centres.
Not all of it has to.
Every Justworx device has a processor, a secure connection home, and time on its hands. Multiply that by the millions we’re building toward and you’d have something the AI industry doesn’t have enough of — and can’t easily build.
The model is the visible cost.
The pipeline feeding it isn’t.
Ask what an AI company spends money on and everyone says GPUs. Behind them sits an enormous, continuous, unglamorous pipeline that has to run before a model ever sees a token — collection, cleaning, filtering, deduplication, vectorisation — growing with every corpus, every refresh cycle and every new retrieval index.
Grid is not a GPU alternative. We say that plainly, and we say why further down. Grid targets the layer beneath — and that work has a specific shape which happens to fit a distributed fleet precisely.
Work that was always going to split.
Modern AI doesn’t rely on trained knowledge alone. Retrieval-Augmented Generation means that before a model answers, the system searches a vector index — a database storing every document as a numerical vector capturing its meaning — and feeds the best matches into the model’s context.
Building that index means running every document through an embedding model: hundreds of millions of small inference jobs for a large corpus, recurring as content changes and wholesale whenever the embedding model is upgraded.
The unit of work is tiny — a chunk of 200–500 tokens in, a few kilobytes of vector out, no dependency between chunks, no shared state, no ordering. Embarrassingly parallel by nature, which is the one property that makes a job portable off a cluster at all.
AI companies need vast, continuously refreshed, geographically diverse web data, and they hit rate limits, geo-blocks and datacentre-IP blacklists constantly. An entire industry exists purely to solve this, and it sells distribution, not compute.
A fleet of Justworx devices, spread across continents, industries and network paths as it grows, is structurally diverse in a way no data centre can replicate. Here the value isn’t FLOPS — it’s independent endpoints in countless different places, and it scales with fleet size regardless of how fast any single processor runs.
Before data reaches a training run it has to be cleaned: near-duplicate detection using minhash and simhash, PII detection and redaction, language identification, spam filtering, boilerplate stripping.
Grid takes the per-document half — computing hash signatures, running classifiers, flagging personal data. The global clustering step that joins those signatures across a corpus stays central, because it’s genuinely all-to-all. Splitting the job along that line is the point.
Batch, not real-time.
That’s the whole trick.
Distributed AI compute has repeatedly failed because people try to make thousands of small devices behave like one big GPU. Splitting a neural network layer across devices — tensor-parallel matrix multiplication — requires constant, microsecond-latency communication mid-computation. Over a wireless mesh that’s physically hopeless.
Grid does the opposite. It accepts only work that is:
- Independent — no unit of work talks to any other.
- Reductive — whatever goes in, what comes back is small. Where the input is large, the node fetches it over its own connection rather than having it shipped down the mesh, so the only traffic Grid carries is the compact result.
- Latency-tolerant — a batch job, not a live user request.
That last point makes everything else possible. Corpus indexing is a background job. Nobody waits on any single document. What matters is aggregate throughput measured against a freshness target.
And the honest version of that: an edge node isn’t slightly slower than a data-centre GPU at this work. It’s dramatically slower, by orders of magnitude. What changes the picture is the count on the other side of the multiplication and the fact that nobody is waiting. The question Grid answers is never “how fast is one node” — it’s “does total fleet throughput keep this index inside its freshness window.”
The section that makes the rest believable.
- We don’t beat a GPU on price per vector, and we won’t claim to. Embedding is among the cheapest things in the AI stack. Grid’s case rests on what a data centre structurally cannot do — be in millions of places at once, collect and process in the same hop, and run on capacity that gets deployed and powered for another job anyway.
- Coordination is the real engineering problem, not compute. Scheduling, retrying and verifying work across millions of intermittently connected devices is a serious distributed-systems challenge. Our advantage is that we’ve spent six years building fleet orchestration and every device carries unforgeable hardware identity — so verification can be targeted rather than blanket replication. We don’t think that makes it easy.
- Today’s silicon does this slowly. ESP32-class modules can run small quantised models, and techniques that keep embedding tables in flash while the compute-dense layers stay in fast memory extend that further than we expected. But minutes-per-chunk is the honest current figure. Grid becomes practical on our Cortex-class modules, and we’d rather say so than imply otherwise.
- Consent is non-negotiable. No device contributes without the explicit, informed agreement of its owner. Anything less isn’t a network — it’s a liability.
Honest about the distance.
The building blocks: an AI-managed private mesh, hardware identity fused into every unit, and no-code fleet orchestration — the platform Grid will run on. The fleet itself is early, and grows with every product our partners ship.
Cortex-class modules — a step change in on-device memory and compute that brings real quantised model inference and document processing within reach of a single node.
A distributed work queue across consenting devices, offering AI companies a collection and preprocessing layer at a cost structure nobody with a data centre can match.