# Benchmarks (/docs/benchmarks)

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

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.

<GatewayDiagram />

## Results [#results]

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

| Sessions | Each session starts its own servers | turno, all six servers running | turno, idle (tool lists cached) |
|---|---|---|---|
| 4 | 1,410 MiB, 28 processes | 692 MiB, 8 processes | 101 MiB, 1 process |
| 8 | 3,163 MiB, 56 processes | 847 MiB, 8 processes | 103 MiB, 1 process |
| 4, servers through `npx -y` | 3,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 [#run-it-yourself]

```sh
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):

```json title="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 [#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.

| Setup | What runs |
|---|---|
| **Direct** | every 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 running** | one `mcpd` (shared scope) with an empty tool cache: each server starts once to learn its tools and stays up for every session |
| **turno, idle** | `mcpd` 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 [#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](/docs/concepts/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 [#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.