Omniscio

OmniscioGuidesHow many sessions at once

How many Claude Code sessions can you run at once? Measured on one machine

Most answers to this question describe one ceiling and leave the other two out. Claude Code has an engine ceiling, your machine has a hardware ceiling, and your plan has a usage ceiling.

We measured the hardware one on a machine we can describe, and read the other two out of Anthropic's own documentation. The table below comes from sessions we started, watched and counted.

Last tested on Claude Code 2.1.306, October 21, 2026. By the Omniscio team. Updated .

Three ceilings, and only one is about your hardware

The engine does not set a session count. Claude Code's documentation lists five ways to take on several tasks at once: subagents, agent view, agent teams, dynamic workflows and projects.

It puts no number on how many sessions you open.

The number it does set is inside a session. Twenty subagents can run at once by default, and a twenty-first is refused with Concurrent subagent limit reached until the running ones finish. An environment variable raises the limit.

Two things before you plan.

  • A session started by running claude directly is tied to that terminal and ends when the terminal closes, unless you send it to the background.
  • The sessions in agent view, a research preview, are background sessions that a closed window does not end. Those background sessions run on your own machine, surviving a sleep but not a shutdown.

The hardware minimum Anthropic states is 4 GB of RAM and an x64 or ARM64 processor, which is the floor for the machine itself rather than for one session. What each additional session costs on top of that is what the table further down this page measures.

The plan is the ceiling that fails all at once rather than gradually. Every session you open draws on the same usage allowance, which the section on usage below covers in full.

How we measured it

The rest of this section is for readers who want to check our method.

One machine, one afternoon, every number below produced by the same script.

  • Machine: a Linux virtual machine with 8 vCPUs on an AMD Ryzen 9 9950X host, and 15.6 GB of RAM.
  • Versions: Claude Code 2.1.306 on Node 24.18.1, with git 2.43.0 and tmux 3.4.
  • Load: nothing else we started was running on it.

Two words, defined as this page uses them.

  • Idle: an interactive Claude Code session sitting at its prompt in a tmux pane, with nothing typed and nothing running.
  • Working: a headless claude -p run given one line of work.

A working session overwrites index.html with a session-specific heading, in its own git worktree. Every session in a batch started in the same second.

Memory is the proportional set size of each session's whole process tree, read from /proc/<pid>/smaps_rollup every pass.

Proportional set size splits shared pages between the processes that map them, so twelve sessions do not each appear to own a private copy of the same binary. Plain resident memory would have reported more than twice as much, 2.3 GB against 1.1 GB.

Processor is the sum of user and system time across the same process tree, sampled every half second while a batch ran. Every working row is the highest reading across three runs on October 21, 2026.

What the table measures is the cost of the Claude Code client process on this machine: how much memory it holds and how much processor time it spends.

The model's replies came through a proxy service, and the model behind it was not a Claude model. The idle rows do not depend on the model at all. The working rows do, because a working session's cost follows what the model asks it to do. Treat them as one realistic example rather than a constant.

Anything that depends only on the model, such as time to first token or tokens per turn, is left off this page. The repository here was tiny, so a session working through a large codebase will use more memory than these numbers show.

What one, three, six and twelve sessions cost

Scroll sideways for the processor column.

SessionsMemory, idleMemory, workingProcessor, working
1139 MB211 MB0.8 of 8 cores
3329 MB543 MB2.4 of 8 cores
6586 MB1.0 GB4.8 of 8 cores
121.1 GB1.9 GB7.7 of 8 cores

Memory is the total for all sessions in the row, measured as proportional set size. The processor column is the peak reading across three runs on October 21, 2026, as a fraction of the machine's eight cores. Disk per worktree is the same at every session count, so it is the section below rather than a column here.

Memory is cheaper per session than you expect

Read the idle column and the cost of one more session falls as the count rises. It is 139 MB for the first session, 110 MB each at three sessions, 98 MB at six and 90 MB at twelve.

Each session after the first added roughly 80 to 95 MB, because the processes share most of their code with each other.

Twelve idle sessions held 1.1 GB of a 15.6 GB machine, and the same twelve while working peaked at 1.9 GB, an eighth of the machine. At about 160 MB per working session, the 14 GB this machine had free would have held nearly ninety.

Memory was never going to be the reason twelve did not fit.

That is for small edits. A session that reads a large repository, runs a test suite and holds the output in its context will hold more than 200 MB. To find out on your machine, point the same script in the capture below at your own repository.

The processor is what runs out

One working session, working alone, used 0.8 of a core at its peak. Twelve ran together and all finished, but they filled the processor: the measured cost at twelve was 7.7 of the 8 cores, about 0.64 each.

Plan on about ten working at once per eight cores, and fewer if you leave a core spare. On a 16 GB, 8-core laptop, more fit if half of them are idle.

A worktree copies your files; the dependencies cost the disk

A worktree is a full copy of the checked-out files, without the git history, which it shares with the main checkout.

Ours looked tiny because our test repository held two files of 30 and 8 bytes, so its twelfth worktree was 86 bytes, a 48-byte pointer to that shared history included. On a real project the copy is as big as your working tree.

What a worktree does not share is your installed dependencies. It is a fresh checkout, and the documentation tells you to install them inside it. Gitignored files follow only if you list them in a .worktreeinclude file.

That is where the disk goes. The checkout we build Omniscio from carries about 2.3 GB of installed dependencies in node_modules, measured on October 21, 2026. Twelve worktrees that each installed their own would be about 27 GB before anyone writes a line of code. Plan for the dependencies, not for the checkouts.

The run, as it printed

This is the measurement script's own output from the run the table is built from. It is cut to the blocks this page reports: the machine, the twelve idle sessions, one twelve-session batch, and the summary. The per-session lines for the other batches are the same shape and are left out.

machine: Linux 7.0.0-38-generic x86_64 | Model name: AMD Ryzen 9 9950X 16-Core Processor
cpus: 8 | Thread(s) per core: 1
memory total 15988 MB | available 14194 MB
claude: 2.1.306 (Claude Code) | node v24.18.1 | git 2.43.0 | tmux 3.4

### idle: 12 interactive session(s) sitting at the prompt
sessions 12 | PSS total 1083 MB | per session 90 MB | RSS total 2340 MB | processes 12 | CPU 1.0%
after kill: 0 measurement session(s) left on the machine

### active: 12 headless session(s), one identical edit each, started together
sessions 12 | peak PSS 1889 MB (157 MB per session) | peak machine CPU 748% of 800%
sessions 12 | failures 0 | writes: <h1>written by session 1</h1> | <h1>written by session 2</h1> | ... | <h1>written by session 12</h1>

### summary
sessions | idle PSS/session MB | idle CPU % | active peak PSS/session MB | active CPU %
1 | 139 | 0.3 | 211 | 84
3 | 110 | 0.7 | 181 | 236
6 | 98 | 1.7 | 167 | 478
12 | 90 | 1.0 | 158 | 770

Captured on our Linux test machine on October 21, 2026. Three cuts are made and nothing else.

The writes line is shortened where it marks twelve near-identical entries. The wall-clock figure is dropped from each batch line, and the timing and token lines the script also prints are omitted. Those measure the model answering rather than the machine, and this page reports neither.

The processor figure is the peak reading as a percentage of 800%, which is the machine's eight cores counted one per core.

What an extra session costs in usage, and why it is not memory

Memory is the part you can plan from a table. Usage is the part that surprises people, and it is the ceiling most likely to stop you first.

Every turn of every session is a request counted against your plan's allowance. That allowance is one number for the account rather than a pool per session.

Anthropic's own documentation is blunt about the parallel case. Background sessions consume subscription usage the same as interactive sessions, so ten in parallel uses quota roughly ten times as fast as one.

The usage-limits page adds the warning that matters when you scale up. Usage counts against the session and the weekly allowances at the same time. A single burst of heavy activity, such as a large fan-out, can use up the weekly allowance before the session window resets. Twelve sessions started together is exactly that kind of burst.

Usage is counted in tokens on each request to the model. A session waiting at its prompt sends almost none, so the memory column and the bill move independently. Our twelve idle sessions sat at about 1% of the machine's processor.

When usage does bite, the /usage breakdown names the usual causes. It recommends a change for any behavior behind a tenth or more of recent usage, long context and cache misses among them.

There is a quieter cost to parking sessions. The first message you send after a break longer than the prompt cache's lifetime misses the cache and reprocesses the whole context. A session you come back to after an hour opens with one expensive turn before it is cheap again. Twelve sessions you return to at once is twelve cold turns.

So what number should you actually use?

Split the count by what you do with the sessions, because they are not the same kind of work.

  • Sessions you steer. Three to five. Sessions like these make you the bottleneck long before the machine does, and past five the queue you are managing is your own attention.
  • Sessions you review in batches. The rest, up to the machine's processor limit: ten working at once on our eight-core test box, five on four cores. They run unattended, and what they cost is processor time and plan usage rather than your attention.

Twelve short sessions at once on a 16 GB, 8-core machine is realistic. Twelve sessions each reading a large repository and running a test suite is not the same proposition, and the table above should not be read as a promise about it.

Those sessions hold bigger contexts and spend more time on the processor, which is exactly the resource that ran out first here.

Two numbers to take to your own machine. One is about 0.8 of a core per session working at the same moment. The other is roughly 200 MB of memory per working session, on top of the 4 GB Anthropic says the machine needs.

Whichever runs out first is your ceiling, and on a machine with more than four cores it is usually the processor.

Where Omniscio fits

Omniscio is the desktop app we make, so read this section knowing that. It runs many sessions at once across projects.

Each session can work in its own copy of the project on its own branch, through a switch with three levels: per session, a project default, or an app-wide default. For Claude Code sessions all three are off until you turn one on; engines whose tools run outside Claude Code's guardrail hooks get their own copy by default.

A copy's dependencies are prepared in the background, so the first build or test in a large project can need to wait a moment. Work in a copy is committed on the session's own branch and can merge back automatically when you archive the session, if automatic merging is turned on.

Past a handful of sessions the problem becomes triage, and the sessions that need an answer float to the top of an inbox.

The Free plan covers 8 projects, and Pro is a paid plan; the pricing page has both. Omniscio installs on Windows, macOS and Linux.

What this does not tell you

These are single-machine measurements on one operating system. The numbers carry the shape of that machine: eight cores, 15.6 GB of memory, a small repository and a short task. A Windows or macOS session will differ in the details, and a session working through a large codebase will differ in the memory column most of all.

We did not run past twelve, so this page cannot tell you what fails at twenty-four or where memory finally runs out. We did not measure the interactive interface's own cost under load beyond the idle figures. We also did not test what a rate-limited plan does to a batch partway through.

Our other guide on this subject, what to use to run 10-20 coding agents at once, reports its own twelve-session run. That run was on one Linux machine on October 17, 2026, on Claude Code 2.1.302, and the guide quotes how long it took. This page reports memory, processor and disk, and leaves time out on purpose.

Where this page and Anthropic's documentation disagree, the documentation wins. Claude Code ships often; check the current limits before you size a machine against this table.

Sources

Every statement about Claude Code on this page rests on one of these, re-read on November 8, 2026. The measurements above are from October 21, 2026. Every statement about Omniscio rests on our own pages, read on November 8, 2026, with the pricing page read again on November 12, 2026.

Common questions

How many Claude Code sessions can one machine handle?

On an 8-core, 16 GB Linux machine we ran twelve at once and every session finished. Memory was not the limit: twelve idle sessions held 1.1 GB and twelve working ones peaked at 1.9 GB. The processor was the limit, at 7.7 of the 8 cores, so plan on about ten working at once.

How much memory does each Claude Code session use?

About 90 to 140 MB per session while it sits at the prompt, and 160 to 210 MB per session while it is working. The first session costs the most, at 139 MB, and each one after it added roughly 80 to 95 MB, because sessions share most of their code pages. A session reading a large repository will hold more than a session making a one-line edit.

Does running several sessions use my plan allowance faster?

Yes. Every session draws on the same allowance, and Anthropic's own documentation says background sessions consume subscription usage the same as interactive ones. Ten in parallel uses quota roughly ten times as fast as one, and a single large fan-out can use up the weekly allowance before the session window resets.

Is RAM or processor the limit for parallel sessions?

On our machine it was the processor. Twelve sessions used 1.9 GB of a 15.6 GB machine but filled 7.7 of its 8 cores. A machine with more cores and less memory would run more sessions than ours. An 8-core laptop with 8 GB of RAM still runs out of processor first. The 4 GB left after the machine's own needs holds about twenty working sessions, twice what eight cores can run.

Does each session need its own worktree?

Only if two sessions might touch the same files. A git worktree gives a session its own directory and branch, its own copy of your tracked files while sharing the repository's history. What it does not share is installed dependencies: a worktree is a fresh checkout, so they are installed again inside it, and that is where the disk goes.

Run a dozen sessions in one window

Omniscio installs on Windows, macOS and Linux, and the Free plan covers 8 projects. It gives each session its own copy of the project when you want one, and puts the session that needs you at the top.