Tightly coupled compute
- Training a frontier model
- Tensor-parallel serving over NVLink
- Interactive chat at the lowest possible latency
Keep doing that on GPUs. The swarm is what you put next to them.
Liskov AI
Inference at the scale
of the world’s edge.
Every Acurast processor becomes an independent AI worker: a complete open-weight model, a task, a result. Point a batch, an evaluation, or a training loop at the swarm and let scale do the rest.
Early access We are building this with the first teams now.
01 — Built for scale-out
Don’t build one giant computer.
Build ten thousand small ones.
The most valuable AI work of the next few years is not one enormous forward pass. It is millions of independent ones: generate, evaluate, attempt, verify. That is work a swarm does better than a rack.
Embarrassingly parallel intelligence
- A complete small model on every worker, no worker waiting on another
- Throughput that grows with the fleet, not with a purchase order
- Geographic spread and real residential vantage for free
- Commodity hardware with no idle capacity to amortise
- A lost worker costs one retry, never the run
Horizontal scale, cheap hardware, and a bill that reads in results.
02 — Workloads
Work that scales out
instead of up.
Available
Roadmap
Roadmap01
Batch inference
Classify, extract, summarise, filter, rerank, and moderate across queues of any size. Spread the batch over as many replicas as it deserves and collect the results.
Throughput without a queueRoadmap02
Synthetic data
Question–answer pairs, reasoning traces, alternative solutions, adversarial and preference examples, generated wide and filtered by a verifier or a stronger judge.
Generate wide, filter hardRoadmap03
Evaluation and scoring
Run benchmarks, grade outputs, and score candidates across millions of samples, each one independent, each one a number you can trust.
Millions of samples, one billRoadmap04
Embeddings
Embed whole corpora with a small open-weight encoder on every worker, and get vectors back keyed to the input that produced them.
Wide and cheapRoadmap05
Agent rollouts
Coding, maths, data, and browser agents attempt tasks in isolated environments. Every attempt is a trajectory; a separate verifier scores it. Millions of them feed your training loop.
Experience generation for RLResearch06
Bigger models, nearby workers
Split a larger model across a handful of processors that measure close to each other on the network, so the swarm reaches models no single phone can hold.
Topology-aware, measured firstEach workload lands with a listed Marketplace offering, published example code, and a recorded run behind it. See the release sequence →
03 — Experience at scale
Your GPUs learn.
The swarm explores.
Reinforcement learning has two halves: expensive, synchronous weight updates and cheap, asynchronous experience generation. Liskov takes the second half and gives your training cluster a world of workers to learn from.
Learn
Backpropagation, optimiser steps, checkpoints.
- Publishes a model version
- Receives verified trajectories
- Never waits on a worker
Explore
Independent workers, each with the model, a task, an environment, and a budget.
InferenceToolsEnvironment
RetriesVersionsAttribution
Prove
Reward is computed where the worker has no say.
- Clean checkout, patch applied
- Tests run, result recorded
- Trajectory tagged with its model version
04 — Four ways in
Launch it. Copy it.
Or just call it.
Use the swarm the way your team already works: a Marketplace launch, a repository you own, or an endpoint your existing client already speaks.
A Marketplace offering
Configure a model, a task source, and a result sink, then launch as many replicas as the batch needs. Pull-based, so your endpoints stay yours and no worker needs a door opened to it.
Example code and a guide
The worker, the client that submits tasks and collects results, and a walkthrough from a forked repository to a completed batch. Copy it, change the model, ship.
An OpenAI-compatible endpoint
One Liskov URL in front of a replica fleet, usable from any client that already speaks the OpenAI API. Point your batch at it and the swarm does the rest.
Verified results
Every paid result is checked before it is charged, so what you pay for is work that actually happened. Verification is part of the product, not a premium tier.
05 — Priced by result
Not a GPU-hour.
A useful result.
The swarm does not compete on FLOPS. It competes on what a batch, an evaluation, or a verified trajectory actually costs you, with failures, retries, and verification already inside the number.
Commodity hardware, no idle capacity to amortise, and work that never waits on a neighbour. That is the cost curve we are building toward, and the one we will publish.
cost / million useful tokenscost / million evaluated samplescost / verified trajectorycost / passing coding taskcost / GPU-hournot the metric
06 — Open by design
Open weights. Open data.
Clear boundaries.
The swarm is built for the open-weight era: models you can distribute freely and data you are happy to run anywhere. That is where its scale is unbeatable, and we are clear about where it stops.
Open weights
Openly licensed models, or your own where sharing them is fine. Published once, versioned by content address, cached on every worker that needs them.
Open data
Public datasets, synthetic tasks, open-source repositories, and any inputs you are comfortable running on an independent processor.
Private models
Fine-tunes and adapters whose weights are the product stay on infrastructure you control.
Sensitive prompts
Personal and regulated data belongs on a path built for it. A worker on the swarm sees what it runs.
The full picture of what a workload exposes is in the trust and data boundaries →
Early access
Bring the workload that needs
ten thousand workers.
We are onboarding the first teams now. Tell us the model, the task shape, and the volume, and we will build the first offerings around what you actually run.