TL;DR
This paper formulates Page-level Slide Personalization (PSP) as an inverse planning problem, where a user's latent design intent is inferred from a few reference slides. To solve this without relying on non-differentiable rendering tools during training, the authors introduce SPIRE, a structural denoising framework that trains a Critic and a Planner agent via reinforcement learning to collaboratively generate and refine personalized slide layouts.
What Problem Does This Paper Address?
When creating slide decks, human designers naturally adapt layouts, color palettes, and typography to match a specific brand identity or personal style. While modern AI agents can generate content, they struggle with fine-grained, page-level personalization. Existing methods typically rely on rigid, pre-defined templates or require users to provide exhaustively verbose formatting instructions.
The authors define this challenge as Page-level Slide Personalization (PSP). Solving PSP automatically is incredibly difficult for two reasons:
- Black-Box Executors: Slide rendering tools (like PowerPoint or Beamer) are non-differentiable black boxes. You cannot backpropagate pixel-level losses through them to train a layout model.
- Pixel vs. Structure: Standard image-generation losses (like pixel-wise L2 distance) fail because slide quality is governed by discrete structural decisions (alignment, hierarchy, spacing) rather than raw pixel values.
Methods
To bypass the black-box rendering bottleneck, the paper proposes SPIRE (Structural Planning via Inverse REconstruction). Instead of treating slide personalization as an end-to-end image generation task, SPIRE frames it as an inverse planning problem solved via structural denoising.
The Structural Denoising Loop
Instead of adding pixel-level noise (like diffusion models do), SPIRE intentionally corrupts a "gold" (perfect) slide by applying random, element-level structural perturbations. These include shifting coordinates (layout), distorting element sizes (hierarchy), and altering text colors (styling). Because these corruptions are programmatically generated, the exact "errors" are known, creating a perfectly verifiable self-supervised training signal.
SPIRE splits the task between two cooperative agents:
- The Critic ($C_\phi$): Learns to inspect a corrupted slide alongside the user's reference slides and generate structured, actionable textual feedback pinpointing the discrepancies.
- The Planner ($\pi_\theta$): Learns to take the high-level content instruction and either generate a design plan from scratch or iteratively revise a suboptimal plan guided by the Critic's feedback.
Both agents are fine-tuned using Reinforcement Learning (specifically Direct Alignment from Preference Optimization, or DAPO). The Critic is rewarded for accurately identifying the engineered corruptions, while the Planner is rewarded based on a VLM judge's preference for its plan over the corrupted alternative.
Datasets
The authors evaluated SPIRE using the following datasets:
- Zenodo10k: A large corpus of real-world slide decks. The authors randomly sampled 200 decks and performed a chronological slide-level split (80% training, 20% testing).
- SlideBench: Used as an out-of-distribution (OOD) test set to evaluate how well the framework generalizes to completely unseen design styles and topics.
To create the training triplets (Instruction, Gold Slide, Reference Slide), they used a frontier VLM to extract factual, style-free summaries of the gold slides to serve as the user instructions.
Key Insights and Ideas
- Slides are Discrete Structures: Treating slides as images hurts model performance. By focusing optimization on the discrete structural space (bounding boxes, font sizes, color hexes), the model learns layout logic rather than pixel arrangements.
- Two-Agent Decomposition Stabilizes RL: The authors mathematically prove (Theorem 2) that training the Critic and Planner separately eliminates the randomness and noise induced by the black-box executor. This strictly reduces policy gradient variance, making reinforcement learning stable and tractable.
- Critiques as Semantic Gradients: The Critic's text-based feedback acts as a readable, discrete proxy for a mathematical gradient, allowing the Planner to perform multi-turn iterative refinement.
Key Results
SPIRE was evaluated against strong baselines, including slide-native pipelines (AutoPresent, PPTAgent) and generic visual synthesis models (Stable Diffusion 3.5 + IP-Adapter). Both the Critic and Planner in SPIRE were built on top of open-source Qwen2.5-VL-7B models.
- Beating the Giants: Despite using 7B-scale models, SPIRE outperformed frontier GPT-based baselines. On the VLM-as-a-Judge metric (measuring Faithfulness, Color, Layout, and Aesthetics), SPIRE achieved an average score of 0.5415 on test pages and 0.7333 on OOD pages, significantly higher than AutoPresent (0.5069 / 0.6461).
- Iterative Improvement: Ablation studies confirmed that slide quality steadily climbs over successive refinement rounds (up to 3 rounds), proving that the Planner successfully interprets and executes the Critic's feedback.
- Strong Generalizability: On OOD pages, SPIRE achieved the highest win/tie rate (exceeding 90% against most baselines), showing it doesn't just memorize training templates but truly leverages reference slides as contextual evidence.
Limitations and Future Work
While SPIRE marks a significant step forward, the authors note a few limitations:
- Data Synthesis Dependency: The framework relies on an oracle VLM (like GPT-5 class models) during the offline data curation phase to synthesize the initial suboptimal plans and gold critiques used to bootstrap training.
- Single Reference Constraint: In the current experimental setup, the reference set size was limited to $K=1$ to maximize the personalization challenge. Exploring how the model aggregates design intent from larger, diverse reference sets remains future work.
Summary updated