EditPPT: Structured Execution and Evaluation for Reliable Slide Editing

arXiv:2608.20381 · cs.CL, cs.AI, cs.HC · Submitted 2026-06-29 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "EditPPT: Structured Execution and Evaluation for Reliable Slide Editing".

Jane: Here's the gist of the paper. The gist The EDITPPT framework reframes slide editing as a constrained tool-selection problem executed via shape-level operations through the native PowerPoint COM interface, which addresses cascading errors in long decks by narrowing the LLM action space and preserving application-resolved structure.

Tom: How it works EDITPPT processes an editing request through a five-stage pipeline (Figure 2) where it "(i) parses the relevant slides into structured representations of native PowerPoint objects, augmented with selective visual metadata, (ii) decomposes the instruction into a per-slide task list, (iii) dispatches each task to a specialist agent, (iv) executes deterministic shape-level operations through the PowerPoint COM interface, and (v) validates the result using complementary structural and visual validators before either accepting the edit or triggering recovery" The core mechanism involves using the running PowerPoint application as a shared interface for both parsing and editing, following evidence that "object-model-based slide manipulation can be more efficient and style-preserving than pixel-level".

Jane: The system employs a COM-based parser that produces a JSON object enumerating native PowerPoint objects and their properties, including "object type, geometry, text and font attributes, table and chart contents, image metadata, and slide-level elements".

Tom: This representation reduces input size significantly compared to raw XML by removing "package-level XML redundancy while preserving editable object state".

Paper summary: Tom: So, EDITPPT proposes a multi-agent framework that uses the native PowerPoint COM interface to do the actual editing. They claim this approach narrows the LLM action space while keeping application-resolved structure intact.

Jane: But how does it manage that complexity? If we're talking about long decks, where errors tend to cascade, what's stopping it from just making a mess?

Tom: The core mechanism involves parsing the request into structured representations of native PowerPoint objects and then using a planner to break that down into per-slide subtasks. Each task goes to a specialist agent who only uses a small subset of predefined tools.

Lu: They use this structure-first representation, which they call Augmented Slide Representation, where they produce a JSON object listing every shape ID and its properties before the agents even start working on anything.

Meng: I wonder about that parsing step. If we have to convert everything into a JSON object of native PowerPoint properties, isn't that going to be slow or create too much overhead for a fast editing loop?

Tom: They address that by using a COM-based parser that produces this JSON, which they say removes "package-level XML redundancy while preserving editable object state." It’s designed to be smaller than raw XML because it keeps the actual state of the objects.

Jane: And then they have this multi-agent dispatcher routing tasks based on object type, and each agent is tied to specific tools like text editing or chart editing. That sounds like a very specialized team of workers.

Lalam: I see how that specialization helps control the output. The agents are constrained to tools that are deterministic at the shape level, which should keep things predictable when they execute the changes via COM.

Tom: And they don't stop there with just execution; they have a dual-modal validation system after every edit. They separate instruction verification from visual quality assessment for more robust checking.

Jane: That sounds smart because you could have one agent follow the text instructions perfectly, and another module check if the visual layout still looks right, like making sure things aren't overlapping.

Lu: That separation is what they emphasize because replacing that dual-modal validator with just one Vision Language Model judge caused instruction following to collapse by over thirty-seven points and object preservation by nearly thirty-two points <ref:2608.20381#pg3>.

Conclusion: Tom: So, looking at the paper "EditPPT: Structured Execution and Evaluation for Reliable Slide Editing", the authors are showing that constraining *how* edits are executed, not just making the AI model bigger, actually makes slide editing more reliable.

Jane: What does that mean in simple terms for someone who isn't deep in AI engineering? What's the big picture implication here?

Tom: It means we can move away from relying on open-ended code generation for presentation editing and toward a system where the process is highly structured, using specific tools for specific parts of the deck.

Lu: The implication is that if you define the problem as constrained modification—targets, operations, preservation—you get better results than just letting an LLM wander around trying to write the whole deck from scratch.

Meng: For production use, this suggests that instead of a massive general-purpose model doing everything, we could deploy these specialized agents with their fixed toolsets for high-fidelity editing tasks.

Jane: So it’s about reliability through structure and constraint rather than just raw model size? That makes sense when you think about the cascading errors they were fighting against.

Tom: Exactly. The paper introduces EDITPPT and DECKEDITBENCH, showing that by using a COM-based parser and constrained tool execution, they mitigate length-induced error cascades in practical slide editing.

Jiheon Kim, Kyudan Jung, Jaegul Choo

KAIST AI

cs.CL, cs.AI, cs.HC

Submitted: 2026-06-29

Updated: 2026-10-18

Code: https://github.com/anthropics/skills

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 88/100

The gist: The gist The EDITPPT framework reframes slide editing as a constrained tool-selection problem executed via shape-level operations through the native PowerPoint COM interface, which addresses

Key concepts

Shape-Level Operations: Instead of editing pixels, the system focuses on modifying specific PowerPoint objects like text boxes or charts using their unique IDs. This method ensures that changes are targeted precisely at the intended element without accidentally altering surrounding content or layout, which is crucial for reliable editing.
PowerPoint COM Interface: This is a built-in programming interface that allows external software, like the EDITPPT framework, to directly control and manipulate Microsoft PowerPoint applications. It acts as a shared bridge for parsing the presentation structure and executing deterministic edits directly within the application's object model.
Dual-Modal Validation: The system checks edits using two different methods: one structural validator verifies that the requested changes were made correctly according to the parsed data, while a Visual Language Model (VLM) validator checks for visual quality issues like overlaps or clipping. Separating these checks makes the evaluation much more robust.
Constrained Action Space: The framework limits each specialist agent to only a small subset of predefined, deterministic tools (e.g., 37 tools). This constraint prevents the LLM from generating arbitrary code or making broad, risky changes, forcing it to operate within a predictable and safe set of allowed actions.

Summary

The gist The EDITPPT framework reframes slide editing as a constrained tool-selection problem executed via shape-level operations through the native PowerPoint COM interface, which addresses cascading errors in long decks by narrowing the LLM action space and preserving application-resolved structure.

How it works

EDITPPT processes an editing request through a five-stage pipeline (Figure 2) where it "(i) parses the relevant slides into structured representations of native PowerPoint objects, augmented with selective visual metadata, (ii) decomposes the instruction into a per-slide task list, (iii) dispatches each task to a specialist agent, (iv) executes deterministic shape-level operations through the PowerPoint COM interface, and (v) validates the result using complementary structural and visual validators before either accepting the edit or triggering recovery"

The core mechanism involves using the running PowerPoint application as a shared interface for both parsing and editing, following evidence that object-model-based slide manipulation can be more efficient and style-preserving than pixel-level. The system employs a COM-based parser that produces a JSON object enumerating native PowerPoint objects and their properties, including object type, geometry, text and font attributes, table and chart contents, image metadata, and slide-level elements. This representation reduces input size significantly compared to raw XML by removing package-level XML redundancy while preserving editable object state.

Planning and Targeted Parsing

The planner operates in two stages: first, it interprets the high-level scope of the instruction, such as whether the edit applies to a specific slide, a subset of slides, or the entire presentation. Second, after relevant slides are parsed, it refines the request into shape-level subtasks that specify the target slide, target object, and intended action. For each target slide, EDITPPT uses a structure-first slide representation augmented with selective visual information. The parser produces a JSON object enumerating native PowerPoint objects and their properties, including Shape Id, which serves as the addressing handle for downstream tool calls. This allows agents to ground tasks in PowerPoint-resolved object state.

Specialist Agents and Tool Execution

The dispatcher routes each slide element to the appropriate sub-agent based on its object type and intended edit. The specialist agent then invokes the corresponding COM tool, with the BaseEditAgent executing each edit as a bounded retry-and-rollback loop. This execution is constrained by deterministic shape-level tools through the COM interface. The tool set includes various capabilities, such as Text Editing (7 tools), Table Editing (3 tools), Chart Editing (5 tools), and Shape/Layout operations (13 tools).

Dual-modal Validation

After execution, EDITPPT validates the result through dual-modal validation, separating instruction-level verification from visual-quality assessment for more robust evaluation. This involves two complementary modules: a structural validator that checks instruction fulfillment and unintended object-level changes from parsed slide states, and a VLM-based validator that detect[s] visual design issues such as overlap, clipping, or unintended layout shifts. This separation is crucial because replacing the dualmodal validator with a single VLM judge causes Instruction Following collapsing by over 37 points and Object Preservation by nearly 32 points.

Evaluation and Robustness

The system is evaluated on DECKEDIT-BENCH, a benchmark featuring "28 human-authored decks, 582 slides, and 183 natural-language editing prompts across short (≤10 slides), medium (11 to 30 slides), and long (>30 slides). Experiments show that EDITPPT achieves 99.5% execution rate, 88.7% slide-targeting F1, 82.5% instruction following, and 91.5% object preservation overall". Critically, on long decks (>30 slides), it maintains 90.5% slide F1, 86.6% instruction following, and 91.7% preservation, whereas other systems like PPTPilot show clear instruction-following degradation from short to long decks.

The paper concludes that by using a COM-based parser and constrained tool execution, EDITPPT mitigates length-induced error cascades in practical slide editing. The main contributions include proposing EDITPPT, releasing DECKEDIT-BENCH, and empirically demonstrating that it significantly outperforms existing codegeneration and structure-editing baselines.

Limitations

A limitation is that EDITPPT currently relies on the PowerPoint COM interface, which is tied to the desktop PowerPoint runtime and is effectively single-threaded for many operations. Furthermore, highly abstract instructions that require extensive design reasoning, content rewriting, or global narrative restructuring may still require stronger planning modules or human review.

Ethical Considerations

The work emphasizes that deployments should preserve source files, expose edit logs, and avoid overwriting user content without confirmation. The benchmark ensures ethical use by confirming that All decks in DECKEDITBENCH were contributed by the authors or by colleagues who were fully informed of the research purpose and gave consent for their decks to be used in a publicly released benchmark.

Use of AI Assistants

The implementation utilized AI coding assistants for parts of the implementation and AI writing assistants for language polishing of this manuscript. All technical claims, experimental results, and conclusions were independently verified by the authors.

References

Anthropic. 2026a. Claude Opus 4.7. https://www.anthropic.com/claude/opus/. Accessed: 2026-05-25.

Anthropic. 2026b. Claude Sonnet 4.6. https://www.anthropic.com/claude/sonnet/. Accessed: 2026-05-25.

Anthropic. 2026c. PPTX Skill. https://github.com/anthropics/skills/blob/main/skills/pptx/SKILL.md.

Jiaxin Ge, Zora Zhiruo Wang, Xuhui Zhou, Yi-Hao Peng, Sanjay Subramanian, Qinyue Tan, Maarten Sap, Alane Suhr, Daniel Fried, Graham Neubig, and Trevor Darrell. 2025. AutoPresent: Designing structured visuals from scratch. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR).

Google. 2026. Gemini API Models. https://ai.google.dev/gemini-api/docs/models/. Accessed: 2026-05-25.

Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Nan Duan, and Weizhu Chen. 2024. CRITIC: Large language models can self-correct with tool-interactive critiquing. In International Conference on Learning Representations (ICLR).

Daesik Jang, Morgan Lindsay Heisler, Linzi Xing, Yifei Li, Edward Wang, Ying Xiong, Yong Zhang, and Zhenan Fan. 2026. Deckbench: Benchmarking multiagent frameworks for academic slide generation and editing. Preprint, arXiv:2602.13318.

Kyudan Jung, Hojun Cho, Jooyeol Yun, Soyoung Yang, Jaehyeok Jang, and Jaegul Choo. 2026. Talk to your slides: High-efficiency slide editing via languagedriven structured data manipulation. Preprint, arXiv:2505.11604.

Hyeonsu Kang, Emily Bao, and Anjan Goswami. 2025. Vlm-slideeval: Evaluating vlms on structured comprehension and perturbation sensitivity in ppt. Preprint, arXiv:2510.22045.

Yang Liu, Dan Iter, Yichong Xu, Shuohang Wang, Ruochen Xu, and Chenguang Zhu. 2023. G-Eval: NLG evaluation using GPT-4 with better human alignment. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing.

Yadong Lu, Jianwei Yang, Yelong Shen, and Ahmed Awadallah. 2024. OmniParser for pure vision based gui agent. Preprint, arXiv:2408.00203.

Improvements for AI systems

Automated editing of native PowerPoint decks can be achieved by reformulating slide editing as a constrained tool-selection problem, executing shape-level operations through the native PowerPoint COM interface to narrow LLM action space. This allows agents to execute localized shape-level operations through the native PowerPoint COM interface while preserving the application-resolved structure of user-authored decks.
Implementation of DECKEDITBENCH as a benchmark allows for rigorous evaluation across length tiers, demonstrating that EDITPPT maintains strong performance on long decks, achieving 90.5% slide F1 and 91.7% object preservation, unlike PPTPilot and Talk-to-Your-Slides which show stronger instruction-following degradation as deck length increases.
Development of a dual-modal validation system separates instruction fidelity from visual quality assessment, where the structural validator checks instruction fulfillment and the vision validator detects visual design issues such as overlap, clipping, or unintended layout shifts, providing more robust assessment than relying on a single VLM judge.
The EDITPPT parser uses a compact application-resolved representation instead of raw OOXML, reducing input size from 36.48M raw XML tokens to 8.45M parser tokens and lowering the estimated input cost by 4.32 times, improving efficiency and robustness by removing package-level XML redundancy.
The specialized agent architecture routes tasks based on object type through a dispatcher that performs multi-dispatch, ensuring that local editing failures are less likely to propagate across long, content-dense decks because agents are restricted to type-compatible shape-level tools.
The system incorporates run-level parsing for text by using Character-level font snapshot comparison and a two-tier adaptive font reduction system, which allows the system to perform Proportional scaling Per character ch.Font.Size Preserves original ratio while ensuring text does not overflow shapes via the clamp text to slide function.
The framework supports complex table editing by inferring merged cell structure geometrically through Geometric bounding box comparison, allowing agents to address logical cells rather than raw grid positions, and provides tools like table layout style to modify dimensions and colors directly on the shape.
The system allows for dynamic slide manipulation via tools such as add slide, delete slide, duplicate slide, and set slide background, enabling users to change the title on slide 3 or perform deckwide scope edits that are decomposed into shape-level subtasks.

Abstract

Reliable slide editing requires precise modifications to intended objects while preserving the rest of the presentation. We argue that slide editing is a problem of structured, constrained modification rather than open-ended code generation. Despite the complexity of real presentations, editing requests can largely be decomposed into the objects to change, the operations to apply, and the state to preserve. This perspective guides both evaluation and execution. For evaluation, we introduce DeckEdit-Bench, 183 editing tasks on 28 human-authored decks whose target and preserved objects are annotated at the shape level, so that intended and unintended changes are scored mostly by deterministic rules. For execution, we present EditPPT, a multi-agent framework that resolves targets before editing, restricts each specialist to a subset of 37 predefined tools, and validates each edit for instruction fulfillment and preservation, correcting or rolling back failed ones. Across five backbone models, EditPPT reaches 66.7-74.9% Task Success while keeping Preservation above 97%. Even with an open 27B model and no task-specific fine-tuning, it approaches Claude Code with Sonnet 5 in Task Success while better preserving the original deck. These results suggest that constraining how edits are executed, not only model scale, makes slide editing more reliable.