Claude Code Idle Compaction: Cheaper Breaks, Same Session

Claude Code, Anthropic's coding agent, now shrinks a very long conversation on its own if you leave it idle for about 54 minutes. This is called idle compaction, and it arrived in Claude Code version 2.1.299 on 14 October 2026. The goal is simple: when you come back from a break, your next message should not make the AI reprocess a huge conversation from scratch.

If you manage a team that uses AI coding agents, this is a small change that can affect how quickly you use up your plan. Here is what it is, what changed, and what to do about it.

What is idle compaction in Claude Code?

You need two ideas to understand it.

Context is everything the AI is holding in mind during a session: your instructions, the files it has read, its own earlier answers. It is measured in tokens, which are small chunks of text. A very long working session can pass 200,000 tokens.

Prompt caching is a shortcut. Each time you send a message, the AI has to process the whole context again. Caching lets the provider remember the part it already processed, so the repeat is cheaper. Anthropic's documentation says reading from this cache costs 0.1 times the normal input price for most models, and less for some newer ones.

The catch is that the cache does not last. Anthropic's API documentation says the default lifetime is 5 minutes, with an optional 1-hour lifetime at additional cost. The Claude Code changelog entry for this change refers to a one-hour prompt cache. Once the cache has expired, the next message has to process everything again at the normal input price.

Idle compaction is Claude Code's answer. According to the changelog, a conversation of 200,000 tokens or more that has been idle for about 54 minutes is compacted before its one-hour prompt cache expires. Compacting means the conversation is replaced by a shorter summary of itself. The next message then starts from something small instead of reprocessing the whole thing.

What exactly changed, and when?

The change is listed under Claude Code 2.1.299, dated 14 October 2026. The changelog says it was added "in the terminal". The details:

• It applies to conversations of 200,000 tokens or more.
• It triggers after about 54 minutes idle, a few minutes before the one-hour cache runs out.
• You can change the 200,000-token minimum with an environment variable (a named setting your computer passes to the program) called CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS.
• You can turn the feature off by setting "idleCompaction": false in Claude Code's settings file, settings.json.
• Both of these need version 2.1.290 or later.

The changelog does not give a saving in dollars or percent, and neither will we. It states the purpose: so "your next message doesn't reprocess it all."

Why does it matter if I don't write code?

Because the cost of an AI agent depends not only on how much it does, but also on how long its memory gets and how often it has to be rebuilt.

Picture a product owner who spends the morning with an agent working through a large feature. The conversation grows long. They go to a one-hour planning meeting. When they return and type "continue with the checkout page", one of two things happens:

1. Without idle compaction: the cache has expired, so the whole long conversation is processed again at the normal input price. On a subscription plan, that should mean a bigger bite out of your usage limit. On a pay-per-use account, a bigger bill.
2. With idle compaction: the conversation was already shrunk while you were away, so the first message back has much less to process.

For short sessions the effect is small, which is why the feature only starts at 200,000 tokens. It matters most for people who keep one very long session open all day.

What is the downside?

A summary is shorter than the original, so something can be lost. The agent may forget a small detail you mentioned two hours ago, such as a naming rule, an edge case, or a decision about what not to build.

Compaction itself is not new to Claude Code. What is new is that it can now happen while you are away, so you may not see it happen. You will come back to a session that is a little more condensed than the one you left.

Three habits make this harmless:

• Write decisions down. Put rules and decisions in a project file the agent reads at the start, instead of relying on something said in chat.
• Brief clearly. A good written brief survives any summary better than a vague chat.
• Start fresh for new work. If you are moving to a different task, a new session is cleaner than a very long one, whatever compaction does.

Should I turn idle compaction off?

For most people, probably not. It is on by default, and it only touches very long, idle conversations.

Consider turning it off, or raising the minimum, if:

• you work in long sessions where small details matter a lot, and you would rather decide yourself when to compact;
• you are doing a careful, step-by-step review where you want the full original record kept in the conversation;
• you already start a fresh session for each piece of work, so you rarely reach 200,000 tokens anyway.

The engineer who sets this up only needs the settings file or the environment variable named above. It does not need a change to your product's code.

Other things in the same release window

Idle compaction was not the only change in the last two weeks. A few others from Anthropic's changelog are worth a line for managers:

• Hooks can now fail safe (8 October 2026, version 2.1.295). Hooks are small automatic checks that run around the agent's actions. A command or HTTP hook can now be set with onFailure: "block", so that if the hook cannot start, times out, or exits with an unexpected code, the action is blocked instead of let through.
• Tool permission rules got stricter (14 October 2026, version 2.1.299). An allow rule for one connected tool server (an MCP server) now reaches only the server it names. Previously, a rule such as mcp__a could also allow a server named a__b or a_. If your team wrote rules by hand, check them.
• Retry limit for unattended runs (15 October 2026, version 2.1.301). A new setting lets an unattended run stop waiting when a usage limit resets too far away.
• More detail in usage reporting (14 October 2026, version 2.1.300). The OpenTelemetry api_request event, a standard way to send usage data to monitoring tools, now splits cache writes by lifetime (5-minute and 1-hour).

Does Atlas handle this?

Not itself. Atlas is a team of AI engineers built on Claude Code. Each engineer is its own Claude Code session, running on your own Claude plan, so idle engineers sit on the same plan limits as everything else. Atlas does not manage the cache, show idle-time costs per engineer, or choose when a session is compacted. What it does around cost is an optional daily budget that warns at 50% and 80% and pauses the team at 100%. Engineers also checkpoint their work, so a restart resumes where they stopped. You can read more on the Atlas home page.

The bottom line

Idle compaction is a quiet, sensible fix for a real problem: long sessions that go cold. It is on by default, it only affects conversations of 200,000 tokens or more, and you can tune or disable it. The practical advice has not changed. Keep important decisions in written files, start new sessions for new work, and remember that a summary is only a summary. If your team works in long sessions, ask the engineer who owns your setup to confirm the version is 2.1.299 or later and to decide whether the default suits you.