What is preemptible GPU capacity?

GPU time a cloud provider sells at a discount because it reserves the right to reclaim the machine with little warning. It is cheaper than reserved capacity, and it is only safe for work you can lose a slice of and redo somewhere else.

Why can lattice sieving run on preemptible GPUs when the linear algebra cannot?

Sieving checks candidates independently, so a reclaimed machine costs only the one relation it was working on. The block Wiedemann solve exchanges partial results between GPUs on every step, so a reclaimed machine stalls the whole domain until that step can be replayed.

How much did the RSA-260 run cost?

Cognition reports about **4,900 GPU-days** — roughly 13.5 GPU-years — at an estimated **$400,000** at market prices, using 233 Devin sessions and 14,450 ACUs. It credits its GPU lattice siever with about a 10× cost reduction versus the previous public state of the art.

Does this mean RSA is broken?

No. RSA-260 is a 260-digit number from a public challenge list, and factoring it set a public record for that list. Widely deployed RSA keys are 2048-bit, about 617 decimal digits, and the cost of the sieve rises steeply with the length of the number, so this result does not carry over to them.

GPU· 2026-09-18

Devin-built GPU sieving factored RSA-260 — Preemptible sieving vs the interconnect-bound solve — What does it mean?

TL;DR

What is it: Cognition's RSA-260 factoring run, published September 9, 2026, is a worked demonstration of stage placement — splitting one job by how much communication each stage actually needs, then renting each stage a different class of hardware.
Why it’s needed: Interconnect-tight GPU capacity is the expensive kind, so the cost of a large job is set less by how many GPU-hours it burns than by how many of those hours can be pushed onto cheap, interruptible machines — here, about 4,900 GPU-days for an estimated $400,000.
vs previous: The default is to reserve one tightly connected cluster for the entire job, which prices every stage at the rate its neediest stage demands; here the sieving stage instead ran on fragmented, preemptible capacity, and only the linear-algebra stage paid for NVLink and InfiniBand.

Jargon

GNFS: General Number Field Sieve. The standard algorithm for factoring large numbers. It runs in four stages, and they do not all have the same shape — which is the whole point of this article.
Lattice sieving: The stage that hunts for usable number pairs. Each candidate is checked on its own, so the work splits into billions of independent pieces.
Relation: One usable result from sieving. Cognition's run produced 8.3 billion of them. Losing one costs only the time it took to find it.
Block Wiedemann: The stage that solves one huge sparse linear system built from all the relations. Every step mixes data from across the matrix, so the machines doing it must exchange results constantly.
Preemptible capacity: GPU time a cloud sells at a discount because it reserves the right to take the machine back with little warning. Cheap, but only safe for work you can lose a slice of.
NVLink / InfiniBand: The two fast interconnects that let GPUs exchange data directly rather than through the host. Full explainer
CADO-NFS: The open-source number-field-sieve implementation the Devin sessions modified, rather than writing a factoring pipeline from nothing.
ACU: Agent Compute Unit, Cognition's billing unit for Devin work. The run consumed 14,450 of them across 233 sessions.

The news. On September 9, 2026, Cognition published a run in which parallel sessions of Devin, its coding agent, rebuilt the GPU side of CADO-NFS and factored RSA-260, a 260-digit challenge number, as a new public record. The run consumed about 4,900 GPU-days — roughly 13.5 GPU-years — for an estimated $400,000 at market prices, and Cognition credits its GPU lattice siever with about a 10× cost reduction versus the previous public state of the art. The detail worth keeping is not the record. It is where each stage ran: sieving spread over fragmented, preemptible GPU capacity, while the linear algebra leaned on NVLink and InfiniBand. Read the write-up →

Boxes and the piano

Picture moving day. Most of what leaves the house is boxes, and a box is a self-contained job: one pair of hands, down the stairs, into the van. You can hire help by the hour and let people come and go, because if somebody walks off halfway down the path you lose exactly one box — you do not lose the morning.

Then there is the piano. Four people have to lift it on the same beat, take the stairs at the same pace, and set it down together. You cannot staff that with whoever happens to be free at two o'clock, and you certainly cannot let one of them wander off mid-flight. That crew has to be booked whole, for as long as the piano takes, at the price a booked crew costs.

A factoring run has both kinds of work in it. The boxes are the lattice sieving stage, and Cognition's Devin sessions carried those on whatever GPUs happened to be going spare. The piano is the block Wiedemann linear-algebra stage, and it got the expensive crew.

Polynomial selectionsearch for a good polynomial pair

Lattice sieving8.3 billion independent units — the boxes

Block Wiedemannone shared sparse solve — the piano

Square rootrecover the factors

Why the two stages cannot share a machine

The general number field sieve runs in four stages, and the two that dominate have opposite shapes. Lattice sieving is boxes: it tests enormous numbers of candidates independently, and Cognition's run produced 8.3 billion usable results — called relations — with no candidate needing to know what any other candidate found. That is the same decomposition CUDA asks you to look for when you split a problem into threads and blocks: work that can be cut anywhere, because the pieces never talk.

The block Wiedemann solve is the piano. It solves a single huge sparse linear system built out of all those relations, and every step mixes data from across the matrix, so the GPUs holding the pieces have to exchange partial results with each other continuously. Cognition reports that this stage leaned on NVLink and InfiniBand — the interconnects the GPU track covers under NVLink & PCIe — for exactly that reason.

That difference is what decides the bill, because the cloud sells the two situations at different prices. Preemptible capacity is cheap precisely because the provider reserves the right to take the machine back, which makes it usable only for work whose unit of loss is small — the same property a production harness leans on when it decides what is safe to retry. Sieving qualifies. A synchronous solve does not.

Stage	One unit of work	Talks to other GPUs?	Hardware it can use
Lattice sieving	one relation, ~51 ms of one GPU — derived from ~4,900 GPU-days ÷ 8.3 billion relations, and an upper bound	No — candidates are independent	fragmented, preemptible capacity
Block Wiedemann solve	one iteration across the whole matrix	Yes — on every step	a reserved NVLink / InfiniBand domain

What one interruption actually costs

Hold two reported numbers fixed: the run consumed about 4,900 GPU-days and produced 8.3 billion relations. Charge every GPU-day to sieving — an upper bound, since polynomial selection, the linear algebra and the square-root stage all took GPU time too — and one relation works out to roughly 51 milliseconds of a single GPU (4,900 × 86,400 seconds, divided by 8.3 billion). Put the ~$400,000 bill through the same division and a relation is worth about $0.00005, five thousandths of a cent. That is the whole blast radius of a preemption on the sieving side: the provider reclaims the machine, the relation in flight is lost, and ~51 ms of work is redone somewhere else.

Now price the same interruption inside the block Wiedemann solve. Because every step waits on data from every other participant, a synchronous exchange proceeds at the pace of its slowest member — so losing one GPU there does not cost one GPU's work, it stalls every GPU in the domain until the step can be replayed. Same interruption, same hardware, but the unit of loss jumps from one relation to one iteration across the entire job. That gap, not the price per GPU-hour, is why the discount market is open to one stage and closed to the other.

The part that did not automate

The run used 233 Devin sessions and 14,450 ACUs, with a human holding an average of three and at most eighteen of them open at once — setting priorities, keeping comparable benchmarks in place so two sessions' results could be judged against each other, and redirecting work that had stalled. That is the coordination cost any agent team pays, and here it bought something specific: the split between the two stages was a decision somebody made, not a pattern the agents discovered. Cognition's own summary is blunt about it — "Like in many other cases, I believe that the human-engineered decomposition of the problem was essential to enabling the agents to make progress." The agents wrote the kernels; the decomposition that made cheap hardware usable came first, and came from a person.

Goes deeper in: GPU & CUDA → Memory Hierarchy → NVLink & PCIe

Related explainers

NVLink 6 multi-layer resiliency — Recovery escalation ladder — what the interconnect does when the link the piano crew depends on actually fails
NVIDIA Blackwell sweeps MLPerf Training 6.0 — Strong scaling — the opposite regime, where the whole job is the piano and every rank waits on the slowest

Frequently Asked Questions

Check what you knowMap your AI & GPU knowledge across every track — free, role-based