# Dedicated seats

A dedicated seat is a size in units that sets how much a wallet's Macs can mine. It pays nothing up front. Each seat is carried by one of the wallet's Macs and earns at the smaller of the two classes.

## The seats

| Seat | Id | Price | Units | MLX a day (cap) | MLX an hour | Mined MLX locked | Full rate on |
| --- | --- | ---: | ---: | ---: | ---: | --- | --- |
| Nano | `N` | $50 | 0.5 | 4 | ~0.17 | 20 days | any Mac |
| Lite | `T` | $100 | 1 | 8 | ~0.33 | 14 days | any Mac |
| Core | `S` | $250 | 2.5 | 20 | ~0.83 | 10 days | any M chip |
| Pro | `M` | $1,000 | 10 | 80 | ~3.33 | 7 days | Pro or Max |
| Ultra | `L` | $4,000 | 40 | 320 | ~13.33 | 3 days | Ultra |
| Core Latest | `SX` | $375 | 3.75 | 30 | ~1.25 | 10 days | newest base |
| Pro Latest | `MX` | $1,500 | 15 | 120 | ~5 | 7 days | newest Pro or Max |
| Ultra Latest | `LX` | $6,000 | 60 | 480 | ~20 | 3 days | newest Ultra |

"MLX a day (cap)" is 8 MLX per unit a day (`seatPerDay` in `lib/chain/curve.ts`). It is a ceiling. What a seat really earns each hour depends on its Mac's score and on the pool's release (see [Compute rewards](/protocol/rewards)). The table comes from `TIERS` in `lib/chain/curve.ts`. The ids are kept from the first launch: `S` is Core, `M` is Pro, `L` is Ultra, and the `X` ids are their Latest editions.

## Units

One unit is $100, so a seat's units are its price divided by $100 (`multiplier` in `TIERS`). Units do three things:

- They are the seat's **weight** in the hourly reward split.
- They set the seat's **cap**: 8 MLX per unit a day, or 8/24 an hour.
- Buying a seat moves the network's **position** on the price curve forward by its units (`grantNode` in `lib/chain/ledger.ts`). A Builder grant is the exception: no dollars moved, so the position stays where it is.

## Classes

The three class seats follow Apple's chip classes. `chipClass` in `lib/chain/curve.ts` reads the chip name a Mac reports (`M4`, `M3 Pro`, `M5 Ultra`):

| Chip | Class | Carries in full |
| --- | --- | --- |
| Base M-series (`M1` … `M6`) | `S` | Core |
| Pro or Max | `M` | Pro |
| Ultra | `L` | Ultra |
| One of M6, M5 Pro, M5 Max, M5 Ultra | its class, marked Latest | the Latest edition of its class |

A Latest edition costs and weighs 1.5× as much as its seat (`LATEST_MULT`). It earns its extra weight only on Apple's newest chip in its class, listed in `LATEST_CHIPS`. A chip name with no M-series chip in it counts as a base Mac.

Nano and Lite are **starter seats** (`starter: true`). They are smaller than any class, so any Apple silicon Mac carries them in full. They have no Latest edition.

The class a Mac is carried at is the *checked* class. The server checks the chip a Mac claims against Apple's model identifier and against the speed it measures for that Mac. The check can only lower a class, never raise it. See [Jobs and checks](/protocol/jobs#chip-checks).

## Pairing seats with Macs

Each hour, `pairUp` in `lib/compute/seats.ts` matches a wallet's seats with the Macs that worked for it that hour:

1. Seats are sorted biggest first: by units, then by seat number (`seatsOf` in `lib/compute/rewards.ts`).
2. Macs with a score above zero are sorted biggest class first, then Latest before not, then by score.
3. The first seat goes to the first Mac, the second to the second, and so on.

Each pair earns the units `carriedUnits(seat, mac)` returns:

- A starter seat earns its own units on any Mac.
- A class seat earns the units of the **smaller** of the two classes. It earns the Latest edition's units only when both the seat and the Mac are Latest.

So an Ultra seat on a MacBook Air earns as a Core seat. A Pro Latest seat on an M4 Pro earns as a Pro seat.

What follows from this:

- **A seat with no Mac earns nothing that hour.**
- **A Mac with no seat left earns nothing**, if its wallet holds any dedicated seat. The free seat is only for wallets with no dedicated seat at all.
- The wallet's row in the hour's split has weight = the units carried, and score = their units-weighted average score, capped at 1. So weight × score = Σ units × score over the pairs.

## What a seat pays up front

Nothing. A seat bought at or after `SEAT_REWARD_END_AT` is recorded with `reward: "0"` (`grantNode` in `lib/chain/ledger.ts`). What it buys is the higher mining rate above, earned hour by hour from `compute.mlx`.

Seats bought before that time were paid the curve integral for their units up front, from `rewards.mlx`, locked for the seat's lock-in. The referrer, if any, got a share of it from `community.mlx`. A seat bought after the cutover that was still paid the lump gives it back through the `seat_reward_return` system transaction: the seat's lump goes back to `rewards.mlx` and the referral bonus to `community.mlx`. The seat keeps its units, number and mining rate. Referrals kept counting, and since 29 Oct 2026 they pay on mining instead ([Mining referrals](/protocol/rewards#mining-referrals)).

## Buying a seat

A seat is bought with the `buy_node` transaction (see [Transaction types](/transactions/types)), or through the crypto checkout, which records it once the payment arrives.

- `pay` set to `USDC` or `USDT` pays the price from that balance. With no `pay`, USDC is used first, then USDT.
- `pay: "WALLET"` pays from the whole wallet: USDC, then USDT, then just enough unlocked MLX sold at the spot sell price. See [Paying from the wallet](/protocol/curve#paying-from-the-wallet).

Seats are numbered in order across the network. Their records are public at `/api/node/<id>`, and the [Seats API](/network/seats) lists them.

## Giving a seat to another wallet

A seat can be given to any other wallet with the `transfer_seat` transaction (see [Transaction types](/transactions/types#transfer-seat)). It keeps its number, tier and lock-in; from then on it is carried by the new holder's Macs and counts for the new holder's lock-in. MLX it already mined stays locked with the wallet that earned it. The recipient must have confirmed it isn't a US person.

## Fit badges

`seatFit(tier, mac)` in `lib/compute/seats.ts` is the one rule behind every badge on mlx.app, in the wallet, at checkout and in MLX Node:

| Fit | Meaning |
| --- | --- |
| `best` | The biggest seat this Mac mines in full: its class, or the Latest edition on Apple's newest chip. |
| `ok` | A smaller seat this Mac mines in full. Starter seats are always at least `ok`. |
| `not` | Bigger than this Mac carries, or a Latest edition on an older chip. It would earn as a smaller seat here (`as`). |
| `unknown` | The Mac isn't known. No badge. |

A `not` seat can still be bought. The wallet shows what it would earn on this Mac and what it would earn on a Mac of its class (`fitRates`). MLX Node gets the same verdicts in its heartbeat reply, as `earning.offers[].fit` (see [The worker protocol](/node/worker-protocol#hello)).
