Why the second pane opens instantly

Starting a coding CLI takes seconds. Pre-warmed sessions hide that wait — here is how we do it without eating your memory.

Open a fresh terminal and start a coding agent. Before you can type, it has to load its runtime, check its sign-in, read its configuration and usually index the workspace. That takes a few seconds — sometimes much longer in a large repository.

A few seconds is nothing once. It is a lot when you open panes all day, and it breaks the flow of “I want another agent on this, now.” So PaneScale starts them before you ask.

The idea

For every free cell of the grid in the active workspace — plus one spare, so even a full grid can grow — PaneScale keeps a session that has already started. When you open a pane, the waiting session is simply handed over. The pane appears with the agent ready for input, in milliseconds.

The waiting sessions live in the app’s backend, without a terminal on screen. Their output is buffered, and the startup queries a CLI sends to its terminal are answered right there, so the agent never hangs waiting for a reply. When a pane takes a session over, the buffered output is replayed and the session continues as if it had always been visible.

Not eating your machine

Naively, “a session behind every cell” on a 16-pane grid means sixteen agents running for nothing. That would be a terrible trade. So pre-warming is careful:

  • Low priority. Waiting sessions — and the processes they start, such as MCP servers — run below normal CPU priority. Your real work always comes first.
  • A memory budget. PaneScale estimates what each waiting session costs (about 450 MB for Claude Code with its MCP servers) and always leaves at least 4 GB of memory free. If the budget runs out, fewer sessions wait.
  • Throttled. At most four sessions start at the same time, and after a failed start PaneScale pauses for a minute instead of trying again and again.
  • Bounded per agent. Up to thirty for Claude Code, three for Codex and two plain shells.
  • Kept fresh. A session that has waited for 30 minutes is replaced by a new one, so a pane never starts with stale state.

When you take a session, it is switched back to normal priority immediately.

When the pool is empty

If you open panes faster than sessions can start, the pane starts right away and PaneScale’s start queue staggers the launches, so a burst of new panes doesn’t make every one of them slow. You can type immediately — your input waits for the agent and is sent as soon as it is ready.

Start options are part of the key

If you start Claude Code with a different effort level, a different account or without permission prompts, a session warmed with the default options wouldn’t be the same thing. So the options are part of the pool key: a pane only receives a pre-warmed session that was started exactly the way the pane asks for.

More articles

Checkpoints that never touch your branch

How PaneScale snapshots a working copy byte for byte without moving HEAD, the index or any branch — and why rewinding refuses to overwrite your edits.

Measured, not estimated

Why the Token Guardian shows “not reported” instead of a guess — and how real budgets stop runs instead of turning numbers red.

Memory is context, not commands

Teammates in PaneScale remember. Here is why everything they remember is passed as context and never as instructions — and why that matters for safety.