Skip to content

Dev Box Hardware for Parallel AI Coding Agents: RAM, CPU, SSD

We run 10 to 20 AI coding agents per Linux box, all building and testing at once. A week of job metrics says 64 GB of DDR4 is enough.
Engineering10 min readBy Flint Pay, Product & API Team

Most of Flint's code is written by AI coding agents, Claude Code and Codex, running on always-on Linux machines we call dev boxes. A person steers them from a laptop or phone, and the boxes do the work. A busy box runs 10 to 20 agents at once, and each one compiles Go, runs test suites, and type-checks TypeScript, often at the same moment as the others.

We were about to buy another box and had to choose between 64 GB and 128 GB of RAM. Two of our boxes had already run out of memory, one of them with 128 GB, so "more" looked like the answer. We measured first. A week of job metrics from three machines says to buy 64 GB of DDR4 and spend the difference on CPU cores and a better SSD.

Tip: The short answer

  • 64 GB is enough for 10 parallel build and test jobs plus about 20 agents. Our 64 GB box peaked at 41 GiB.
  • The memory crashes came from unbounded build parallelism, not too little RAM. A per-job cap fixed them on the 64 GB and 128 GB boxes alike.
  • CPU is the next limit. A running job averages 2 to 3 cores, so plan on about 3 threads per parallel job.
  • A budget SSD can hold back the whole box. Our fastest CPU spends most of its time waiting on a drive without a DRAM cache.
  • DDR4 is fine. Nothing we measured was limited by memory speed.

Note: Who these numbers are for

These numbers are for highly parallel agent work: many agents sharing one machine, each running builds and test suites against its own copy of a large repository. One developer with one agent needs far less.

Why we run agents on dev boxes#

We moved agent work off laptops for three reasons:

  • Agents run for hours. A laptop sleeps when you close it. A dev box keeps working, and you can check in from a phone.
  • Agents run in parallel. One coordinating agent often starts several more, each with its own branch, and each of those builds and tests on its own. Ten Go builds at once is more than a laptop can do.
  • Failures stay contained. On a shared machine, one runaway test can take down every other agent's work. A box lets us put each job in its own sandbox and queue them.

Each box gives every agent its own git worktree. Builds and tests go through a per-machine queue that starts jobs first in, first out, through a fixed number of slots: 10 on our largest box. The queue starts a job only when 10 GiB of memory is free and the disk isn't saturated. Each job runs in its own systemd scope, so the kernel can limit and account for it separately.

The workload is a Go monolith, several TypeScript apps (Vite, Vitest, and tsc), and Playwright browsers. The largest Go package has 1,876 files and takes 3 to 7 GiB to compile.

The three machines#

MachineCPURAMSSD
Mini PCIntel i9-13900HX, 24 cores, 32 threads64 GB DDR4-3200, the board's maximumCrucial E100, 1 TB, no DRAM cache
Office desktop (Dell OptiPlex 5000)Intel i7-12700, 12 cores, 20 threads, held to Dell's power limits128 GB DDR4, the board's maximumSamsung 970 EVO Plus, 1 TB
LaptopIntel i7-11800H, 8 cores, 16 threads32 GB DDR4SK hynix PC711, 1 TB

What we measured#

Every job records its peak memory, CPU time, and pressure stall information (PSI): how long its processes waited on CPU, memory, and disk. Every machine also samples used memory, swap, load, disk busy time, and machine-wide PSI every minute or two. From October 30 to November 6, 2026, the three machines ran about 31,000 jobs.

You don't need custom tooling to collect the per-job numbers. Run a job in its own scope, and systemd writes its CPU time and memory peak to the journal when it exits:

Shell
systemd-run --user --scope --unit=my-test -- go test ./...
journalctl --user -u my-test.scope | grep -i "memory peak"
cat /proc/pressure/cpu /proc/pressure/memory /proc/pressure/io

The memory crashes were a parallelism bug#

By default, go build, go test, and go vet run as many compiles at once as the machine has CPU threads. Each compile of a large package takes 2 to 3 GiB. On a 32-thread machine, a single test run could start 20 or more compiles, and several agents started test runs at the same time.

  • On the 64 GB box, 50 compiler processes once held 80 GiB of RAM and swap together. Swap filled, the kernel's memory reclaim thread locked up a CPU, and the box was unusable for 7.5 hours.
  • On the 128 GB box, two jobs running together reached 41 and 30 GiB and used up all 123 GiB the OS could see. Over the week, 323 of its jobs exceeded 15 GiB, and the largest reached 64 GiB.

The extra RAM moved the failure point; it didn't remove it. Two changes did:

Shell
# At most 6 Go processes per job (Go's -p flag), still bounded by CPUs and RAM
export GOFLAGS="-p=6"

# Throttle a job above 20 GiB instead of letting it exhaust the machine
systemd-run --user --scope --property=MemoryHigh=20G -- go test ./...

MemoryHigh makes the kernel slow a job down by reclaiming its memory once it passes the limit, instead of letting it grow until the out-of-memory killer picks victims across the whole machine. Since the cap, the 64 GB box's largest job peaked at 20 GiB, and 99% of its jobs stayed under 15.2 GiB.

After the fix, 64 GB has room#

The figures below cover the 19 hours after the cap went in, November 6, 2026, from about 01:00 to 20:00 UTC. That window covers about 5,500 jobs.

MachineInstalledUsed, 90th percentileUsed, 99th percentileUsed, peakParallel job slots
Mini PC64 GB28 GiB37 GiB41 GiB10
Office desktop128 GB34 GiB51 GiB79 GiB6
Laptop32 GB23 GiB28 GiB30 GiB, with 16 GiB of swap full4

The 64 GB box ran about 12 agents at the median and up to 21. Its memory use grew slowly with the number of jobs running:

Jobs running at onceUsed, medianUsed, 90th percentileUsed, peak
116 GiB20 GiB29 GiB
522 GiB28 GiB33 GiB
1028 GiB36 GiB41 GiB

Two numbers explain the shape. The agents themselves, with their editors, language servers, and browsers, take a baseline of 16 to 20 GiB. A job's peak averages about 9 GiB, but jobs rarely peak at the same moment, so each extra running job adds only 1 to 1.5 GiB at the median.

The kernel agrees. On both the 64 GB and 128 GB boxes, processes spent less than 3% of their time stalled on memory at the 90th percentile. The 32 GB laptop is the exception: its swap is full, its memory stalls reach 10% at the 90th percentile, and jobs there still get killed. 32 GB is too small for this work.

The office desktop's 79 GiB peak came with only 5 jobs running, when several of the largest Go packages compiled at once. On a 64 GB box, the queue's 10 GiB free-memory rule would hold the next job until memory freed up. A bad mix costs some waiting, not a crash.

CPU is the next limit#

While running, jobs used an average of 2.1 cores on the mini PC, 2.4 on the laptop, and 2.9 on the office desktop.

The office desktop shows what happens when there aren't enough. With 6 job slots on 20 threads, its median CPU use was 91%, and in 35% of samples some processes were waiting for CPU more than half the time. It also runs within Dell's power limits, so it can't hold its full boost clocks under a sustained build load.

Plan on about 3 CPU threads per parallel job. For 10 to 12 jobs, that means 28 to 32 threads, in a case and on a board that let the CPU run at its full rated power.

The SSD matters more than the RAM#

The mini PC has the best CPU and plenty of free memory, but it spends most of its time waiting on its disk. Its Crucial E100 is a budget drive without a DRAM cache. In the 19 hours after the cap:

  • The disk was busy 99.6% of the time at the median.
  • In 41% of samples, some processes were waiting on the disk more than half the time. On the other two boxes, that happened in 0% and 2% of samples.
  • Its jobs waited 456 hours in total for a queue slot and ran for 77. Its CPU stall stayed under 14% at the 90th percentile and its memory had room, so the disk was the limit. The queue pauses new jobs while the disk is saturated.

Builds, test binaries, Go build caches, and a git worktree per agent add up to a lot of small writes. Budget drives without a DRAM cache slow down sharply under that kind of sustained load. Our boxes also hold 700 to 760 GB of worktrees and caches, and we keep disks below 70% full so they don't slow down further. That rules out 1 TB.

DDR4 is fine#

All three machines use DDR4, and none of them was limited by memory speed. The limits were CPU and disk. For this workload, a 64 GB DDR4 kit is the better buy than the same capacity in DDR5.

DDR4 does narrow the choice of CPU. AMD's AM5 platform and Intel's Core Ultra 200 desktop chips take only DDR5. With DDR4, the choices are Intel's 12th, 13th, and 14th generation on a DDR4 motherboard, or AMD's AM4 platform.

The spec we're buying#

PartWhat to buyWhy
CPU28 to 32 threads at full desktop power: an Intel i7-14700, i9-13900, or i9-14900, or an AMD Ryzen 9 5950XAbout 3 threads per parallel job, for 10 to 12 jobs
Memory64 GB of DDR4-3200 as a matched 2 × 32 GB kitThe 64 GB box peaked at 41 GiB with 10 jobs running
SSD2 TB NVMe with TLC flash and its own DRAM cache, such as a Samsung 990 Pro or WD SN850XBuilds keep the disk busy, and 760 GB in use needs 2 TB to stay below 70%
MotherboardThe DDR4 version of an Intel LGA1700 board (B660, B760, Z690, or Z790), or an AM4 board (B550 or X570), with four memory slots, two or more M.2 slots, and onboard EthernetTwo free memory slots keep 128 GB possible without replacing the sticks
Cooling and powerA good tower cooler and a quality 550 to 650 W power supplyBuilds hold the CPU at 100% for long stretches
NetworkWired EthernetThe boxes stay on and connected; they don't use Wi-Fi

A few details matter when buying:

  • Update the BIOS before installing the OS. Intel's 13th and 14th generation desktop chips had a voltage problem that their BIOS updates fix.
  • Skip Intel's "F" models, which have no integrated graphics. The Ryzen 9 5950X has none either, so add a basic graphics card for setup.
  • Many AM4 boards accept unbuffered ECC memory. We've seen Go compiler crashes on one of our non-ECC boxes that point to memory errors, so ECC is worth it where the platform supports it.
  • Avoid QLC drives and drives without a DRAM cache.

Before a box goes into service, we run Memtest86+ for at least one full pass, set the BIOS to power on after AC loss and to its highest-performance mode, and install Ubuntu Server LTS.

When 128 GB is worth it#

128 GB makes sense when the rest of the machine can use it:

  • The CPU can run 16 or more jobs at once. The more jobs run together, the more often several large ones peak at the same moment. With 20 GiB per job as the throttle point, three large jobs at once plus the agents' baseline already approach 64 GB.
  • Your jobs are larger than ours. Measure each job's memory peak the way shown above, then size for the agents' baseline plus two or three jobs at their full peak.

The data after the fix covers 19 hours, which is short. A heavier week could raise the peaks somewhat, which is why the spec keeps two memory slots free.