Incremental Summarization: Updating Summaries Without Reprocessing
Consider a customer support memory system that maintains a summary of each customer's interaction history. A customer who contacts support weekly generates 50+ interactions per year. Full re-summarization after each interaction means processing all 50 prior interactions plus the new one, costing 50x more tokens than summarizing just the new interaction. At 10,000 active customers, the difference between full and incremental summarization is the difference between $500 and $25,000 per month in API costs. Incremental summarization makes continuous memory systems economically viable.
Step 1: Detect What Changed
Before updating a summary, determine whether an update is needed and what the new content contributes that is not already captured.
Novelty check: Compare the new content against the existing summary. Send both to the model: "Does the following new content contain any information that is NOT already captured in the existing summary? Answer YES or NO. If YES, list the new information." If the answer is NO, skip the update entirely. This prevents unnecessary API calls when new content repeats previously summarized information (common in customer support where users restate their issue across interactions).
Significance threshold: Not every piece of new information warrants a summary update. Minor details ("user confirmed their email address") do not belong in a high-level interaction summary. Set a significance threshold: "Only flag information as requiring a summary update if it would change a reader's understanding of the customer's situation, preferences, or history." This prevents summary bloat from trivial additions.
Contradiction detection: New content may contradict the existing summary. If the summary says "customer prefers email communication" and the new interaction says "please stop emailing me, I want SMS only," the summary needs correction, not just addition. Instruct the change detection step to flag contradictions explicitly: "Does the new content contradict or update any claim in the existing summary? If so, list the contradictions."
Automated trigger vs continuous: You can run change detection on every new content addition (continuous) or batch new content and run detection periodically (scheduled). Continuous detection costs more but keeps summaries perpetually fresh. Scheduled detection (every 24 hours, every 10 new items) is cheaper and works well for applications where real-time freshness is not critical.
Step 2: Generate a Delta Summary
Once you have identified new information that warrants an update, summarize only the new content. This is the "delta" that will be merged into the existing summary.
Delta prompt: "The following is new content that has been added since the last summary update. Summarize the new information in 2-5 sentences, focusing on: (1) New facts or events not previously captured. (2) Changes to previously recorded information. (3) New preferences, decisions, or outcomes expressed. Do not repeat information already covered in the existing summary."
Context-aware delta: Provide the existing summary as context when generating the delta. This helps the model understand what is already captured and produce a delta that complements rather than duplicates: "Existing summary: [current summary]. New content: [new text]. Generate a summary of ONLY the new information that is not already in the existing summary."
Delta length: Keep delta summaries short, typically 50-200 words depending on the volume of new content. The delta should capture the essence of what changed, not provide a comprehensive summary of the new content in isolation. Longer deltas make the merge step harder and more prone to redundancy.
Step 3: Merge Delta into Existing Summary
The merge step combines the existing summary with the delta to produce an updated summary. This is the most nuanced step because it must resolve contradictions, eliminate redundancy, and maintain coherence.
Merge prompt: "You have an existing summary and a delta containing new information. Produce an updated summary that: (1) Incorporates all new information from the delta. (2) Replaces any information in the existing summary that the delta contradicts or updates. (3) Removes redundancy where the delta overlaps with existing content. (4) Maintains the same approximate length as the existing summary (you may grow by up to 20% if the new information is substantial). (5) Reads as a coherent, self-contained summary, not as an original plus amendments."
Length control: Without explicit length control, incremental updates cause summaries to grow monotonically. Each merge adds new information but rarely removes old information that has become less relevant. Set a target length and instruct the merge step to compress older, less relevant information to make room for new additions. "Target length: 300 words. If including the new information would exceed this length, compress or remove the least important details from the existing content to stay within budget."
Versioning: Keep the previous summary version before overwriting with the merged version. If the merge produces a poor result (coherence drop, hallucination introduction), you can roll back to the prior version and retry. A simple version history (current, previous, two-versions-ago) costs negligible storage and provides essential safety.
Step 4: Schedule Periodic Full Re-Summarization
Incremental updates accumulate small errors over time. Each merge step makes subtle decisions about what to keep and compress, and after 10-20 merges, the summary may have drifted from what a fresh full-pass summarization would produce. The original source's emphases may have shifted, early content may have been over-compressed, and the narrative structure may have become disjointed from repeated patch-and-merge operations.
Full refresh schedule: After every 10-20 incremental updates, perform a full re-summarization from all source content. This resets the summary to a clean, coherent baseline. Compare the full re-summarization against the incrementally maintained version to measure drift: if they diverge by more than 20% (measured by cosine similarity of their embeddings or by LLM-as-judge comparison), the incremental updates are introducing too much drift and the refresh frequency should increase.
Hybrid schedule: The optimal pattern for most applications is: incremental updates for every new content addition (keeping the summary fresh in real time) with a full refresh once per week or once per 15 updates (resetting accumulated drift). The full refresh catches information that was incorrectly compressed, fixes narrative coherence, and re-balances emphasis across the entire source.
Cost comparison: For a customer with 4 interactions per week and a 20-interaction history, incremental summarization costs roughly $0.01 per week (4 delta + merge operations at $0.0025 each). A weekly full refresh costs roughly $0.05 (processing all 20 interactions). Combined cost: $0.06 per customer per week. Full re-summarization on every interaction would cost $0.20 per week (4 full passes). The hybrid approach costs 70% less while maintaining summary quality.
Patterns for Specific Use Cases
Conversation memory: Summarize conversation turns incrementally after every N turns (3-5 is typical). The delta is the new turns. The existing summary is the conversation context. This is the pattern used by ChatGPT, Claude, and other conversational AI systems for managing long conversations within context windows.
Document version tracking: When a document is edited (Google Docs, Notion, wiki pages), generate a delta summary of the diff rather than re-summarizing the full document. The delta captures what changed (added paragraph about pricing, removed section on legacy features, updated statistics). Merge this into the existing document summary.
Knowledge base maintenance: When new documents are added to a topic cluster, incrementally update the topic-level summary. "The existing summary covers 12 documents about machine learning deployment. A 13th document has been added covering model monitoring. Update the topic summary to include the monitoring perspective."
User profile evolution: User preference profiles grow over time as the user interacts with the system. Each new interaction may reveal new preferences, confirm existing ones, or change previously stated preferences. Incremental summarization of user profiles preserves the full history while keeping the active profile summary at a fixed, manageable length.
Handling Conflicting Information Across Updates
The trickiest aspect of incremental summarization is handling information that changes over time. A customer's address, a project's deadline, a product's pricing, all of these may appear in the summary and then change in a later update.
Recency-wins policy: When the delta contradicts the existing summary, the newer information takes precedence. The merge prompt should explicitly state: "If new information contradicts the existing summary, update the summary to reflect the most recent information. Do not preserve outdated claims." This is the correct policy for factual attributes (addresses, statuses, preferences).
Accumulation policy: Some information accumulates rather than replaces. A summary of a customer's purchase history should accumulate orders, not replace old orders with new ones. Distinguish between replacing attributes (current address) and accumulating events (order history) in your merge instructions.
Temporal markers: When important information changes, preserve the temporal context: "Previously preferred email (as of March 2026), now prefers SMS (as of July 2026)." Temporal markers make the summary self-documenting about when changes occurred, which is valuable for audit trails and understanding preference evolution.
Incremental summarization detects new information, generates a delta summary, and merges it into the existing summary without re-processing the entire source. This reduces cost by 70-90% compared to full re-summarization on every update. Schedule periodic full refreshes (every 10-20 updates) to reset accumulated drift. Handle contradictions with a recency-wins policy for changing attributes and an accumulation policy for event histories.