Corvis

Understand it. Build with it.

How the fleet is laid out

Engineering account · Reviewed 2026-11-18

Suppose a dozen spare computers are available for automated work: running test suites, building software, serving a few services. Before deciding which job goes where, there is an earlier question. Which machine is allowed to do what, and which machine must never be asked?

This page answers that for the Corvis fleet, as its configuration declared it on the review date. It is a first-party engineering account, reviewed against the configuration and code that declare each machine's role. The companion guide, Fleet job queues, follows a single job through the queue; this one describes the machines the queue hands work to. Public references support the general techniques; they are not independent verification of this fleet.

Twelve computers, four roles

The fleet is twelve PCs, and each has exactly one role.

Role How many What it does What it never does
Entry machine 1 Hosts the interactive coding sessions people work in. Run fleet work. Asking it to run a project's test suite is refused, and the refusal points to the command that runs the suite on the fleet instead.
Control hub 1 Runs the fleet's own jobs: deploying new versions, ticking the job queue, auditing results. It also starts and looks after the sessions on the entry machine, from across the network. Nothing is withheld; it takes ordinary checks too, and carries the workers' toolchain for them.
Stack server 1 Runs the platform's services (43 of 46 of them) on a desktop with a large GPU. It has no desktop environment and boots straight into its services. Take ordinary queue work. Only checks pinned to it by name run there.
Workers 9 Take checks from the queue. Two of them also hold a duty, described below.

Keeping these apart is what lets many automated sessions share the machines without collisions. The entry machine stays responsive because nothing heavy runs on it: code written there is checked on a worker. The stack server keeps its capacity for the services it hosts. The workers, which can be wiped and rebuilt, absorb the work that might misbehave.

One holder for each duty

Some jobs must be done by exactly one machine. In this fleet they are called duties:

Duty What its holder does
Control The fleet's own jobs: proving and deploying new versions, the queue and its ticks, the audits.
Sessions Starting and tending the entry machine's sessions over the network.
Storage Keeping the fleet's mirrored storage pool and sharing its directories with the other machines.
Network install Answering the network boots that install a machine's operating system.
Devices Running the software for the phones and printer plugged into its USB ports.

The control hub holds the first two. A tower server among the workers holds storage and network install, and another worker holds devices.

One file declares the duty vocabulary, and each machine's entry in the roster names the duties it holds. The fleet's tooling refuses a roster in which any duty has no holder or more than one, and building the system configurations fails the same way for storage and network install. Moving a duty to another machine is therefore a one-line change, and the services that implement the duty follow it.

How work reaches a machine

Nothing pushes work at a machine. Each machine's runner pulls from one shared queue, and it asks only for projects that its machine's free memory and cores can fit at that moment. A machine with room for a small suite therefore never takes a large one and then has to refuse it.

Two runners asking at the same instant never receive the same job: each claim uses PostgreSQL's FOR UPDATE SKIP LOCKED, which lets a transaction pass over a row another transaction has already locked.1 The Fleet job queues guide covers this, and what happens when a worker disappears, in depth.

Once running, a check lives in its own resource slice on the worker. If the machine comes under heavy memory pressure, the check is the thing that gets stopped, not the machine's other work.

One configuration for every machine

Every one of the twelve PCs runs NixOS, built from one shared configuration on one pinned set of packages. The workers share a single machine description, filled in with each machine's own details from the roster; the few machines with special hardware or jobs add a file of their own beside it.

After each deploy, the control hub builds every machine's system into a shared cache. A machine is moved onto its new system with a single command. No job switches the fleet over automatically.

A worker can be wiped and reinstalled over the network, without anyone at its keyboard. The machine that serves those installs is the one exception. It serves every install, its own included, and it holds the fleet's only copy of the shared data, so its roster entry deliberately leaves it unable to be wiped this way.

What this account does not establish

This page describes the configuration as it was declared on the review date. It is not a benchmark, and it does not show that every machine was powered on or healthy at any given time. The machine count and the duty holders change as hardware joins and leaves; the roster, not this page, is the current record. Machine names, addresses and other identifying details are deliberately left out.

All citations below lead to public primary material. They explain the general mechanisms used here. The fleet-specific behavior is this page's first-party engineering account, not an independently reproduced result.


  1. PostgreSQL 16: SELECT, The Locking Clause, paragraphs on SKIP LOCKED, inconsistent views, and row-level locks. ↩