Claude Code's auto-compaction took me 2 minutes, so I moved it to the background

Amadeusz Heller — Wed, 04 Nov 2026 13:22:32 +0000

If you run long Claude Code sessions you know the moment. The context hits the auto-compact threshold, Claude stops, and you look at "Compacting conversation..." for a minute or two. In my Opus sessions that took 80 to 160 seconds every time, and once 259 seconds.

So I built a plugin that does the slow part earlier, in the background, while the session keeps working. When auto-compaction fires, it swaps in the summary that is already done. That takes 8-20 ms.

Repo: SocialBuzzStudio/live-compact (MIT).

Why compaction blocks

Standard compaction is one request: the whole conversation plus "summarize this". The input mostly comes from the prompt cache, but the summary itself is long (about 12,000 tokens in my sessions) and the session waits for the last token of it.

None of that has to happen at the threshold, though. The conversation 40,000 tokens before the threshold is almost the same conversation. Summarize that one, and at the threshold you only have to glue the newest messages onto the summary.

What the plugin does

Since Claude Code 2.1.287, mods are on by default: plugins whose TypeScript runs inside Claude Code and can hook engine events, including compaction. live-compact uses three things from that API:

$.session.usage() every 5 seconds for the context size, and once a minute for the auto-compact threshold.
$.model.fork({ prompt }) when the context is within 40,000 tokens of the threshold (or 20% of it, whichever is smaller). A fork sends the session's last request plus my prompt, with the same model, so almost all of it is read from the prompt cache: about 330,000 tokens read from cache and 12,000 written per compaction in my sessions. Claude keeps working on your task meanwhile.
A session.compact hook. When compaction starts, it gets the conversation and can return its own { messages } instead of letting the engine summarize.

The hook, simplified:

on('session.compact', async ($, e, next) => {
  if (e.agentId) return next(e) // subagents: standard compaction
  const prepared = ready
  reset()
  const eligible = e.trigger === 'auto' || (e.trigger === 'manual' && !e.instructions)
  const result = prepared && eligible
    ? compacted(e.messages, prepared.anchor, headText(prepared.summary))
    : undefined
  if (result && 'messages' in result) return { messages: result.messages }
  return next(e) // anything doesn't line up: standard compaction
})

compacted() returns the summary as the first message, then every message after the last one the fork saw, unchanged. If that message is no longer in the conversation (you rewound past it, ran /clear, resumed), it refuses and the engine compacts the normal way. So the worst case is the same wait as without the plugin.

The parts that took the longest

The fork doesn't see the response in progress. It replays the last request, so the summary ends where that request ended, not at the end of the transcript. The anchor is the last user message before the response that is still streaming, and everything after it goes back verbatim.

Messages you type while Claude works. The engine files them next to the following tool result, outside the messages the compact hook gets. The first version quietly dropped them. Now the plugin catches them on session.append and puts their text back into that tool result.

Skills. Standard compaction carries over the skills used earlier in the conversation. A hook that returns its own messages doesn't get that, so the plugin copies them into the summary message, with the same limits as the engine (5,000 tokens each, 25,000 in total).

--resume. A tool result handed back with its handle keeps its pre-compaction parent, so resuming the session loaded the old history again. I reported it as anthropics/claude-code#107178 and the plugin works around it for text.

Numbers

In my everyday sessions on 2 and 3 November (test sessions not counted), 14 of 17 auto-compactions used the plugin's summary, each in 8-20 ms. In the other 3 the summary wasn't ready yet: one step added more than ~40,000 tokens at once (several large files read in one go) and the context passed the threshold first. Those ran standard compaction.

I haven't compared the quality of the plugin's summaries with Claude Code's own in any systematic way. The prompt follows the same structure, and if your CLAUDE.md has a # Compact instructions section, the summary follows it.

Trade-offs

The context after compaction is bigger by the verbatim tail (usually up to ~40,000 tokens), so the next compaction comes sooner.
The summary shows up as a user message ("This session is being continued from a previous conversation..."). A plugin can't mark it as a compaction summary the way the engine does.
A summary that never gets used is a wasted request, for example after /clear or when you close the session before it compacts. On a subscription it counts toward your usage limits like any other request.
Images in tool results among the kept messages are dropped; their text stays.
Your own PreCompact/PostCompact hooks may not run when the plugin compacts.
I've only tested it on Windows.

Try it

In a terminal:

claude plugin install live-compact --marketplace SocialBuzzStudio/live-compact

In the VS Code extension: type /plugins, add SocialBuzzStudio/live-compact on the Marketplaces tab, then install live-compact on the Plugins tab.

Every compaction leaves one line in the conversation saying whether the plugin's summary was used. If you try it on macOS or Linux, an issue with how it went would help a lot.

Claude Code wrote most of the plugin's code, and this post too, from the project notes. The numbers come from my own everyday sessions.

TL;DR: Claude Code's auto-compaction blocked my Opus sessions for 80-160 s. live-compact has the summary written in the background ~40k tokens before the threshold and swaps it in within 8-20 ms when compaction starts; if anything doesn't line up, standard compaction runs. GitHub