SlideGen: Multimodal Slide Generation

• SlideGen is a modular framework for generating academic slides by jointly processing text, visuals, and design elements.
• Its six-agent architecture coordinates distinct tasks such as content extraction, asset mapping, layout selection, and note synthesis.
• Evaluations show SlideGen outperforms baselines in visual quality, content faithfulness, and geometric balance, with metrics like SlideQA and GAD.

SlideGen is an agentic, modular, and visual in the loop framework for scientific paper-to-slide generation that treats academic slide creation as a multimodal reasoning problem rather than as text-only summarization. It orchestrates a group of vision language agents that reason collaboratively over document structure and semantics, producing editable PPTX slides with logical flow and compelling visual presentation. The system is designed for long-context understanding, deliberate visual planning, and coordinated generation of slide content, layout, formulas, notes, and deck-level styling, and it is reported to outperform strong baselines in visual quality, content faithfulness, and readability (Liang et al., 4 Dec 2025).

1. Problem setting and design rationale

Generating academic slides from scientific papers requires simultaneous handling of textual hierarchy, figures, tables, equations, presentational sequencing, and design constraints. SlideGen explicitly frames this as a multimodal task that requires both long context understanding and deliberate visual planning, in contrast to approaches that largely reduce the problem to text only summarization (Liang et al., 4 Dec 2025).

This problem formulation is significant because research papers are highly structured documents with sections, figures, equations, and tables that carry complementary information. Earlier automatic systems such as "SlideSpawn: An Automatic Slides Generation System for Research Publications" convert the PDF to XML, predict sentence salience, select sentences using ILP, cluster them, and place referenced graphical elements next to selected text (Kumar et al., 2024). A plausible implication is that SlideGen extends this line of work from content extraction and sentence selection toward a more explicitly design-aware and visually grounded generation pipeline.

SlideGen’s stated objective is not merely to summarize a paper, but to produce an editable deck with logical flow and compelling visual presentation. That emphasis makes slide generation closer to a document design task with semantic, geometric, and visual subproblems coupled across the full deck rather than a single-pass summarization problem. This suggests a shift from local sentence importance toward globally coordinated multimodal composition.

2. Six-agent architecture

SlideGen decomposes paper-to-slide generation into six specialized vision language agents, each implemented as an LLM prompt that reads and writes JSON-structured data (Liang et al., 4 Dec 2025).

Agent	Function	Output
Preprocessing	Convert PDF→Markdown and extract images/figures via DOCLING and MARKER	Text and visual asset libraries
Outliner	Infer a two-level presentation outline	JSON with metadata, sections, slide titles, and 3–5 bullets
Mapper	Assign each visual asset to slide indices with rationale	JSON mappings from figures/tables to slides
Formulizer	Specialized Mapper for equations	JSON mapping formulas to target slides
Arranger	Choose one of 19 hand-curated layout templates	JSON with pattern $\pi_i$, coordinates, and slots
Refiner / Speaker	Post-process slides and synthesize notes	Merged/re-colored deck and 2–5 sentence presenter notes

Preprocessing constructs two asset libraries: text assets, defined as section headings mapped to paragraph text, and visual assets, defined as figure/table caption mapped to image file. The Outliner reads the full document and infers a two-level presentation outline organized as sections, slides, and bullet points, while also outputting metadata such as title, author, and date. The Mapper assigns figures and tables to slide indices with rationales, and the Formulizer performs the analogous function for equations by either cropping formula images, extracting LaTeX code, or taking user-drawn bounding boxes.

The Arranger is the explicitly design-oriented component. It chooses among 19 hand-curated layout templates, denoted $T1 \ldots T19$, based on the number, type, and aspect ratios of assets on a slide. The Refiner then applies deck-level post-processing: it merges consecutive text-only slides, switching to a 2-text-block template, and extracts a base color from the deck’s figures by pixel counting, removes near-black/white, picks the mode RGB, and refines it on a fixed-hue HSV plane via a simple “move right (↑ saturation) then down (↓ value)” rule so that theme colors remain vivid yet dark enough for contrast. Finally, the Speaker synthesizes 2–5 sentence presenter notes per slide or subsection from textual and visual rationales.

Architecturally, this decomposition makes the pipeline modular at the level of document understanding, asset alignment, geometric layout, visual theme control, and speaking support. A plausible implication is that the JSON interfaces make each stage inspectable and editable, which is particularly relevant for expert workflows where slide generation is often followed by manual revision.

3. Multimodal reasoning, geometry, and visual planning

All SlideGen agents communicate via JSON, and the system alternates between LLM reasoning and deterministic layout steps. There is no single global gradient; instead, the paper describes a joint objective over all slides that balances text–figure alignment, content faithfulness, and visual aesthetics. The only explicit optimization metric is the Geometry-Aware Density (GAD) score, defined per slide as follows (Liang et al., 4 Dec 2025):

$OM_i = 1 - |\rho_i - \tau|$

$$M_i^{eff} = \# \text{ of content regions with area } \ge a_{min}$$

$$FR_i = \max\left(0, 1 - \frac{(M_i^{eff} - M^*)^2}{\kappa}\right)$$

$$s_i^{geom} = \lambda_1 \cdot OM_i + \lambda_2 \cdot FR_i$$

$GAD = \frac{1}{N} \sum_{i=1}^{N} s_i^{geom}$

Here $\rho_i$ is normalized occupied area, $\tau = 0.55$ is the target occupancy, $M^* \approx 4$ is the preferred region count, $T1 \ldots T19$0 tunes tolerance, and $T1 \ldots T19$1 are set by least squares to align GAD with human ratings. In practice, GAD guides template selection indirectly: the Arranger picks patterns that produce $T1 \ldots T19$2 and $T1 \ldots T19$3.

The template library operationalizes this geometric reasoning. The rule engine inspects the number of images, the number of formulas, and the size and aspect of visuals. If no visuals are present, it selects T1_TextOnly; for one wide image, T4_ImageTop; for one tall image, T2/T3; for two images, T5; for exactly four small images, T10; and for mixed formulas, T14–T18. Visual balance is then maintained by the combined action of occupancy and region-count objectives, with slides that fail these tests being merged, re-templated, or consolidated over the course of the six-agent process.

This design makes visual planning first-class rather than incidental. The system’s use of figure-based color extraction and layout templates means that slide appearance is partly derived from the paper’s own visual assets rather than only from generic presentation heuristics. That feature is central to the claim of design-aware multimodal slide generation.

4. Intermediate representation and PPTX generation

SlideGen uses a JSON deck as its intermediate representation. Each slide is represented with fields of the form {role, title, bullets[], images[], formulas[], pattern π, theme_color, notes} (Liang et al., 4 Dec 2025).

Template files are implemented as a set of PPTX slide masters in 16:9 aspect ratio, pre-designed in WPS/PowerPoint with fonts, placeholder shapes, and color palettes. Users can customize these masters via Slide Master view. The generation stage is handled by a Python driver, described as python-pptx or similar, which reads the JSON and, for each slide, selects the .pptx master for $T1 \ldots T19$4, fills text placeholders with bullets, inserts images and formula PNGs into specified bounding boxes, sets the deck theme color from the Refiner, and attaches speaker notes.

The end product is an editable .pptx file. That point is technically important because many generative presentation systems terminate in rasterized or HTML-like outputs that are less amenable to conventional academic editing workflows. By keeping layout choices, content slots, and theme attributes in structured intermediate form and then materializing them through slide masters, SlideGen aligns generation with standard office formats rather than replacing them.

A plausible implication is that this intermediate-representation design also supports incremental substitution of components. Because the slide deck is represented explicitly as structured objects rather than as opaque rendered pages, customized masters, alternative arranging logic, or domain-specific formula handling can be inserted without changing the entire pipeline.

5. Experimental setup and empirical performance

SlideGen is evaluated on a dataset of 200 peer-reviewed ML/NLP papers from 2022–2025, restricted to Oral presentations only. The baselines include end-to-end GPT-HTML and GPT-Image pipelines using GPT-4o and GPT-5, as well as two multi-agent systems, PPTAgent and PosterAgent. The evaluation metrics are GAD, SlideQA, VLM-as-Judge, and Text Perplexity under Llama-2-7B (Liang et al., 4 Dec 2025).

SlideQA uses 100 questions per paper, split into 50 verbatim and 50 interpretive questions, answered by 6 VLM readers and scored by accuracy. VLM-as-Judge uses GPT-4o to rate slides from 1–5 on Content, Design, and Coherence. Text Perplexity measures textual fluency and regularity. Together, these metrics cover geometric density, factual recoverability, judged presentation quality, and language quality.

Reported results place SlideGen at the top of the evaluated systems. With a GPT-4o backbone, it achieves the highest overall SlideQA, at approximately 84% interpretive and approximately 73% verbatim accuracy, the best GAD at approximately 0.81 versus 0.72–0.80 for baselines, and a VLM-as-Judge average of approximately 4.3/5 versus approximately 3.9. Its PPL is the lowest, at approximately 50 versus 200–800. In a human user study, 93% of participants chose SlideGen decks as their draft, and 80% rated the quality as “better than most humans.”

These results are notable because they couple content faithfulness with design-centric evaluation. The benchmark is not limited to ROUGE-style text overlap or slide-count heuristics; it includes questions answered from the produced slides and explicit geometric criteria. This suggests an evaluation regime more aligned with how scientific presentations are actually consumed: as visually structured arguments that must remain factually grounded.

6. Limitations, adjacent directions, and future work

SlideGen has several explicitly stated limitations. Its slide designs are limited to 19 predefined masters, so adapting to a new domain requires manual template curation. Its evaluation is confined to AI conference papers, and performance on very different genres such as humanities or business reports remains to be validated. The Refiner performs only one merge/color pass, and formula extraction can produce mismatches when choosing between LaTeX extraction and cropped formulas; an integrated renderer with exact font matching is identified as a way to improve consistency (Liang et al., 4 Dec 2025).

The paper’s future directions are correspondingly concrete: learning template priors from a corpus of real slide decks so that the Arranger can interpolate new layouts; adding a closed-loop agentic step that renders a draft slide, has a VLM “critic” score $T1 \ldots T19$5, and reruns Arranger/Refiner iteratively; extending the system to automatically produce animations or speaker-view slides such as highlights and progressive reveals; and performing domain adaptation by swapping in new slide-master libraries and re-tuning color heuristics.

These limitations intersect with broader issues in automated slide research. "SlideAudit: A Dataset and Taxonomy for Automated Evaluation of Presentation Slides" characterizes automated evaluation of specific graphic designs like presentation slides as an open problem and reports that AI models struggle to accurately identify slide design flaws, with F1 scores ranging from 0.331 to 0.655 (Zhang et al., 5 Aug 2025). This suggests that further progress in generation may depend not only on better planning and rendering, but also on more reliable design-aware evaluation. In a different but related direction, "DeepSlide: From Artifacts to Presentation Delivery" argues that most AI slide generators optimize the artifact while under-optimizing the delivery process, introducing a system centered on requirement elicitation, time-budgeted narrative planning, attention augmentation, and rehearsal support (Yang et al., 1 Apr 2026). A plausible implication is that SlideGen and DeepSlide occupy complementary positions: the former emphasizes design-aware multimodal deck construction, while the latter emphasizes the full presentation process from planning to delivery.

Within the emerging literature on scientific slide generation, SlideGen is therefore best understood as a framework that formalizes collaborative multimodal planning over a structured deck representation. Its distinctive contribution is the integration of coordinated outlining, mapping, formula handling, arrangement, refinement, and note synthesis into a pipeline that produces editable PPTX output while explicitly optimizing geometric density, visual balance, and faithfulness to the source paper.