[FEATURE] Automatic, on-demand context compression for long conversations ("Smart Summarization")

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Long conversations in Claude.ai become progressively more expensive to continue, because every new message reprocesses the entire prior history in addition to any attached files. This isn't a minor inefficiency as it compounds:

• A 100-message thread costs dramatically more per response than a fresh chat with equivalent content, because the full transcript is resent every turn.
• On Free/Pro plans with rolling 5-hour usage windows, this means long-running creative, research, or planning threads burn through the quota disproportionately fast, often forcing users to abandon useful context entirely and start over from scratch, losing continuity.
• The only current mitigation is manual: the user has to notice the problem, generate their own summary, copy it out, and paste it into a new conversation. This works, but it's a workaround the user has to discover and execute themselves it should be a first-class product feature.

There's real research showing that long raw context isn't just expensive, it's also worse for accuracy:

• Liu et al. (2023/2024), "Lost in the Middle: How Language Models Use Long Contexts" (arXiv:2307.03172, TACL 2024), found that model accuracy on long-context retrieval and QA tasks follows a U-shaped curve information in the middle of a long context is retrieved and used substantially worse than information at the start or end. In other words, letting a conversation's context grow indefinitely doesn't just cost more tokens, it can actively degrade the quality of the assistant's use of earlier information.
• Packer et al. (2023), "MemGPT: Towards LLMs as Operating Systems" (arXiv:2310.08560), proposes exactly the architecture this request is asking for: an OS-inspired tiered memory system where a "main context" (fast, in-window) is kept lean via recursive summarization, while evicted content moves to an "external context" (archival store) that can be paged back in on demand. This is a published, working pattern not a hypothetical.
• Follow-on work (MemoryOS, Kang et al. 2025; MemoryBank, Zhong et al. 2024; A-Mem, Xu et al. 2025) has continued to refine tiered/summarized memory for exactly this use case: long-running, multi-session conversational agents.

The pattern is established in the literature. What's missing is a polished, user-facing implementation of it in Claude.ai itself.

Proposed Solution

1. Detection: when a conversation crosses a length/token threshold where cost-per-turn is climbing noticeably, surface an inline, dismissible notice: "This conversation is getting long, which makes each reply slower and more expensive. Summarize older parts to speed things back up? (Uses some tokens now, saves more going forward.)"
2. User-triggered compression: on confirmation, Claude generates a structured summary of the older portion of the conversation (facts, decisions, open threads) and replaces the raw transcript of that portion with the summary in active context while keeping the full original transcript archived and scrollable/re-readable by the user, not deleted.
3. Retrieval on demand: if a later prompt references something that got compressed away, the system should be able to page the relevant original portion back in (MemGPT's core idea) rather than forcing the user to manually dig it up.
4. Fully optional and reversible: this should never happen silently or by default without consent, given that summarization is lossy by nature tone, exact phrasing, and details not deemed "key facts" will not survive compression. The user should stay in control of when the trade-off is worth it.

This is conceptually similar to disk defragmentation: a deliberate, user-initiated cost paid once to restore performance, rather than a silent background process. Framing it that way (transparent cost, clear payoff) would likely make users receptive to opting in rather than feeling like something was done "to" their conversation.

As far as I'm aware, none of the major consumer LLM products (ChatGPT, Gemini, Grok, Kimi) currently offer this as a polished, automatic-but-opt-in feature either this would be a genuine differentiator, not just parity.

Alternative Solutions

_No response_

Priority

High - Significant impact on productivity

Feature Category

Other

Use Case Example

_No response_

Additional Context

_No response_