The Engineer

Where the v1 nodes are hiding

cgroup v1 rarely survives on the nodes anyone looks at. Start with long-lived base images: Amazon Linux 2, Ubuntu 20.04, and CentOS/RHEL 7- and 8-era hosts. They shipped with v1 defaults, pre-5.8 kernels, or both. Next are custom AMIs and golden images nobody has rebuilt in two years. After those, check the pools that rarely get touched: GPU, batch and on-prem.

A node has to clear four separate floors. Each one can fail an upgrade on its own:

The failCgroupV1: false override exists. Record each use as a dated exception with a named owner, with an expiry. Switching cgroup mode already needs a boot parameter change and a reboot. Rebuilding the image and rolling the pool costs about the same as patching hosts in place. The rebuild also leaves no override behind to forget.

What v2 changes on day one

• Whole-container OOM kills. The OOM killer now kills the entire container, not one process. That ends the zombie pod, where a worker died and the supervisor kept the container looking healthy. Restart patterns in dashboards and on-call runbooks will change.
• PSI metrics on by default. Pressure Stall Information records how long tasks stalled waiting on memory, CPU or I/O. It is a better saturation signal than utilization. It is the instrument to have in place before enabling swap.
• In-place Pod-level resizing without recreating pods. Memory QoS with memory.min/memory.low tiering is still alpha in v1.36. Do not design around it yet.

Reading the swap numbers honestly

Node swap works only because cgroup v2 accounts for swap separately. Chris Short highlights GKE benchmarks run on NVMe Local SSDs. Next to the 3x sandbox result, they show the upside and the cliff:

• gVisor headless Chrome went from 80 to 160 pods per node.
• A Linux kernel build with its memory limit halved from 600 MB to 300 MB finished faster: 374s against 433s.
• The same build at 200 MB ran more than 40% slower.

The middle result looks backwards. The source does not explain it. We think this is what happens, though we have not tested it. Without swap, the kernel can reclaim only file-backed pages. A memory-constrained build evicts the page cache it needs and rereads from disk. With swap, cold anonymous pages go out instead and the hot file cache stays resident. At 200 MB nothing cold is left, so the build pages its own working set.

Size node pools on RAM alone and treat swap as headroom for idle and bursty pages. Adding the two together is how a pool reaches the cliff.

The tests ran on local NVMe, the first of three caveats on the headline figure. Network-attached block storage will have much worse swap-in latency. The baseline configuration for the 433s run is not given, so treat the build gain as directional until it is reproduced. Anything in anonymous memory can land on the swap device. Swap encryption and local-disk lifecycle are therefore part of the design.

The smart move

The order is sweep, gate, then harvest. The sweep takes an afternoon with a DaemonSet or kubectl debug node/.... The gate is a pipeline precondition of zero v1 nodes, with one pool canaried through kubeadm preflight before the fleet. After that, prototype swap. Setup is a few lines of KubeletConfiguration with LimitedSwap, applied to Burstable pods on mostly-idle workloads such as agent sandboxes, headless browsers and CI runners. Latency-sensitive services stay on Guaranteed QoS. LimitedSwap does not apply there.

What the deal doesn't tell you yet

Techpresso gives dates but no deal terms. It does not cover Deno KV data hosted on Deploy, the JSR registry, or what the migration help offered to paying customers actually includes. Those gaps decide which exit is viable. We would get answers in writing from the vendor contact before building a plan on assumptions.

Ryan Dahl and Bert Belder will merge Deno's open-source Celld project into Cloudflare's Workerd runtime. The merged platform is meant to run on self-managed infrastructure, with a standard object storage bucket as its only coordination dependency. If that holds, it removes the consensus cluster, which is the part that makes self-hosted edge runtimes painful to operate. It is a good goal but unverified, and we'd want four answers first:

• Which primitives it assumes, such as conditional writes, compare-and-swap or lease objects. S3-compatible stores do not all support the same set, so “standard bucket” may quietly mean S3 semantics.
• Whether the request hot path ever touches the bucket.
• What running isolates do when the bucket is slow or unavailable.
• What coordination traffic costs in request volume at a given node count.

Four exits, compared

The deciding variable is API surface. Handlers written to web standards (fetch, Request/Response, Web Crypto, Streams) are the cheapest port to Workers. Code that leans on Deno.serve, Deno.env, Deno KV, Deno.cron or deno compile costs roughly the same to port anywhere. For that code, operational fit is the better basis for choosing.

The rehearsal most teams skip

The WEF's Next-Generation Computing Framework, covered by Exponential View, names the gap this deal makes concrete: resilience planning that assumes “peacetime” access to suppliers. Most game days simulate availability failures, such as a region going down or a dependency timing out. Few simulate access failures, where a license server returns a valid 403, an IdP suspends the tenant, or a model API retires the pinned version. Access failures are cleaner and worse than outages because no timeout trips the circuit breaker. The caller gets an authoritative no.

We are running the Deploy sunset as an access-failure drill, because most failover plans have never rehearsed one.

Deno customers got roughly six months of notice. The next vendor may give less. We'd set the internal Deploy cutover for end of Q1 2027 rather than April, because six-month sunsets lose their last month to stragglers, DNS cutovers and data export. We would also stop greenfield work on a runtime with a twelve-month security horizon. The same rehearsal is worth running against dependencies that haven't announced anything yet.

The argument both camps share

Georgetown's Justin Thaler gave the a16z crypto panel its cleanest line: AI “cannot find the nonexistent algorithm.” That protects the math only conditionally. It holds if no efficient algorithm exists. Nobody can prove that today. Dan Boneh ties the proof to P versus NP. Boneh also admits that model skill at cryptanalysis is unmeasured. Asked whether models are bad at cryptography, he says: “We don't know.” Justin Drake's “bunker mode” warning, relayed by Exponential View, sits at the other pole with no paper and no demonstrated break behind it. Neither camp claims an assumption has actually moved.

Both sources cite the same precedent. In 2022, SIKE, a NIST post-quantum candidate, fell to classical mathematics in roughly an hour on a single core. The Rainbow signature scheme fell the same year to an attack that ran for a weekend on a laptop. Neither break used a quantum computer or a model. Each took one insight against a young, structured assumption. That is why Boneh's sharpest warning matters: a model could “look at our post-quantum systems and potentially weaken them in some way, maybe break them altogether.” A post-quantum-only migration trades one bet for another.

Three attack surfaces, three answers

We expect the first row to move first. Thaler concedes “the surface area for bugs just gets very large,” and cheaper model analysis helps attackers as much as defenders. Boneh puts the defender's edge before deployment. After ship is “the wrong time to attack a cryptosystem.” That argues for AI review before merge on crypto-touching code. A failed AI attack reads like a fuzzer reporting zero crashes. It describes what that model searched. It says nothing about what attacks exist. Re-run the review when model generations change.

Hybrid covers one failure; agility covers the next

Hybrid elliptic-curve-plus-lattice encryption already runs on some internet connections. Boneh's reasoning for it is sound: “If you break elliptic curves, it doesn't matter because it's also encrypted under a lattice-based system.” Now take the scenario he raises himself, where AI weakens the lattice half. Hybrid falls back to classical-only security and the algorithm has to be swapped. That swap is cryptographic agility, and it has its own failure mode. JWT alg-header confusion and TLS downgrade attacks show what happens when the peer picks the algorithm. Keep the allowed list server-side and set by policy.

The engineering cost is mostly bytes. ML-DSA-44 signatures run about 2.4KB. Ed25519 signatures are 64 bytes. Base64-encode one inside a JWT in a header and it collides with common ~8KB proxy header limits. Better to find that on an internal path than during a forced migration. Hybrid X25519MLKEM768 key exchange adds roughly 1.2KB to the TLS ClientHello. Current browsers, major CDNs and OpenSSL 3.5+ support it. On enable, watch for middlebox breakage and handshake p99.

One caveat on the panel: weigh its “FUD” framing against a16z's portfolio exposure to elliptic-curve-secured assets. Its technical claims still match mainstream cryptographic consensus.