SlideForge: Controllable Editing of Slides as Structured Artifacts¶
Conference: EMNLP 2026
Paper: ACL Anthology
Code: https://github.com/UIUC-MONET/SLIDEFORGE
Area: LLM Reasoning
Keywords: Structured Slide Editing, Deck State Graph, Perception-Aligned Decomposition, Theme-Preserving Reconstruction, Rendered-State Verification
TL;DR¶
Addressing the critical failure modes of existing presentation agents that treat slides as flat pixels and corrupt editable structures, SLIDEFORGE conceptualizes slide editing as structured-artifact manipulation. By linking native PPTX XML objects and visual decomposition into an executable Deck State Graph (DSG), it conducts grounded planning, modality-aware element reconstruction, and closed-loop visual self-repair, maintaining layout fidelity and native editability while achieving superior stylistic transformation.
Background & Motivation¶
Presentation slides constitute a foundational medium for communicating technical knowledge, research findings, business insights, and pedagogical narratives. With the rapid evolution of frontier multimodal large language models (VLMs/LLMs), autonomous agents have exhibited remarkable capabilities in visual captioning, document understanding, and holistic media synthesis. However, when deployed for fine-grained, controllable editing of existing presentation decks, current agents frequently experience catastrophic breakdowns. Slides are inherently not mere sequences of static rendered pixel frames; they are complex, layered digital artifacts engineered with native vector shapes, hierarchical bullet lists, data-linked charts, editable tables, nested groups, z-ordering hierarchies, and slide-master inheritance schemes.
This profound disparity between how multimodal agents perceive slides and how humans author them has induced severe architectural drawbacks in existing approaches. Mainstream agents predominantly approach slide modification via end-to-end prompt-driven generation, screenshot-level visual inpainting, or ungrounded script generation. Screenshot-based diffusion and vision models inevitably rasterize rich vector objects, irrevocably stripping away native editability and freezing text and charts into unalterable bitmap graphics. Conversely, naive script-generation agents operate blind to visual layout dynamics, frequently breaking alignment, overlapping bounding boxes, distorting non-target content, and causing typography overflows. Crucially, raw PPTX XML parsing fails to encapsulate high-level visual perceptual units (such as imported diagrams or screenshot callouts), while pure vision detectors lack programmatic handles to underlying vector document primitives.
Resolving this tension requires recognizing that slide editing is fundamentally a problem of structured-artifact manipulation rather than unconstrained pixel generation. An effective system must bridge the chasm between rendered visual perception and native document representations, isolating editing targets while anchoring protected content under explicit boundary constraints. Core idea: Formulate controllable slide editing as state recovery and constrained manipulation of structured artifacts by constructing an executable Deck State Graph (DSG) that couples visual decomposition with native PPTX primitives, powering a slide-native agent pipeline with theme-preserving reconstruction and closed-loop rendered-state self-repair.
Method¶
Overall Architecture¶
SLIDEFORGE establishes an end-to-end agentic architecture comprising four tightly interconnected stages: Perception-Aligned Deck State Graph Construction, Slide-Native Editing Harness, Theme-Preserving Reconstruction, and Rendered-State Verification with Self-Repair. Given an existing PPTX presentation and a natural-language editing prompt (optionally accompanied by an aesthetic target theme), the framework transforms the deck while strictly preserving non-target regions, layout geometry, typographic hierarchy, and native editability.
%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400, 'subGraphTitleMargin': {'top': 8, 'bottom': 16}}}}%%
flowchart TD
IN["Input Slide (PPTX) + Instruction / Target Theme"] --> S1["Stage 1: Deck State Graph Construction<br/>XML parsing + visual SAM segmentation + dual-path grounding"]
S1 --> S2["Stage 2: Slide-Native Editing Harness<br/>Scope grounding S_edit / S_keep + constrained API execution"]
S2 --> S3["Stage 3: Theme-Preserving Reconstruction<br/>Aesthetic contract + 6-class modality typing + palette mapping"]
S3 --> S4["Stage 4: Verification & Self-Repair<br/>Single-element & full-deck headless rendering + local graph repair"]
S4 --> OUT["Output Native Editable Slide (PPTX)"]
Key Designs¶
1. Deck State Graph Construction: Unifying native document structure and visual perception into an executable state
Operating strictly on XML symbols misses rasterized diagrams, whereas operating exclusively on pixel screenshots destroys document editability. SLIDEFORGE resolves this dichotomy by parsing the underlying PPTX XML to extract all native editable objects—text boxes, geometry shapes, tables, charts, pictures, groups, z-orders, and master bindings. In parallel, it renders the slide and applies an open-vocabulary visual segmentation model (a lightweight decoder-adapted SAM on 306 slide component classes). To ensure comprehensive coverage across heterogeneous slide components, it deploys two complementary grounding mechanisms: a text-mediated path where a VLM describes visual regions and an LLM maps them into the taxonomy \(\Lambda\), and a visual path where a VLM directly tags active labels from rendered imagery. Their union forms a slide-conditioned vocabulary \(\Lambda_p\). Detections are refined through image-whitening re-checks to harvest missed regions, and a perceptual merge module consolidates fragmented boxes and connector lines into unified editing units. The resulting Deck State Graph \(G = (V, E)\) stores slide nodes, native object nodes, and perceptual component nodes \(\Omega = (E_{\text{fine}}, M, R)\), with edges encoding topological containment, reading order, z-ordering, and bidirectional execution bindings.
2. Slide-Native Editing Harness: Enforcing controllability via scope grounding and constrained execution
Direct LLM code generation often suffers from unintended side effects where non-target text or formatting is inadvertently altered. Given a natural-language prompt \(u\), the harness grounds the user instruction directly onto nodes and relations within \(G\), explicitly partitioning the slide into an editable target scope \(S_{\text{edit}}\) and an immutable preservation scope \(S_{\text{keep}}\). An LLM planner translates the grounded intent into atomic, slide-native python-pptx operations (such as text run modification, shape resizing, or table cell content updates). Because elements within \(S_{\text{keep}}\) remain programmatically locked at their original spatial anchors, background layouts and unreferenced foreground objects are preserved verbatim. For non-editable raster graphics that fall within \(S_{\text{edit}}\), the graph supplies their exact bounding boxes, semantic roles, and local layout context, permitting isolated, in-place visual replacement without disrupting surrounding slide typography.
3. Theme-Preserving Reconstruction: Preserving functionality and editability through structured aesthetic contracts and modality typing
Global style migration frequently degrades layout readability or flattens slides into uneditable posters. Under a target theme \(T\), SLIDEFORGE first establishes a deck-level aesthetic contract \(C\), generating role-specific styled backgrounds (opening, content, and closing slides) and extracting a harmonized palette of dominant theme colors, secondary tones, and WCAG contrast-compliant font palettes. Each foreground element is then assigned one of six reconstruction modalities \(\tau_i \in \{0, 1, 2, 3, 4, 5\}\): discardable ornaments (\(\tau=0\)), plain editable text boxes (\(\tau=1\)), shaped text panels (\(\tau=2\)), native editable tables (\(\tau=3\)), vectorized shape compositions approximated by primitive shapes (\(\tau=4\)), and styled raster assets (\(\tau=5\)). A palette-constrained color mapping function \(f_C\) maps identical source hex values to identical target hex values, preserving semantic contrast between table headers and body rows. The restyled slide is assembled by layering the styled background and anchoring reconstructed foreground primitives to their exact DSG coordinates.
4. Verification and Self-Repair: Closing the execution loop via headless rendered-state feedback
Feedforward document synthesis lacks awareness of post-assembly visual defects such as text overflow, font clipping, and layer occlusions. SLIDEFORGE introduces a dual-level closed-loop verification pipeline that couples native PPTX modifications with visual rendering inspection. In component verification, each reconstructed editable primitive (\(\tau_i \in \{1, 2, 3, 4\}\)) is rendered headlessly in isolation and compared against its ground-truth crop \(b_i\); if text overflows or geometries drift, the verifier triggers localized self-repair by decreasing font sizes or slightly expanding the box width without restarting the slide. In slide verification, the fully assembled slide is rendered and scrutinized by an LLM critic against theme \(T\), contract \(C\), and preservation constraints \(S_{\text{keep}}\). When visual overlap or occlusion occurs, the error is mapped back to the corresponding graph edge in \(G\), triggering a targeted z-order swap or alignment adjustment.
Benchmark & Evaluation Protocol¶
To rigorously assess controllable slide transformation beyond subjective visual plausibility, this work establishes a comprehensive two-pronged evaluation protocol: 1. State Recovery (Decomposition): Evaluated on an out-of-domain test set of 89 system conference decks characterized by dense equations, complex architecture diagrams, and custom tables. Reconstructability is measured through image metrics (SSIM, LPIPS, CLIP similarity) between original slides and reassembled components. Coverage and non-redundancy are evaluated using the unified \(\text{SCAN} = 0.5 R_c + 0.5 R_o\) metric alongside independent VLM judgments for Cohesion, Label Fit, Granularity, and Non-Redundancy on a 1–5 scale. 2. State Transformation (Restyling & Editing): Evaluated across three contrasting target aesthetics (Industrial, Warm, and Finance). Outputs are rendered via headless LibreOffice and evaluated by multimodal judges and human experts across six 1–10 dimensional rubrics (Deck-level Coherence, Slide-level Coherence, Information Fidelity, Text Readability, Content-Decoration Balance, and Fitness for Purpose). Furthermore, native PPTX editability is quantified by measuring the total number of editable leaf shapes (Editable Count, EC) and their proportional area coverage (Editable Area Ratio, EAR).
Key Experimental Results¶
Main Results¶
In the state recovery (decomposition) evaluation on out-of-domain system conference presentations, SLIDEFORGE significantly outperforms existing slide recovery and code-agent baselines across all pixel-level, perceptual, and semantic criteria.
| Method | SSIM ↑ | LPIPS ↓ | CLIP ↑ | SCAN ↑ | Cohesion ↑ | Label Fit ↑ | Granularity ↑ | Non-Red. ↑ |
|---|---|---|---|---|---|---|---|---|
| SlideCoder (Tang et al., 2025) | 0.743 | 0.482 | 0.726 | 0.780 | 4.54 | 2.68 | 3.18 | 3.73 |
| Claude Code (Opus 4.7) | 0.813 | 0.341 | 0.837 | 0.858 | 4.54 | 2.82 | 3.90 | 3.89 |
| SLIDEFORGE (Ours) | 0.950 | 0.054 | 0.984 | 0.960 | 4.70 | 4.50 | 4.68 | 4.87 |
In the state transformation (restyling) evaluation across three distinct aesthetic styles, SLIDEFORGE attains the highest overall performance on all targets, achieving marked superiority in preserving information fidelity and text legibility.
| Evaluation Dimension | Industrial (AP) | Industrial (GI+C) | Industrial (Ours) | Warm (AP) | Warm (GI+C) | Warm (Ours) | Finance (AP) | Finance (GI+C) | Finance (Ours) | |---|---|---|---|---|---|---|---|---| | Deck-level coherence | 7.50 | 7.03 | 7.39 | 7.52 | 6.83 | 7.14 | 6.17 | 6.03 | 6.10 | | Slide-level coherence | 5.20 | 5.37 | 6.00 | 5.03 | 5.07 | 5.90 | 4.17 | 4.52 | 5.14 | | Information fidelity | 6.03 | 4.37 | 6.96 | 5.38 | 4.00 | 6.55 | 5.38 | 4.45 | 6.59 | | Text readability | 6.57 | 4.07 | 6.79 | 5.14 | 3.69 | 6.38 | 5.83 | 3.93 | 6.66 | | Content-decoration balance | 5.17 | 5.53 | 6.50 | 4.21 | 5.00 | 5.97 | 4.00 | 4.90 | 5.66 | | Fitness for purpose | 4.83 | 3.67 | 5.71 | 3.62 | 2.86 | 4.90 | 4.24 | 3.48 | 5.34 | | Overall | 5.88 | 5.01 | 6.56 | 5.15 | 4.57 | 6.14 | 4.97 | 4.55 | 5.91 |
(Note: AP denotes AutoPresent whole-slide generation baseline; GI+C denotes GPT-Image-2 generation followed by Claude Opus 4.7 decomposition)
Ablation Study & Controllability Analysis¶
To determine whether the transformed slides retain genuine, functional editability rather than collapsed visual representations, the authors quantified editable PPTX object counts and area ratios:
| Configuration / Method | Editable Count (EC) | Editable Area Ratio (EAR) | Normalized Count Ratio (EC/input) | Note |
|---|---|---|---|---|
| Input Ground Truth | 71.2 | 62.36% | 1.000 | Human-authored academic presentations |
| AutoPresent | 11.9 | 50.17% | 0.266 | Flattens fine-grained objects into static imagery |
| GPT-Image-2 + Claude | 32.4 | 31.63% | 0.696 | Recovers partial text but drops structured shapes |
| SLIDEFORGE (Full Framework) | 72.8 | 49.74% | 1.349 | Fully preserves and refines native editable shapes |
In localized element-wise editing evaluations across 30 sampled decks: - Text modification / recoloring (431 elements): Average rating of 3.90/5, with 91.6% achieving \(\ge 3\) and 75.2% achieving \(\ge 4\). - Text-panel restyling (24 elements): Average rating of 4.54/5, with 100% achieving \(\ge 3\) and 95.8% achieving \(\ge 4\). - Image replacement (8 elements): Average rating of 4.12/5, with 100% achieving \(\ge 3\) and 75.0% achieving \(\ge 4\). - Chart / table reconstruction (11 elements): Average rating of 3.64/5, with 72.7% achieving \(\ge 3\). - Icon / diagram reconstruction (132 elements): Average rating of 3.27/5, with 71.2% achieving \(\ge 3\).
Furthermore, in a single-stimulus Turing-test human study, human-original slides exhibited an AI false-alarm detection rate of 23.6%, whereas SLIDEFORGE reconstructions were classified as machine-generated in only 10.7% of cases (\(d' = -0.52, p = 0.1751\), showing no significant detectability above human originals). In sharp contrast, the Claude Code (Opus 4.7) baseline was readily identified as AI-generated in 77.4% of cases (\(d' = 1.47, p < 0.0001\)).
Key Findings¶
- Structured decoupling prevents catastrophic content drift: While holistic generation baselines like AutoPresent achieve marginally higher deck-level theme uniformity, they severely compromise technical fidelity, hallucinating scientific diagrams and garbling chart axes. SLIDEFORGE guarantees zero unintended content drift by enforcing hard locks on the preservation scope \(S_{\text{keep}}\).
- Native editability is completely retained: By assigning modality types \(\tau_i \in \{0 \dots 5\}\), SLIDEFORGE achieves an editable shape count ratio of 1.349 relative to original inputs, outperforming rasterized generation baselines by over \(5\times\).
- Rendered verification ensures high-efficiency convergence: Across 6-slide test decks, the end-to-end framework requires an average of only 3.0 localized self-corrections during restyling, achieving a 100% convergence rate with an average runtime of 1080 s and a cost of $4.59 per deck.
Highlights & Insights¶
- Executable graph bridging visual and document hierarchies: Constructing the Deck State Graph unifies visual segmentation masks with underlying python-pptx object pointers, solving the long-standing semantic gap between what an agent sees and what it can manipulate.
- Pragmatic modality-aware reconstruction: Rather than pursuing an impractical "all-vector" or "all-raster" extreme, the system strategically routes text to textboxes, tables to native table grids, diagrams to primitive shape graphs, and complex photos to bounded raster assets.
- Localized visual feedback without global retraining: The closed-loop verification pipeline translates visual flaws (e.g., text overflow, occlusion) directly into graph-level parameter updates or z-order swaps, demonstrating an efficient paradigm for autonomous multimodal software operation.
Limitations & Future Work¶
- Inference latency and API expense: The extensive use of multi-stage VLM calls for proposal mapping, whitening coverage review, and iterative self-repair results in high inference latency (~18 minutes for a 6-slide deck), limiting real-time interactive usage.
- Extreme geometric complexity and alpha channel deficiencies: Highly intricate vector topologies (e.g., dense circuit diagrams) challenge the primitive shape synthesizer (\(\tau=4\)), while downstream image generation models lacking alpha-transparency support can introduce opaque background artifacts around restyled raster assets (\(\tau=5\)).
- Constrained task scope: The current framework is tailored toward style adaptation and localized element modification; expanding to multi-slide narrative restructuring, automated slide summarization from scientific manuscripts, and animation dynamics remains open.
Related Work & Insights¶
- vs AutoPresent (Ge et al., 2025): AutoPresent generates slides from scratch via text prompts and tool-augmented coding, but cannot reliably edit pre-existing decks without hallucinating or overriding non-target structures; SLIDEFORGE focuses on controllable transformation, explicitly preserving non-target contents.
- vs Talk to Your Slides (Jung et al., 2026): Talk to Your Slides demonstrated the power of manipulating structured PPTX objects over raw screenshots, but relied heavily on direct XML heuristics; SLIDEFORGE enriches this paradigm with deep visual perception (SAM segmentation), perceptual grouping, and rendered-state visual verification.
- vs SlideCoder (Tang et al., 2025) & Claude Code: Generic coding agents attempting to regenerate presentations in a single forward pass lack visual verification, frequently generating overlapping shapes or unreadable font sizes; SLIDEFORGE's closed-loop render-and-repair mechanism establishes a dependable blueprint for executable artifact agents.
Rating¶
- Novelty: ⭐⭐⭐⭐⭐ [Pioneers the modeling of presentation slides as executable Deck State Graphs, linking visual segmentation and native document objects]
- Experimental Thoroughness: ⭐⭐⭐⭐⭐ [Establishes rigorous benchmarks covering decomposition, restyling, element controllability, human evaluations, and Turing-test studies]
- Writing Quality: ⭐⭐⭐⭐⭐ [Exceptionally structured and thorough, providing complete prompt listings, formal formulations, and insightful qualitative analyses]
- Value: ⭐⭐⭐⭐⭐ [Offers a robust, industry-relevant blueprint for AI-assisted document and presentation authoring that strictly respects human editability]