Text Summarization

15.1 Introduction to Text Summarization

15.1.1 What Is Text Summarization

Text summarization is the process of producing an abridged (shortened) version of a text while strictly retaining the key, relevant information. It is one of the most practically impactful applications of NLP because it directly addresses information overload — the situation where the volume of available text far exceeds what a person can read in the available time.

The challenge, though it appears simple at first glance, is substantial for machines. Humans read a 400-page novel and can explain the plot to a friend in three minutes — we naturally identify what matters and discard the rest. For a computer, automatically identifying the most important information in a text and expressing it in a coherent, concise format requires solving several hard problems simultaneously: understanding what the text is about, judging what a reader would consider important, and generating (or selecting) language that captures that importance concisely.

Text summarization has wide-ranging real-world applications:

• Email summarization condenses long email threads into the key points and action items, saving professionals from reading dozens of back-and-forth messages.
• Minutes-of-meeting summarization captures action items and decisions from lengthy discussions that might last hours.
• Research paper summarization helps researchers quickly assess whether a paper is relevant to their work, often by generating a short abstract or title.
• Customer complaint summarization extracts the core issues from batches of feedback, helping support teams prioritize and respond.
• Search engine snippets — when you search on Google, the short 26-word description under each result is itself a tiny extractive summary of the target page.
• News aggregation — apps that condense daily news into a 5-minute digest are performing multi-document summarization.

The professor emphasized that these examples span healthcare, finance, search, and many other domains, making text summarization a universally relevant NLP task.

15.1.2 Industry Experience Discussion

During an opening discussion, students shared their real-world experience with text summarization, providing concrete illustrations of the concepts discussed above.

Healthcare alert monitoring: One student described a multi-agent workflow system in the healthcare domain that processes monitoring alerts from multiple tools. Each agent provides a brief summary of its alerts, and a downstream agent consolidates these into a root cause analysis. This system uses OpenAI's GPT-5 via an enterprise license, with data grounded within the organization for privacy. Key challenges include:

• Cost: Token-based pricing applies even with enterprise licenses, and the volume of alerts can make this expensive.
• Hallucinations: The system occasionally attributes one tool's alert root cause to another tool — a dangerous error in healthcare monitoring where misdiagnosis of system failures could have real consequences.
• Accuracy: While imperfect, the system still outperforms the previous manual process in both speed and consistency.

Financial asset management: Another student described working in a domain where numerical performance data across products is converted into natural language and then summarized into one-page reports that salespeople use when meeting clients. The system uses prompt caching for token optimization (reusing cached prompt prefixes across similar queries to reduce API costs) and processes millions of numerical data points into coherent narratives.

Real-world domain connection: These student examples illustrate that text summarization is not an academic exercise — it is a production-grade capability deployed in healthcare monitoring (root cause analysis), financial reporting (narrative generation from numerical data), and many other industries. The choice of summarization method (rule-based, extractive, abstractive, or LLM-based) depends on the specific constraints of the domain: privacy requirements, cost budgets, accuracy thresholds, and the nature of the input data (text vs. numerical vs. multimodal).

15.2 Types of Text Summarization

Text summarization can be classified along several dimensions. Each dimension represents a design choice that affects the algorithm, the data requirements, and the quality of the output.

15.2.1 By Input Scope: Single-Document vs. Multi-Document

Single-document summarization takes a single input — one PDF, one email, one customer review, one research paper — and produces a summary. The output can range from a short abstract of roughly 200 words to a single-sentence heading or title. Generating a good title for a research paper, for instance, is itself a summarization task: the title must capture the key contribution of the paper in very few words. The shorter the required summary, the harder the task, because every word must count.

A surprisingly strong baseline for single-document news summarization is simply extracting the very first sentence — in news writing, the first sentence often contains the most important information (the "inverted pyramid" style).

Multi-document summarization takes a group of documents on the same topic and produces a unified summary. A typical use case: "For all research papers in area X, give me a summary." The system must first identify the top-K relevant documents from the collection, then extract the most important sentences across those documents while managing redundancy — because multiple documents may express the same information using different wording.

15.2.2 By Output Style: Extractive vs. Abstractive

This is the most important design dimension and the one the professor emphasized most heavily.

Extractive summarization selects sentences, phrases, or paragraphs directly from the input text. The system does not generate new language; it identifies and extracts existing content. For example, given a news article about flooding, an extractive summary would reproduce exact sentences like "Several roads were flooded" verbatim from the source.

Abstractive summarization generates new language that may not appear verbatim in the source. Words can be added, deleted, reordered, or paraphrased — much like how a human would describe a movie review using their own words rather than quoting the script. Abstractive summaries read more naturally and can capture information spread across multiple sentences into a single concise expression.

The key trade-offs:

A practical strategy that many production systems use combines both: use extractive methods first to identify the most important sentences, then use an LLM to paraphrase and polish those extracted sentences into more fluent abstractive prose. This layered approach gives the reliability of extractive selection with the readability of abstractive generation, though it consumes more computational resources and cost.

15.2.3 By Focus: Query-Focused vs. Generic

Generic summarization summarizes the entire content of a document without any specific user query. "Summarize this research paper" is a generic task — the system must decide what is important across the whole document. This is what most people think of when they hear "text summarization."

Query-focused summarization (also called focused summarization or topic-based summarization) targets a specific topic or question. The summary must capture information relevant to the query keywords, ignoring text that does not answer the prompt. For example: "From my emails, extract all those where students have shown interest in MTech or PhD research" is query-focused — the system must filter for relevance to the specific topic of student interest in research programs.

Similarly, complex question answering over documents — such as asking about the efficacy of a specific medical treatment for a given age group and health condition — is a form of query-focused text summarization. The system acts as a focused answer builder, knitting together relevant text segments into a coherent response.

Both types can combine with single-document or multi-document settings, yielding four possible combinations:

15.2.4 By Learning Approach: Supervised vs. Unsupervised

Supervised approaches require labeled training data — pairs of (document, summary). The model learns from these pairs to generate summaries for unseen documents. Any supervised method (neural networks, LSTMs, transformers, traditional classification) requires this labeled data. The quality of the summary depends heavily on the quality and quantity of the training data.

Unsupervised approaches work without labeled data. They use only the input document(s) and apply statistical or graph-based techniques to extract important content. These are cheaper to deploy and often competitive with supervised methods for extractive summarization. TF-IDF and PageRank (covered in sections 15.4 and 15.5) are the two primary unsupervised methods discussed in this lecture.

15.3 The Text Summarization Pipeline

The three stages are: Content Selection (what to include), Sentence Ordering (how to arrange it), and Sentence Realization (how to clean it up). The professor described these using a "Three-Act Play" metaphor: Act 1 decides who makes the cut, Act 2 tells a coherent story, and Act 3 polishes the diamond.

15.3.1 Content Selection

Content selection identifies which sentences (or words, phrases, paragraphs) should be part of the summary. This is the most critical step — if the wrong sentences are selected, no amount of post-processing can salvage the summary.

The simplest approach works as follows:

1. Fragment the document into sentences via sentence tokenization.
2. Assign each sentence a weight based on relevance to the query (for query-focused summarization) or to the document's overall topic (for generic summarization).
3. Rank the sentences by weight.
4. Select the top-K sentences for the summary.

Various techniques exist for computing these weights, ranging from simple TF-IDF scoring (section 15.4) to graph-based PageRank (section 15.5) to supervised classification (section 15.6). The choice of weighting method is the primary differentiator between extractive summarization systems.

The connection to information retrieval (IR) is direct: content selection is fundamentally about retrieving the most relevant textual units from a large pool, which is the same core problem that search engines solve. A search engine retrieves documents; a summarizer retrieves sentences. The mathematical tools — TF-IDF, cosine similarity, ranking — are the same.

15.3.2 Sentence Ordering

After selecting the best sentences, they must be arranged into a coherent, readable summary. Simply concatenating high-scoring sentences in arbitrary order produces gibberish — imagine a summary that starts with a conclusion, jumps to background context, and ends with a methodology detail.

The professor discussed several ordering strategies:

• Original position ordering: Sentences occurring earlier in the source document appear earlier in the summary. A sentence from the first paragraph comes first; a sentence from the last paragraph comes last. This is the simplest heuristic and works well for single-document summarization of news articles (which follow the "inverted pyramid" structure where the most important information comes first).

• Similarity-based clustering: Sentences with similar content are placed adjacent to each other, creating thematic coherence. This uses cosine similarity between sentence embeddings to group related sentences together.

• Chronological/temporal ordering: If the text contains dates or time references, sentences can be ordered chronologically. This is natural for narrative texts, event timelines, and news coverage.

• Domain-specific rules: Different domains have different natural orderings. For example, a biography summary should follow a life-chronology (birth → education → career → legacy), while a definition summary should follow genus → species → synonym → subtype. The professor provided a table of domain-specific templates:

• Knowledge graph-based ordering: Using knowledge graphs to identify semantically related terms and ensure conceptually linked sentences are placed adjacent to each other.

• Small language models for ordering: Tiny or edge-deployed language models can be trained specifically for the sentence-ordering task — feed them the selected sentences and let the model output the optimal order. This treats ordering as a separate, simpler sub-problem that a small model can handle, without needing a full LLM.

15.3.3 Sentence Realization (Cleaning)

The final stage cleans the assembled summary to produce polished, readable output. Extracted sentences are often too long, contain broken references, or have redundancies when placed side by side.

The cleaning operations include:

1. Simplification (pruning): Strip out unnecessary clauses such as appositives, attribution clauses, and initial adverbials.

• Original: "Rebels agreed to talks with government officials, international observers said Tuesday."
• Pruned: "Rebels agreed to talks with government officials." (removed attribution clause)

1. Coreference resolution (anaphora fixes): If an extracted sentence starts with "He" or "She," the reader will not know who is being referred to. The system must replace the pronoun with the full entity name.

• Original: "He has immunity from prosecution..."
• Fixed: "Gen. Augusto Pinochet has immunity from prosecution..."

1. Deduplication: Removing duplicated sentences — even if worded differently, two sentences may convey the same information, and the summary has a length constraint.

1. Coherence editing: Ensuring smooth transitions between sentences, resolving ordering issues discovered during combination, and performing general readability improvements.

For complex question-answering pipelines, the realization stage may also include named entity recognition (to ensure key entities are properly represented), regex-based guardrails (increasingly important in agentic AI systems to prevent unintended actions such as agents modifying databases), and rule-based coreference resolution.

15.4 Unsupervised Content Selection: TF-IDF Approach

The TF-IDF approach dates back to Hans Peter Luhn's pioneering work in 1958 at IBM. Luhn's insight was that the frequency of a word in a document, weighted by how rare that word is across the entire collection, is a strong signal of the word's importance. This idea remains one of the most widely used techniques in information retrieval and text summarization today.

15.4.1 Method

The TF-IDF content selection method proceeds in four steps:

1. Compute TF-IDF for each word: For each word $w$ in each document $D$ in the corpus, compute its TF-IDF weight.
2. Score each sentence: For each sentence in each document, compute the sentence weight as the sum of the TF-IDF scores of its constituent words.
3. Rank all sentences: Sort sentences by their computed weights in descending order.
4. Select top-K: The top-K scoring sentences form the extractive summary.

For query-focused summarization, the computation focuses only on the query terms: a sentence receives a non-zero score only if it contains query words. For generic summarization, the computation considers all words, and topic words (words appearing in specific documents but not widely across the corpus) naturally receive higher TF-IDF scores.

15.4.2 Worked Example: TF-IDF Content Selection

15.4.3 Limitations of TF-IDF for Summarization

Despite these limitations, TF-IDF remains popular for content selection due to its simplicity, interpretability, zero training cost, and surprisingly competitive performance. It is often the first baseline to try before moving to more complex methods.

15.5 Unsupervised Content Selection: Graph-Based Approach (PageRank)

15.5.1 Method

The graph-based approach proceeds through these steps:

1. Sentence splitting: Fragment the document into individual sentences.
2. Vector representation: Convert each sentence into a vector representation. This can use sparse TF-IDF vectors or dense contextual word embeddings. For contextual embeddings, a sentence transformer (a neural network that produces a fixed-size vector for any input sentence) computes word embeddings for each word in the sentence and then combines them — typically by averaging across dimensions or taking the element-wise maximum — to produce a single sentence embedding ${\mathbf{s}}_i\in {\mathbb{R}}^d$.
3. Pairwise similarity: Compute the cosine similarity between every pair of sentence vectors. This produces a symmetric similarity matrix where entry $(i,j)$ represents how similar sentence $S_i$ is to sentence $S_j$:

$$\text{sim}(S_i,S_j)=\frac{{\mathbf{s}}_i\cdot {\mathbf{s}}_j}{\Vert {\mathbf{s}}_i\Vert \times \Vert {\mathbf{s}}_j\Vert }$$ The cosine similarity ranges from 0 (no overlap) to 1 (identical). The diagonal entries (self-similarity = 1) are ignored.

1. Graph construction: Treat each sentence as a node. Create an edge between sentence pairs whose cosine similarity exceeds a chosen threshold (e.g., 0.05). Pairs below the threshold are not connected — this prevents weakly related sentences from influencing each other's PageRank scores.
2. PageRank computation: Run the PageRank algorithm on the constructed graph to rank sentences by their centrality.
3. Sentence selection: Select the top-K ranked sentences for the summary.

15.5.2 Worked Example: Graph-Based Summarization

15.5.3 Understanding the PageRank Formula

Initialization: All sentences start with equal PageRank scores. With 5 sentences, the initial score for each is:

$$P{R}^{(0)}(S_i)=\frac{1}{5}=0.2\text{for all }i$$

Iteration 1: For each sentence $S_i$, the new PageRank is computed by summing contributions from linked neighbors. For example, S1 is connected to S2 and S3 (but not S4 or S5). The computation uses only the edges that exist — if S1 is not linked to S5 and S4, those contributions are zero.

Subsequent iterations: Each iteration updates all PageRank scores simultaneously using the previous iteration's values. Convergence is reached when scores stabilize (change less than a threshold, e.g., $10^{-6}$) or after a fixed number of iterations — analogous to the stopping condition in gradient descent.

15.5.4 Trade-offs of Graph-Based Summarization

15.6 Supervised Content Selection

Supervised methods for content selection require labeled training data — pairs of (document, summary) — from which the model learns to identify which sentences belong in a summary. The professor posed this as an open discussion to the class, eliciting several approaches that span the spectrum from classical machine learning to modern LLMs.

15.6.1 Discussion: How Would You Implement Supervised Summarization?

The features used for binary classification include:

• Position in the document: First sentences are often important (in news articles, the most extract-worthy sentence is typically the title, followed by the first sentence of paragraph 2, then paragraph 3).
• Length of the sentence: Very short sentences (fewer than 5 words) are rarely useful in a summary.
• Amount of information carried: Measured by TF-IDF weight or log-likelihood ratio score — sentences with more "salient" words carry more information.
• Degree of redundancy with other sentences: A sentence that is highly similar to already-selected sentences contributes less new information.
• Whether the sentence contains key entities or topic words: Named entities (people, organizations, locations) and topic-specific terms are strong signals of importance.

During training, the model learns from labeled data which feature patterns correspond to "include in summary." During testing, each sentence's features are evaluated and the model outputs a binary decision (include or exclude).

RAG (Retrieval-Augmented Generation): One student suggested using RAG — creating abstracts of internal documents, building a knowledge tree of high-ranked branches, and feeding these to a small LLM with self-attention for text generation. The professor noted this was an interesting idea worth exploring but acknowledged uncertainty about how RAG would generate the relevant sentences for summarization specifically. A possible combination involves using knowledge graphs for abstractive summarization to generate coherent summaries related to the query, combined with RAG-based chunk retrieval, though this approach would be expensive.

15.6.2 Challenges of Supervised Approaches

15.6.3 Industry Perspective on Classical ML vs. Deep Learning

A practical insight from industry: traditional ML models are still widely used in production for text summarization and other NLP tasks, even in the era of LLMs. The professor emphasized this point — it is not always the case that the most complex model is the best choice.

15.7 Handling Redundancy: Maximal Marginal Relevance (MMR)

Maximal Marginal Relevance (MMR) is the most popularly used measure for balancing relevance against redundancy, particularly in query-focused summarization. It was originally proposed by Jaime Carbonell and Jade Goldstein in 1998.

15.7.1 The MMR Concept

MMR addresses two simultaneous objectives:

1. Informativeness (relevance): Selected sentences must be highly relevant to the user's query.
2. Non-redundancy: Selected sentences must not duplicate information already captured in the summary.

The core idea is iterative greedy selection: at each step, select the sentence (or document) that is most relevant to the query while being least redundant with already-selected items. Think of it like packing a suitcase for a trip — you want to bring the most useful items (relevance), but you would not pack three identical white shirts (redundancy). Each new item should add something the others do not have.

15.7.2 The MMR Formula

$$\text{MMR}(D_i)=\lambda \cdot \text{Sim}(D_i,Q)-(1-\lambda )\cdot \underset{D_j\in \text{Selected}}{\max }\text{Sim}(D_i,D_j)$$

where:

• $D_i$ is the candidate document (or sentence) being evaluated
• $Q$ is the user's query
• $\text{Sim}(D_i,Q)$ is the relevance — the cosine similarity between the candidate and the query (how well it answers the question)
• ${\max }_{D_j\in \text{Selected}}\text{Sim}(D_i,D_j)$ is the redundancy — the maximum similarity between the candidate and any already-selected item (how much it overlaps with what we already have)
• $\lambda \in [0,1]$ is a tunable parameter balancing relevance vs. redundancy

The first term rewards relevance — the more similar $D_i$ is to the query, the higher the score. The second term penalizes redundancy — the more similar $D_i$ is to an already-selected item, the more the score is reduced.

The role of $\lambda$:

• $\lambda =0.5$ (default): Equal weighting of relevance and redundancy.
• $\lambda >0.5$: Prioritize relevance over diversity. Use this when missing a key fact is costly (e.g., medical or legal domains where a missed detail could have serious consequences).
• $\lambda <0.5$: Prioritize diversity over relevance. Use this when exploration and breadth of coverage matter more (e.g., exploratory search, brainstorming).

15.7.3 Worked Example: MMR for Document Selection

15.7.4 Edge Case: Identical MMR Scores

15.7.5 MMR Applied to Sentence Selection

The MMR concept, originally demonstrated above for document selection, applies identically to sentences. In the sentence-level variant:

• Replace each $D_i$ with a sentence $S_i$ from the corpus.
• Compute cosine similarity between all pairs of sentence embeddings (using sentence transformers from Hugging Face, which compute word embeddings for each word using contextual word embedding algorithms and then combine them by averaging or taking the element-wise maximum to produce a single vector for the entire sentence).
• Select sentences iteratively using the same MMR formula.
• Stop when K sentences have been selected (where K is the desired summary length in sentences).

The process is identical: first select the sentence with the highest relevance to the query, then iteratively add sentences that maximize MMR (balancing relevance against redundancy with all previously selected sentences).

15.7.6 MMR as the Standard for Query-Focused Summarization

15.8 Sentence Ordering

After content selection (and redundancy removal via MMR), the selected sentences must be ordered into a coherent summary. This is the second stage of the summarization pipeline — and one that is often underappreciated. A summary with perfectly selected but randomly ordered sentences reads like a ransom note: each piece is meaningful on its own, but the combination is incoherent.

15.8.1 Ordering Strategies

15.8.2 Multi-Document Ordering Challenges

When sentences come from multiple source documents, their original positions are not directly comparable. If sentence A appears first in document 1 and sentence B appears last in document 2, the relative ordering is ambiguous — neither sentence has a natural claim to being "earlier" in the summary.

This is one of the key challenges in multi-document query-focused summarization. Solutions include:

• Chronological anchoring: If the source documents have publication dates, use those to establish a temporal ordering.
• Thematic clustering with transitions: Group sentences by subtopic, order the groups logically, and add transitional phrases between groups.
• Learned ordering models: Train a model on multi-document summaries with known orderings to learn the patterns.

15.9 Neural Text Summarization

15.9.1 LSTM Encoder-Decoder with Attention

A bidirectional LSTM encoder-decoder with attention mechanism can be trained for text summarization, using the same architecture as sequence-to-sequence models for machine translation. The architecture works as follows:

• Encoder: A bidirectional LSTM reads the source document word by word (in both forward and backward directions) and produces a sequence of hidden representations ${\mathbf{h}}_1,{\mathbf{h}}_2,\dots ,{\mathbf{h}}_n$ that encode the document's content.
• Decoder: Another LSTM generates the summary token by token, producing one word at a time conditioned on the previously generated words.
• Attention mechanism: At each decoding step, the attention mechanism computes a weighted combination of the encoder hidden states, allowing the decoder to "look back" at the most relevant parts of the source document when generating each summary word. This acts as a spotlight — the decoder focuses on different parts of the input as it writes different parts of the output.

The padding problem: LSTMs require all input sequences to be of the same length (because the recurrent computation proceeds step by step, and the GPU processes batches in parallel). If training examples vary in length — one summary is 5 lines and another is 500 lines — the shorter one must be padded with zeros to match the longest. This consumes tokens unnecessarily and inflates computational cost. The longer the maximum sequence length in the training set, the more wasted computation on padding tokens.

15.9.2 Transformer-Based Models

Transformer models (including T5, GPT, Qwen, Llama, and others) can be used for text summarization. These models have varying parameter counts — from 1 billion to 700 billion parameters — and can be fine-tuned on domain-specific summarization data.

The transformer architecture addresses the LSTM's long-range dependency problem through self-attention, which allows every token in the input to attend directly to every other token, regardless of distance. This means the model can capture relationships between the first and last sentence of a document just as easily as between adjacent sentences.

During training for summarization, the data is typically structured as: ARTICLE TEXT <EOS> SUMMARY <EOS> <pad>. The model calculates loss only when predicting the summary portion — it learns to "read" the article and then "write" the summary. The same padding concerns apply for RNN-based variants, though transformer architectures handle variable-length inputs more naturally through positional encoding (each token's position is encoded as a vector that is added to its embedding, allowing the model to distinguish word order without sequential processing).

15.9.3 LLM-Based Summarization

Modern LLMs (Large Language Models) can perform text summarization through prompting — sending the document with an instruction to summarize. This is the simplest approach from an implementation perspective:

"Please summarize the following article in 3 sentences: [article text]"

For production use in cost-sensitive or accuracy-critical environments, explainable pipeline approaches (content selection → ordering → realization) are preferred because they offer:

• Interpretability: You can trace exactly which sentences were selected and why.
• Lower hallucination rates: Extractive methods only use text from the source document.
• Controllability: You can adjust each stage independently (e.g., change the ordering strategy without retraining the content selector).

15.9.4 The Cost-Quality-Scalability Triangle

15.10 Evaluation: ROUGE Score

15.10.1 What ROUGE Measures

ROUGE works by computing n-gram overlap — counting how many word sequences of length $n$ appear in both the machine-generated summary and the human reference summary. The most common variants are:

• ROUGE-1: Unigram (single word) overlap — measures whether the summary uses the same individual words as the reference.
• ROUGE-2: Bigram (two-word phrase) overlap — measures whether the summary uses the same phrases as the reference. This is a stricter measure than ROUGE-1 because matching two consecutive words is harder than matching individual words.
• ROUGE-L: Longest common subsequence — measures the longest sequence of words that appears in both the summary and the reference, allowing for gaps.

The professor indicated that ROUGE would be covered in detail in the next session (the end-semester review/recap session), as the current session ran out of time. The exam is expected to include simple numerical problems on ROUGE computation.

15.11 Exam Guidance Summary

15.11.1 Expected Exam Questions

• Numerical problems are expected on:
• MMR computation — the full iterative process with worked examples (3 iterations, 5 documents, computing MMR scores at each step). This is the most likely numerical question type.
• TF-IDF calculation and sentence scoring — computing IDF for words in a corpus, computing TF-IDF per word per document, and scoring sentences to select the top-K.
• IDF computation — understanding the formula $N/N_k$ or $\log (N/N_k)$ and applying it to a given corpus.
• ROUGE score — a simple numerical problem. This will be covered in the review session.

• Conceptual questions on:
• Extractive vs. abstractive summarization (trade-offs, when to use which)
• Unsupervised vs. supervised approaches (advantages, disadvantages, when each is preferred)
• The text summarization pipeline stages (content selection, ordering, realization)
• The trade-offs between different methods (cost, quality, scalability)

• Application-oriented questions: Given a specific application scenario, recommend and justify an approach (e.g., "For this application, which method would you use and why?"). These questions test the ability to apply the cost-quality-scalability framework to novel situations.

Study focus: The numerical computations (MMR, TF-IDF, IDF) and the conceptual framework (types of summarization, pipeline stages, trade-offs) are the primary study targets for this module.

End-sem review session: A recap session covering post-midsem content from the end-semester perspective is planned. This will cover ROUGE in detail and provide an opportunity to clarify doubts.

15.12 Key Industry Applications

15.12.1 Industry Examples

• Healthcare alert monitoring (Optum): A multi-agent workflow system that processes monitoring alerts from multiple tools, generates per-alert summaries, and consolidates them into root cause analysis. Uses GPT-5 via enterprise API with data grounding for privacy. Key challenges: cost (token-based pricing), hallucination across tool boundaries (the system occasionally attributes one tool's alert to another), and accuracy that, while imperfect, outperforms the previous manual process. This is an example of multi-document query-focused abstractive summarization using LLMs.

• Financial asset management: Converting numerical product performance data into natural language summaries for sales presentations. Processes millions of data points into one-page client reports. Uses prompt caching for optimization. This is an example of structured-data-to-text summarization — the input is numerical, and the output is a narrative summary.

• Email summarization: Condensing long email threads into key points and action items. Single-document or multi-document (depending on thread length), typically extractive or hybrid.

• Minutes of meetings: Automatic generation of meeting summaries and action items from meeting recordings. This involves speech-to-text preprocessing followed by multi-document summarization.

• Research paper summarization: Generating abstracts, titles, or topic-specific summaries from research papers. Single-document generic summarization; a strong baseline is simply extracting the first sentence.

• Customer complaint analysis: Extracting core issues from batches of customer feedback. Multi-document query-focused summarization where the implicit query is "what are the main problems?"

• Google search and ChatGPT: Query-focused text summarization in everyday use — when users ask questions, the system produces concise answers from large document collections. Google search is noted as having less carbon footprint per query compared to LLM-based approaches, because it uses lightweight extractive snippets rather than generating full abstractive answers.

• Agentic AI systems: Text summarization as a component in larger agent workflows, where multiple specialized agents handle different aspects of the summarization pipeline (one agent selects content, another orders it, a third cleans it up).

• Guardrails in agentic systems: Rule-based filtering using regular expressions to prevent unintended actions (e.g., blocking update queries, preventing agents from modifying databases). Coreference resolution and named entity recognition as part of the summarization realization stage. These guardrails are essential for production safety — without them, an autonomous agent summarizing a customer email might accidentally trigger database modifications.