Skip to Content

DocsConcepts

Benchmarks

How much memory MCP servers take with and without the gateway, and how to measure it on your machine.

View source

This page gives the memory numbers behind turno's claim, how they were measured, and the command that reproduces them on your machine.

turno exists because of one measurement: 18 Claude Code sessions open on a 16 GB Mac held about 11.7 GB in MCP server processes, most of them copies of the same few servers. The benchmark reproduces that effect with public servers so anyone can check it.

Results

Apple M3, 16 GB, macOS, Node 26.13, 2026-11-16:

SessionsEach session starts its own serversturno, all six servers runningturno, idle (tool lists cached)
41,410 MiB, 28 processes692 MiB, 8 processes101 MiB, 1 process
83,163 MiB, 56 processes847 MiB, 8 processes103 MiB, 1 process
4, servers through npx -y3,123 MiB, 52 processes

With 8 sessions the gateway uses 73% less memory while every server runs and 97% less while they are idle. Direct memory grows with every session; the gateway's stays nearly flat, because only mcpd grows (one HTTP session per client).

Run it yourself

git clone https://github.com/wimo-dev/turno && cd turno
pnpm install && pnpm build
node bench/mcp-ram.mjs --sessions 8 --out bench/results/mine.json
node bench/mcp-ram.mjs --sessions 4 --npx

The script uses a throwaway HOME and never reads or changes your own configuration. It writes a result like this one (the 8-session run above):

bench/results/2026-11-16-m3-16gb-8-sessions.json
{
  "machine": "Apple M3, 16 GB",
  "node": "v26.13.0",
  "sessions": 8,
  "direct": { "mode": "installed binaries", "mib": 3163, "processes": 56 },
  "gatewayColdCache": { "mib": 847, "processes": 8 },
  "gatewayWarmCache": { "mib": 103, "processes": 1 }
}

Method

bench/mcp-ram.mjs installs six popular local MCP servers into a temporary folder (no API keys needed, versions pinned in the script):

  • @playwright/mcp
  • chrome-devtools-mcp
  • @modelcontextprotocol/server-filesystem
  • @modelcontextprotocol/server-memory
  • @modelcontextprotocol/server-sequential-thinking
  • @upstash/context7-mcp

It then measures three setups with N simulated sessions. Each session does what an agent does when it starts: initialize and tools/list on every server.

SetupWhat runs
Directevery session starts every server over stdio, as with a plain mcpServers entry (--npx starts them through npx -y, as most server READMEs suggest)
turno, all servers runningone mcpd (shared scope) with an empty tool cache: each server starts once to learn its tools and stays up for every session
turno, idlemcpd restarted with the cache the first round wrote: the tool lists come from the cache and no server starts until a tool is called

Memory is the sum of the resident set size (RSS) of every process involved, read from ps three seconds after the last session connected.

Caveats

  • RSS counts shared pages once per process, so sums overstate real pressure somewhat for both setups. Activity Monitor's "Memory" column (physical footprint) gives lower absolute numbers but the same ratio.
  • Servers that keep state per session (a browser driven by one agent at a time) should run with scope = "session" or exclusive = true, which gives back some of the saving. Stateless servers (docs, search, memory, issue trackers) share safely. See Scopes.
  • Servers that open a browser or index files use much more memory once a tool runs; this benchmark only starts them and lists their tools, which is what every session pays even if it never calls them.
  • Run it on your own machine with your own servers before quoting a number: turno mcp list shows what you run, and the script's SERVERS list is easy to edit.

On your real setup

Once the gateway runs, turno mcp savings compares its memory now with an estimate of the same live sessions without it, and turno mcp top shows memory per running server.

On this page