Personalization as Inverse Planning: Learning Latent Design Intents for Agentic Slide Generation via Structural Denoising

Tianci Liu, Zihan Dong, Linjun Zhang, Haoyu Wang, Jing Gao, Emre Kiciman, Ranveer Chandra, Wei-Ting ChenarXiv 2026 · arXiv

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:

  1. 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.
  2. 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.
SPIRE shifts the paradigm from rigid templates or long instructions to inferring latent design intents from reference slides.

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.

The SPIRE framework separates training into a self-supervised structural perturbation loop, eliminating executor-induced noise.

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

Abstract

Slide design requires personalizing both deck themes and page layouts. Yet, current AI agent-based methods struggle with fine-grained, page-level design. Solely relying on prespecified templates or user verbose instructions, they fail to capture latent design intents, leaving Page-level Slide Personalization (PSP) unresolved. To close this gap, this work formulates PSP as an inverse planning problem. We propose to learn a design intent without assuming any knowledge of the specific executing tools (e.g., PowerPoint, Beamer) being used. However, relinquishing control over these tools makes the problem intractable to optimize end-to-end. To overcome this, we propose SPIRE, a principled framework to solve PSP approximately. By intentionally corrupting the visual structures of clean slides, SPIRE creates a verifiable task to denoise the corruption, whereby two agents learn to collaboratively refine executable designs via reinforcement learning (RL). We present a proof that structural denoising is a consistent surrogate for PSP, and that the multi-agent formulation strictly reduces policy gradient variance in RL. Extensive experiments demonstrate the superiority of SPIRE.
BibTeX
@misc{liu2026personalization,
  author = {Tianci Liu and Zihan Dong and Linjun Zhang and Haoyu Wang and Jing Gao and Emre Kiciman and Ranveer Chandra and Wei-Ting Chen},
  title = {{Personalization as Inverse Planning: Learning Latent Design Intents for Agentic Slide Generation via Structural Denoising}},
  year = {2026},
  eprint = {2607.00407},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2607.00407},
}
Figure