Altai

Capacity, from machines that already exist.

An open-weight model split across several computers, behind one OpenAI-compatible endpoint. A machine that cannot fit a model scores zero, not slow. Several of them together can serve it.

Private testnet · invite only

There is nothing to download here yet. Altai runs on its authors' machines and joining takes a token we hand out by name. Opening it to anyone needs one more piece of isolation between machines in a group, which is the work in progress.

Architecture

Who does what

The coordinator decides who plays which role. It never holds model weights and never sees a group's internal traffic.

whole

Holds a complete model. Serves a request start to finish.

head

Holds the embedding and output layers plus its own block. Drives its group and emits every token.

stage

Holds a contiguous block of middle layers. Runs them for every token. Never downloads the model file.

How a request is served Your app any OpenAI client /v1 coordinator assigns roles · routes holds no weights ONE GROUP — ONE UNIT OF CAPACITY head embedding + output its own layers emits the tokens stage layers 15–28 no model file nothing dials in stage layers 29–40 …as many as the model needs HIDDEN STATES ROLE ASSIGNMENT whole fits the model alone also one unit of capacity Requests reach a head, or a whole node. A stage is reached only by its own head, through a tunnel it dialled out.
Layer numbers are from a real 40-layer split. A stage holds only its own block, so a laptop can join a group serving a model many times larger than it could hold.

The argument

Why capacity, and not speed

The binding constraint on a frontier-class model is memory, not FLOPs. A fast GPU with 24 GB cannot hold a 600 GB model at any clock speed. Twenty of them can.

And capacity is what is scarce. Datacenter servers are supply-constrained — vendors say so in their own filings and expect it to persist — while the memory in workstations, gaming machines and office hardware is already built, already powered, and mostly idle. It is not waiting on a fab.

So the aim is not to beat a hosted API on price or latency. It is to serve a model that otherwise could not be served at all, for the people who need it, on machines that already exist.

The target

Where this is going

Sparse mixture-of-experts models — DeepSeek-V3, Kimi-K2 — are the problem this exists to solve. They are where the memory wall is worst and where it is most tractable: only a fraction of the experts fire for any token, so the weights that must be resident are far smaller than the weights that must be available.

The route is pipeline stages across a low-latency regional group, each stage running its own block of layers with that block's experts offloaded to ordinary system RAM. Experts never cross the network. Only hidden states do — on the order of 16 KB per token per hop. That is what makes a machine with plenty of RAM and a modest GPU useful, instead of only machines with datacenter cards.

This route does not run yet

In the engine we use, expert offload and pipeline parallelism are currently mutually exclusive — switching on offload disables the pipeline, verified in the engine's own source. The upstream change that would lift it is open and unmerged. Until then the sparse frontier is the design target and not a capability, and nothing here should be read as saying otherwise.

State

What runs today

worksOpenAI-compatible endpoint Tool calls, streaming, usage, error shapes. The compatibility suite is the project's main asset.
worksA model split across two machines A 14B model served by two ordinary Macs, neither of which can hold it alone.
worksJoining over the internet A node registering from another network, with a join token.
worksSleep and rejoin A laptop closes, the group re-forms, the laptop comes back.
not builtSigned receipts Responses carry a receipt id that currently refers to nothing. The next large piece of work.
not yetAnyone joining safely See the notice at the top. This is the gate on opening the network.

Roadmap

What comes next, in order

Intentions, not dates. Each one is listed because something concrete blocks it, and the blocker is named.

nextSigned receipts A node signs what it produced, before the coordinator sees the whole response — that ordering is what stops a coordinator forging an attestation. Blocked on putting the node in the request path, which is a change to how a request reaches an engine.
in progressOpening the network Role assignment must stop trusting a machine's own claim about its memory. Until a node's privileges come from something the coordinator can check, joining stays by invitation.
designingCPU-only nodes, sandboxed A machine with many cores and a lot of RAM and no GPU is not a lesser node — it is the machine the sparse route depends on, because offloaded experts live in system RAM. Running a sandbox around the node would let such a machine contribute general compute as well as inference. The sandbox is a thing to borrow, not invent; the open question is metering and what an operator is agreeing to run.
the targetSparse frontier models DeepSeek-V3, Kimi-K2 class. Blocked upstream: expert offload and pipeline parallelism are mutually exclusive in the engine today.

Limits

What it does not claim

It does not serve frontier models today. What has actually run is a 14B open-weight model split across two Macs; the near-term target is 32B–70B dense. The sparse-frontier ambition above is the problem being worked on, not a description of what you would get this morning.

It is not cheaper than a hosted API. At the speeds a pipeline across several machines runs, electricity alone costs more per token than the market price of a hosted model. The argument is capability, not price.

A receipt will be an attestation, not a proof. When they exist, a receipt will say that a node asserted it produced an output. A dishonest node can sign a false claim, and nothing here will imply otherwise.

Operators

Running a node

One file, opened. It profiles the machine, proposes how much to contribute, opens a page in your browser, and joins. No terminal, no Python, no Docker, no address to type. You set the ceilings; the coordinator never asks for more than you allowed.

export ALTAI_JOIN_TOKEN=<the token you were given>
open "Altai Node.app"

A stage downloads nothing — its head sends it the tensors for its own layers. Only a head or a whole node needs the model file on disk.