Up to 3× pod density is a benchmark, not a RAM budget cut
The Kubernetes Blog reports density gains of up to 3× from Local SSD swap across three workloads. I read that as a pilot case for idle-heavy agent sandboxes, not a cue to shrink memory budgets.

Key argument
The Kubernetes Blog reports density gains of up to 3× from Local SSD swap across three workloads. I read that as a pilot case for idle-heavy agent sandboxes, not a cue to shrink memory budgets.
A kubelet configuration stanza carries most of the weight in the Kubernetes Blog post Scaling Kubernetes Workloads with Node Swap: it tells a node to stop refusing to start when swap is present and to hand pods a limited slice of disk-backed memory. Around that stanza the Kubernetes Blog wraps a benchmark of three workloads, a Linux kernel build, sandboxed headless browsers and isolated Python runtimes, and reports density gains of "up to 3×, often with little or no latency cost," on the premise that memory is "often the first hard limit a Kubernetes cluster hits" and that agent pods load heavily to run untrusted code, then sit idle waiting for the next prompt.
I read it more narrowly than the post does. Pilot it where agents genuinely sit idle between prompts, and nowhere else yet. Do not let it trim the RAM in the next server order, and do not assume any particular production fleet will land near the top figure. The reason sits in the post itself. The gain comes from paging out dormant memory, and the post reports results from its own three test workloads, not from a production agent fleet. That distinction is the whole argument, and fleet data showing production agents dormant for as much of their life as the post's intended use case describes would change it.
Dormant Memory Is the Lever the Post Leaves Unsized
The mechanism is plain. The kernel pages memory nobody is touching out to a fast local SSD, and the freed RAM goes to pods doing work. The kernel build in the post marks the boundary: the Kubernetes Blog reports that routing swap to a Local SSD let the build run under a 300 MB container memory limit, half the 600 MB minimum it needed without swap, with no slowdown, in fact faster at 374 seconds against a 433-second baseline, while pressing the limit to 200 MB pushed the active working set into swap, produced long I/O waits, and lengthened the run by over 40%. The post calls swap "an insurance policy for burst memory, not a replacement for active RAM," and I read that line as the decision rule rather than a reassurance. What the post reports for that build is two lower limits and two outcomes, with its own explanation of why the second one slowed. It does not report a working-set measurement for the build, and it does not describe the test conditions behind the pair of runs beyond the memory limits, so I cannot say what else, if anything, differed between them. The question an operator inherits is how far a given workload's limit can fall before its active memory, rather than its dormant memory, starts reaching disk, and the post offers only the build's two outcomes as a guide, nothing from any reader's fleet.
That is why the density figure cannot be lifted off the page and dropped onto a fleet. The Python sweep that produced the top number ran many simultaneous sandboxes on the same data analysis job, and the Kubernetes Blog reports that the node hit a hard RAM limit and failed at 80 concurrent sessions without swap, then reached 240 sandboxes, the 3× figure, with it. The post says agent pods "typically enter long-tail idle phases," which describes the intended use case; it does not report an idle ratio taken from a production agent deployment. That gap is where the decision lives.
Two readings of the same benchmark lead to opposite procurement calls. In the first, agents really do spend most of their life parked, dormant memory is plentiful, and swap converts wasted RAM into pods, which eventually argues for less memory per node. In the second, a reader's agents keep more of their memory active than the post's description of long-tail idle phases implies, and the fleet sits nearer the slower of the kernel build's two swap results than the faster one. The post cannot tell an operator which fleet it runs, and it reports no idle measurement from any deployment. The questions I would want answered first are how much resident memory per sandbox goes untouched across a working day, how much swap-in traffic appears in the busiest concurrent window, and how tail latency moves with pod count on the operator's own nodes. Until those are answered, the figure is a ceiling observed on someone else's hardware.
What the Post Blames for Peak Latency
My frame is that the binding layer keeps moving and the useful question is which layer sets the schedule this quarter. That is my frame, not something the post tests, and the post's own attribution is narrower than it. At the maximum densities it ran, the Kubernetes Blog says the per-pod latency increase is "driven mainly by pods competing for CPU, not by swap I/O," and it repeats that attribution for the Python sandboxes. I read that as an explanation of the latency cost at peak in those runs and nothing more. It does not establish what caps a node once swap is on, and the post reports no such ceiling. The post also gives no latency figure below peak, saying only that an operator tuning for a latency target would run lower and see "a proportionally smaller latency cost." Proportional to what is the number an operator needs and does not get here.
Who pays for the relocated limit depends on what the fleet already owns. The post's cost argument is that density rises on the same infrastructure, and that holds for the Local SSD-backed node it tested. Whether it holds for a reader's fleet turns on questions the post does not answer: whether its nodes already have local disk fast enough for this, and whether CPU headroom at the chosen density is already there, given that the post attributes peak latency to CPU contention. If either has to be bought, the cost comparison changes, and the post does not price that case. On the swap itself, the post describes the LimitedSwap setting and says the node rations swap space from idle application memory, but it puts no number on how much local disk to set aside per node, and it says nothing about drive wear under sustained paging. A pilot should log swap capacity consumed, swap-in traffic and drive health per node before anyone edits a bill of materials.
Pilot Ticket Versus RAM Budget
Here are my criteria, stated so they can be checked. I would open a pilot when a fleet runs agent sandboxes with long waits between prompts, when its nodes already have Local SSD, when the latency budget tolerates some CPU contention at the chosen density, and when cgroup v2 is in place, because the Kubernetes Blog says the separate swap accounting that answers the old objection depends on it. The post also instructs that workloads run as Burstable QoS with memory limits set above requests, so the pilot should include that change and watch what it does to OOM behavior. I would leave memory procurement alone until the pilot has measured the fleet's own idle ratio and its latency at the density it would actually run.
Two things keep me from going further. First, the post lists developer environments, browser testing farms, JVM applications and AI execution runtimes as places swap can "multiply your density efficiency," but the post reports measurements only for the build, browser and Python cases, and it hands the browser density numbers off to external directories. A recommendation is not a result. Second, the only managed platform the post names is Google Kubernetes Engine, where the Kubernetes Blog says the configuration is natively supported through Node Memory Swap on Local SSD profiles. That is a statement about where the post says the path is packaged, not a finding about any other provider, and I cannot read a commercial winner out of it. The exposed party is any operator who sizes RAM down on the strength of the headline figure before measuring how much of its own agents' memory is actually dormant. The checkpoint that proves me wrong is published fleet data showing that most of a production agent fleet's resident memory sits dormant between prompts, together with a small latency cost below peak density.
The Case for Not Waiting
The strongest case against my caution is that the post answers both historical objections to swap. The Kubernetes Blog reports that node swap reached General Availability in v1.34, that cgroup v2 tracks disk swap on its own so a container's real memory use is no longer unpredictable, and that fast NVMe Local SSDs largely eliminate the latency penalty spinning disks imposed. On that reading the kernel build is a demonstration rather than a caveat, the Python sweep went from a hard failure to the 3× figure on one node, peak latency is attributed to CPU, which an operator controls by running below peak, and the enablement the post describes is a kubelet setting paired with the cloud provider's fast local disk. For an operator whose agents genuinely spend most of their life waiting on a prompt, every day the swap stays off is a day paying for idle RAM, and the post's own premise is that idle resident memory is expensive, so the delay I am asking for is not free either.
I accept all of that for the pilot and none of it for the budget. The same post shows the other side of its own tradeoff: the kernel build it ran finished faster under the first lower limit and over 40% slower under the second, in the Kubernetes Blog's own figures, once the active working set reached swap. Which side of that line a reader's fleet lands on is not something the post can report, because it benchmarked its own three workloads and not anyone else's agents, and it gives no working-set measurement an operator could compare against. The post describes enablement as a kubelet setting and says nothing about reversing it, so a pilot still needs its own exit plan. Even so, a pilot is a smaller commitment than a memory order, and I would rather make the procurement decision with the fleet's own numbers in hand.
Runtime Directories and Fleet Idle Data
Three observables will move my view. The first is the Agent Sandbox GKE Swap Runtimes directory, which the Kubernetes Blog points to for density metrics under gVisor and Kata. The post itself carries no browser density numbers, so whether the stronger isolation runtimes match the default-runtime story is open, and the post's own note that untrusted code often needs stricter isolation than standard namespaces is exactly why that gap matters to me.
The second is whether the swap-on-local-disk path turns up as a packaged option on managed Kubernetes platforms other than Google Kubernetes Engine, which is the only one the post names. I do not know what other providers ship, and the post does not say, so I treat the breadth of practical availability as an open question rather than a Google advantage. The third is whether any operator publishes fleet-level measurements of agent idle time and of latency below peak density, which the post describes as proportionally smaller but did not report. I put the most weight on that one. The feature is real, and the post reports its own slower run alongside its faster ones. The number that decides whether it changes a memory budget has not appeared in the post, and until it does, the right order is pilot, measure, then procure.
Sources
The Current is written by Josh Jiwoon Inn with AI assistance in drafting. It does not claim interviews or first-hand reporting, and every number is attributed to a named source. See the AI-assisted Disclosure and Methodology.