How many coding agents fit on one box?

Total memory used by every agent process tree as sessions were added, sampled 8 times per step after a 20s settle. The line is close to straight, which is the useful part: after the first session, each additional one costs about the same 167 MB. The run finished the whole ladder with 2.2 GB still available, no swap, and no OOM kills.

The ramp above is the flattering number, and quoting it alone would be dishonest. Those sessions were open and waiting. To get the other end we watched a real developer machine for 10 minutes with 17 Claude Code sessions on it doing actual work: reading files, running builds, spawning subagents.

Claude Code sessions per tier, at three measured intensities. On every tier the plan's own agent cap binds before memory does.

Both datasets measure the whole process TREE of each session, meaning the CLI plus its MCP servers, language servers and anything it spawns, in proportional set size, which splits shared pages between the processes mapping them. Summing RSS instead would count the shared runtime once per agent: the same ramp reads 340 MB per session in RSS against 238 MB in PSS.

The other things sharing the box

Measured the same way, by starting each one and sampling its tree until it exited or the window closed. Peaks, not averages: these are spikes that have to fit while every agent is also resident.

• Vite dev serverbun run dev353 MB peak
• Production buildbun run build432 MB peak
• Headless Chromium/home/dev/.cache/ms-playwright/chromium-1234…526 MB peak

Measure your own box

Paste this on any Linux machine while your agents are working. It walks /proc, sums each agent's process tree, and prints one line per session. Nested subagents are counted inside their parent's total as well as their own.

python3 - <<'PY'
import os, re, collections
proc = {}
for pid in filter(str.isdigit, os.listdir('/proc')):
    try:
        st = open(f'/proc/{pid}/status').read()
        pss = re.search(r'^Pss:\s+(\d+)', open(f'/proc/{pid}/smaps_rollup').read(), re.M)
    except OSError:
        continue
    proc[int(pid)] = (int(re.search(r'^PPid:\s+(\d+)', st, re.M)[1]),
                      re.search(r'^Name:\s+(.*)', st, re.M)[1].strip(),
                      int(pss[1]) / 1024 if pss else 0)
kids = collections.defaultdict(list)
for pid, (ppid, _, _) in proc.items():
    kids[ppid].append(pid)
def tree(pid):
    return proc[pid][2] + sum(tree(k) for k in kids[pid] if k in proc)
for pid, (_, name, _) in sorted(proc.items()):
    if name in ('claude', 'codex', 'opencode', 'pi'):
        print(f'{name:10} pid {pid:<8} {tree(pid):7.0f} MB')
PY

If your numbers disagree with ours, yours are the ones that matter. Size for them.