Loading...
Community presentation
Imagine asking an AI to write a short summary. It produces the first word, then the next, then the next. Each word depends on what came before it. That step-by-step process is h…
Create your own version
Use this visual direction as inspiration for a new Presenton deck.
Use this designCreator prompt
Imagine asking an AI to write a short summary. It produces the first word, then the next, then the next. Each word depends on what came before it. That step-by-step process is how most language models generate text. Now imagine a different approach. First, sketch the shape of the whole answer. Then, fill in the details in a handful of passes. That’s the idea behind next concept modeling, or NCM, a text generation method from Stanford’s Hazy Research team. In the team’s paper, NCM matches a diffusion model summary quality on one benchmark while running up to 31 times faster. That number is real, but it’s easy to misunderstand. The comparison is against a diffusion language model, not ChatGPT or a standard word-by-word model. And NCM is a research system, not a ready-made replacement for the chatbots most people use. So, what is NCM doing differently? Where does the speedup come from? And what can the paper’s results tell us about the future of text generation? Let’s start with the bottleneck NCM is trying to change. Most large language models use autoregressive generation. Autoregressive means each new token is predicted using the tokens that came before it. The model writes the first token, then uses that token to predict the second. It adds the second token to the context, predicts the third, and continues. That gives the model a clear order for constructing a sentence, but it also means the next step must wait for the current one. As the answer gets longer, the model repeats that process again and again. Even if the GPU can perform a lot of calculations in parallel, the generation sequence still has to move forward one token at a time. One reason this can be slow is that, during generation, the model has to repeatedly work with its parameters and the growing context. The exact bottleneck depends on the model, hardware, and serving setup, but the sequential nature of token generation is one important limit. Researchers have explored ways to generate multiple positions at once. Diffusion language models are one approach. They begin with a sequence of masked or incomplete positions and refine them over several passes. But there’s a trade-off. Fewer refinement passes can mean worse quality, while each pass may process a large part of the sequence again. NCM tries a different strategy: generate a structured representation from coarse to fine. NCM is not a new kind of transformer that has replaced transformers altogether. It uses a transformer, but changes what the transformer predicts and the order in which it predicts it. Instead of predicting the next word in a sentence, NCM predicts discrete codes arranged in levels. The first levels give a coarse representation of the text. Later levels add information that was missing from the earlier ones. A useful analogy is drawing a picture. You might first block in the large shapes, then add smaller shapes and shading, then finish with fine details. You don’t need to decide the exact position of every eyelash before you know where the face is. NCM aims to give a model a similar way to organize text generation. It creates a rough representation of the whole sequence first, then adds detail in stages. The word concept can make this sound like the model is writing abstract ideas before words. That’s not quite what the paper means. In NCM, a concept is a code in a learned, multi-scale representation. The codes are intended to capture information at different levels of detail. They aren’t necessarily human-readable ideas or sentences. NCM has two main components: a multi-scale tokenizer and a transformer generator. The tokenizer is based on a multi-scale residual VQ-VAE. In plain language, it learns to represent a passage of text as a stack of discrete codes. The first level is short and coarse. Each later level contains more positions and adds information that earlier levels missed. The final level reaches the full sequence length. When the codes are combined and decoded, they reconstruct text. Training then happens in two stages. Stage 1: teach the tokenizer to encode and reconstruct text. The tokenizer learns to turn text into a hierarchy of codes, then decode those codes back into text. The goal is for the hierarchy to retain enough information that the final reconstruction is accurate. Stage 2: train the generator to predict those codes. The tokenizer is frozen, and a transformer learns to generate its levels in order. At each level, it predicts all the codes at that level in parallel, conditioned on the information represented by the earlier levels. At generation time, the tokenizer’s decoder turns the completed representation back into text. That means the model doesn’t write a finished paragraph during its first pass. It builds the representation that will eventually decode into one. Both NCM and diffusion models generate text through multiple passes. The difference is what happens during those passes. A diffusion language model typically revisits a sequence as it refines it. Depending on the method, each pass may process many or all of the output positions. NCM generates a sequence of levels. Early levels contain fewer positions. Later levels contain more. It predicts a level and moves on to the next one. It doesn’t repeatedly revise the entire sequence in the same way. Here is the short version: diffusion repeatedly refines a sequence, while NCM predicts a hierarchy of increasingly detailed representations. That difference helps explain why NCM can use fewer function evaluations, or NFEs. An NFE is one model evaluation during generation. But counting evaluations alone doesn’t tell us how long a method will take. One pass may be more expensive than another, and implementations differ. The paper therefore also reports wall-clock comparisons. The idea is not that every NCM pass is free. It’s that the early passes can be cheaper because they operate on shorter levels. The 31 times figure comes from the paper’s XSum summarization experiment. The researchers generated summaries using NCM and a diffusion baseline called Aurora LM. They report that NCM achieved comparable Rouge-L quality while running 31 times faster in their measured setup. The benchmark generated 1,024 sequences at a batch size of 16 on a single Nvidia H100 SXM GPU. That’s an important result. It is also a specific result. It does not mean that NCM is 31 times faster than ChatGPT. It does not mean every NCM task runs 31 times faster. And it does not establish that NCM is faster than standard autoregressive models on every workload. The comparison is between NCM and a diffusion language model on a particular summarization benchmark, using the authors’ experimental setup. The paper reports other results, too. On the LM1B language modeling benchmark, NCM achieved better generative perplexity than the strongest diffusion baseline while running 21 times faster. On OpenWebText, the authors report that NCM was competitive with the strongest diffusion baseline while running 10 times faster. These comparisons are evidence that the approach can be efficient on several research tasks. They are not a universal speed guarantee. One of the most striking results in the paper is Sudoku. Sudoku has global constraints. A number placed in one square affects what can go in many other squares. A method that commits to individual output positions in order may find that earlier choices make later choices difficult. NCM’s coarse-to-fine process gives it a different generation structure. It can build a representation of the whole puzzle solution across levels, rather than producing one final answer from left to right. In the paper’s Sudoku experiments, NCM outperformed the autoregressive and diffusion baselines across the tested difficulty levels while using fewer function evaluations than the compared methods. That result is interesting because it shows the method isn’t only about generating fluent sentences. The authors are also testing whether a hierarchy of representations can help with structured tasks that require a globally consistent answer. But Sudoku is a controlled benchmark. Strong performance there doesn’t automatically mean NCM will reason better across the broad range of tasks people give general-purpose assistants. The paper also evaluates German-to-English translation using WMT14. Here, a single headline number wouldn’t tell the whole story. Translation quality is assessed with metrics like BLEU, and results depend on the model, decoding strategy, and evaluation setup. The authors report that NCM can improve its output using minimum Bayes risk decoding, or MBR. In simplified terms, the system generates multiple candidate translations and selects one based on how well it agrees with the others. Generating candidates and comparing them costs additional compute. That makes this a useful example of a broader point: fast generation can be paired with extra inference-time work to improve quality, but that work still has a cost. When you see a result for a new generation method, check both the quality measure and the inference budget used to obtain it. NCM is a promising research direction, but several questions remain. Scale is an open question. The paper studies generators up to 725 million parameters in its scaling experiments. That is enough to investigate the method, but it doesn’t establish how NCM will behave at the sizes of today’s largest deployed language models. The authors report that scaling improved quality in their experiments, but testing much larger systems is still necessary. The output format is structured and bounded. NCM generates through a defined hierarchy, and the experiments use task-specific configurations. That’s different from demonstrating a flexible assistant that can smoothly answer with one sentence, then a page, then a longer report, in the same general-purpose system. Results are benchmark-specific. A speedup on summarization does not tell us the speedup for translation, chat, code, or long-form writing. Each task has different quality requirements and computational costs. Reconstruction quality matters. The tokenizer must preserve the information needed to recover the original text. If details are lost in the representation, the generator can’t reliably restore them later. This is especially important for names, numbers, and other exact details. And finally, the comparison depends on the baselines and setup. Wall-clock performance can change with batch size, sequence length, hardware, and software implementation. A compelling research result should be replicated and tested on the workloads people actually care about. Can you download and run NCM? The situation is more nuanced than the attached article’s “5-byte file” section suggests. There are now published NCM checkpoints on Hugging Face for tasks including XSum, WMT14 German-to-English, Sudoku, TinyStories, and LM1B. The same checkpoint listing marks OpenWebText as pending. So, it would be misleading to say that no NCM models are downloadable. But a downloadable research checkpoint isn’t the same thing as a convenient, general-purpose chatbot. The released models are organized around specific tasks and datasets. You’ll need to follow the project’s code and configuration to run the relevant model, and the checkpoints don’t establish that there’s a drop-in NCM assistant with the breadth and tooling of a current general-purpose LLM. The right takeaway is: some research checkpoints are available, but that does not make NCM a ready-made ChatGPT replacement. Is NCM still an LLM? Yes. NCM changes the generation procedure and representation, but it still uses a transformer to model and generate text. So, the claim that NCM “ends LLMs” misunderstands the result. NCM is better understood as an alternative approach to text generation within the broader language model research landscape. It challenges a familiar assumption: that text must always be generated one token at a time, from left to right. It doesn’t show that autoregressive models are obsolete, or that every future assistant will use NCM. What developers should take away: There are three practical lessons here. First, the 31 times speedup is a meaningful research result, but it applies to a specific comparison: NCM versus a diffusion baseline on XSum summarization, under the authors' reported setup. Second, the method’s central idea is coarse-to-fine generation. A model predicts a short, low-detail representation first, then adds progressively finer levels. This offers a different way to trade off generation speed, compute, and output quality. Third, the most useful next step is independent testing. If you are evaluating NCM for a real application, compare it with your current baseline on the same hardware, at the same batch size, and with the same quality checks. Include the outputs that are hardest to get right, such as numbers, names, and long responses. NCM doesn’t settle the future of language models. It gives researchers a new way to study how text can be generated, and a strong set of results worth investigating further. If you found this video helpful, please like and subscribe for more clear breakdowns of the latest AI research. And let me know in the comments: do you think coarse-to-fine generation could become a practical alternative for everyday AI tools? Thanks for watching. This is the exact video script i am going to teach, so I need slides to explain all these Follow Design: {"palette":["Deep navy #0B1020 — primary background","Electric cyan #39D5FF — active pathways and key concepts","Violet #8B6CFF — secondary process layers","Signal lime #C7F36B — verified takeaways and positive results","Cloud white #F4F7FB — primary text","Slate blue #667085 — secondary text and annotations"],"fonts":{"Inter Tight":"https://fonts.googleapis.com/css2?family=Inter+Tight:ital,wght@0,100..900;1,100..900&display=swap","Inter":"https://fonts.googleapis.com/css2?family=Inter:ital,wght@0,100..900;1,100..900&display=swap","Roboto Mono":"https://fonts.googleapis.com/css2?family=Roboto+Mono:ital,wght@0,100..700;1,100..700&display=swap"},"type":"Inter Tight for assertive technical headings in bold, Inter for body copy and explanatory captions in regular to medium weights, and Roboto Mono for metrics, labels, code-like terms, and benchmark annotations. Use a clear hierarchic scale with compact headings, generous body line height, sentence case for explanations, uppercase mono labels with slight tracking, and bold emphasis only for critical comparisons.","layout":"Use a 12-column grid with wide outer margins and a consistent left alignment. Build each slide around one dominant visual argument, supported by short explanatory text blocks. Use an 8-point spacing rhythm, generous vertical breathing room, and recurring top-left section labels with bottom-right progress markers. Reserve full-width compositions for process diagrams and comparison slides; use split layouts for explanation-versus-evidence moments.","framework_treatment":"Use a dark research-lab canvas with thin luminous rules, layered nodes, and restrained glow. Represent processes as connected pathways, coarse-to-fine systems as nested blocks, and competing methods as parallel tracks. Use flat metric cards with oversized numerals, compact source labels, and clear caveats. Cover slides should feature a bold abstract hierarchy graphic; content slides should alternate between diagrams, benchmark panels, and annotated explanations; closing slides should simplify to one takeaway with a quiet grid fade.","feels_like":"A frontier AI lab briefing crossed with a polished mission-control interface."}
Presentation overview
This community presentation was shared by ADITYA J R as a complete 12-slide example. Imagine asking an AI to write a short summary. It produces the first word, then the next, then the next. Each word depends on what came before it. That step-by-step process is h… The preview lets you review the full sequence in order, rather than judging the design from a single cover image.
Use it as a reference for planning your own deck: notice how the amount of information changes from slide to slide, where visual emphasis appears, and how repeated design choices help the presentation feel connected. Community examples are inspiration, not locked templates, so you can keep the ideas that fit your audience and replace anything that does not.
Learn from the example
Look at the job each slide performs. Identify where the deck introduces its subject, develops the main points, adds evidence or examples, and moves toward a conclusion.
Notice which element attracts attention first and how headings, supporting text, images, and data are separated. Strong hierarchy makes the intended reading order obvious.
Compare spacing, typography, color, and repeated components across the slides. Consistent rules help varied content feel like one presentation instead of unrelated screens.
Make it your own
Begin with your audience and the decision, lesson, or action the presentation should support. Replace the topic, examples, evidence, and visuals with material you can verify, then edit every slide for one clear takeaway. You can borrow the visual direction without copying the creator's wording or message. Presenton will use this community deck as a design reference while you develop content for your own purpose.
