🤖 AI

ACE: A Self-Correcting Agentic Canvas Editor for Multi-Slide Presentation Automation

The paper introduces ACE, a self-correcting agentic canvas editor that leverages a hierarchical scene-graph and a ground-truth-free feedback loop to overcome the layout fragility and evaluation challenges of flat-format document editing, achieving superior instruction-following performance and human preference over existing agentic pipelines at significantly lower cost and latency.

Original authors: JooYoung Jang, Taegyeong Lee, Jihyeon Park, Nojun Kwak

Published 2026-08-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: JooYoung Jang, Taegyeong Lee, Jihyeon Park, Nojun Kwak

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the world of digital design, creating a presentation is rarely about starting from a blank page. Most people begin with a template, a pre-structured document that offers a professional layout and a consistent visual style. This approach saves time and ensures quality, but it creates a new problem: changing that template is often difficult. When a user wants to rearrange a list, swap a chart for a diagram, or adjust the spacing of text across dozens of slides, they must manually move every single element. If they add a new item, they often have to recalculate the position of everything else to avoid overlaps, a tedious process that requires constant attention to detail.

Artificial intelligence has begun to offer help in this area, using large language models to act as digital assistants that can read instructions and make changes. However, these systems face two significant hurdles. First, the files used to store these presentations are often built like a flat list of items with fixed positions, lacking a sense of hierarchy. This forces the computer to do complex math to figure out where everything goes, leading to frequent errors where the layout breaks. Second, design is subjective; there is no single "correct" answer for how a slide should look. Traditional computer programs judge success by comparing the result to a specific reference image, which unfairly penalizes valid but different creative choices. This makes it hard for an automated system to know when it has truly succeeded or when it needs to try again.

Researchers at Seoul National University and the company Miridih have developed a new system called ACE to solve these specific problems. Instead of treating a presentation as a flat list of coordinates, ACE views the document as a structured family tree of elements, similar to how a website is organized. In this structure, moving a parent container automatically updates all the items inside it, just as resizing a folder on a computer screen moves the files within it. This approach allows the system to handle complex edits without constantly recalculating positions. To make this efficient, the system uses a smart router that only feeds the computer the specific parts of the presentation it needs to work on, rather than the entire document, which saves significant time and computing power.

The most distinct feature of ACE is its ability to learn from its own mistakes without needing a human to check the work first. The system includes a specialized judge that reads the instructions and compares them to the changes the computer just made. If the changes do not fully match the user's intent, the judge writes a clear, natural-language critique explaining what is missing. This critique is then fed back into the system as a new instruction, prompting it to fix the specific errors. This cycle repeats until the system is confident the task is complete. Because the judge evaluates whether the instructions were followed rather than comparing the result to a single reference image, it allows for valid creative variations that other systems might reject.

In testing this system against 94 different editing tasks, the researchers found that ACE significantly outperformed existing methods. When compared to a standard coding-based approach that edits presentation files directly, ACE followed instructions more accurately and completed the tasks faster. The system was able to reduce the amount of information it needed to process by nearly 90 percent on average, making it much cheaper to run. While the visual quality of the final slides was statistically similar to the best existing methods, human raters consistently preferred the results produced by ACE. In blind tests, people chose the ACE output over the alternatives more than half the time, and they overwhelmingly preferred the versions that had gone through the self-correction loop.

The study also demonstrated that the system rarely needs to try many times to get it right. In about two-thirds of the cases, the system got the task correct on the very first attempt. When it did need to correct itself, the process was highly effective, with the vast majority of corrections leading to a better result. The researchers also implemented a safety mechanism that automatically reverts to an earlier version if a correction attempt makes the result worse, ensuring that the system never degrades the quality of the work. By combining a smarter way of representing documents with a self-correcting loop that understands human intent, this new approach offers a reliable path for automating the complex, detail-sensitive work of editing professional presentations.

Technical Summary: ACE – A Self-Correcting Agentic Canvas Editor for Multi-Slide Presentation Automation

1. Problem Statement

The paper identifies two primary barriers preventing the reliable deployment of Large Language Model (LLM) agents for editing legacy presentation documents (e.g., PowerPoint):

Legacy Format Limitations (P2): Traditional formats like Office Open XML (OOXML) represent slides as flat sequences of absolutely positioned elements. Agents editing these formats must manually recompute coordinates for every element when content is added or removed, leading to spatial hallucinations and broken layouts. Furthermore, existing editable action spaces are often too small (e.g., offering only five APIs) to cover the complexity of real-world design edits.
Lack of Unique Ground Truth (P1): Design is subjective; there is no single "correct" output for a given instruction. Existing benchmarks often penalize valid-but-different outputs by comparing them against a single reference deck using fixed style rubrics. Additionally, open-ended design editing lacks natural success signals (like execution errors in code generation), making it difficult to implement effective self-correction loops.

2. Methodology

The authors propose ACE (Agentic Canvas Editor), a system designed to operate over a hierarchical scene-graph rather than flat XML, paired with a content-aware routing mechanism and a ground-truth-free self-correction loop.

2.1 Scene-Graph Domain-Specific Action Space

Instead of flat OOXML, ACE utilizes a scene-graph representation (similar to Figma Slides and the HTML DOM).

Hierarchical Structure: Elements are organized in parent-child trees.
Auto-Layout: Parents can enforce constraints (e.g., "hug children," "fill parent") rather than absolute coordinates. This allows agents to insert or remove elements without manually recalculating the position of every sibling.
Action Space: The system exposes 98 specialized tools organized into 11 modules (e.g., create_smartart, create_data_chart). These are semantic operations rather than primitive shape calls, reducing the "reasoning tax" and execution trace length (e.g., a table-to-chart conversion drops from 66 primitive operations to 22).

2.2 CARE: Content-Aware Context Routing

To address the context window limitations of long decks (which can exceed 1M tokens), ACE employs CARE, a router that feeds the agent only the relevant slice of the deck.

Three Modes:
1. Micro-Spatial: High-fidelity JSON for a specific target slide.
2. Macro-Programmatic: Skeleton JSON (node IDs and text) for cross-slide batch edits.
3. Systemic-Token: Only design-system variables and style IDs.
Efficiency: CARE reduces input tokens by an average of 89% (ranging from 86.6% to 99.9%) compared to passing the full deck, without sacrificing quality.

2.3 Self-Correction with a Ground-Truth-Free IF Judge

ACE implements a closed-loop self-correction mechanism driven by an Instruction-Following (IF) Judge.

GT-Free Evaluation: Unlike previous methods that compare predictions to a reference deck, the IF judge evaluates the delta between the original deck and the agent's prediction against the user's instruction. It scores whether the user's intent was met, regardless of the specific visual outcome.
Multimodal Verification: The judge receives structured edit diffs (JSON) and selectively attaches rendered images only when visual-semantic verification is needed.
The Loop: The agent edits the deck, the judge provides a score (0–5) and a natural language critique. If the score is below a threshold ( $\tau=4$ ), the critique is fed back as the next-turn instruction. The loop runs for a maximum of 3 iterations.
Safety: A "strict-peak rollback" mechanism reverts to an earlier iteration if the critic's own logged score declines, ensuring no regressions occur.

3. Key Contributions

The paper makes three specific contributions:

A Reference-Free, Edit-Grounded Evaluator: A multimodal IF judge that scores the agent's edit delta against the instruction rather than a single ground-truth answer. This enables a self-correction loop for open-ended design tasks where no natural success signal exists.
A Domain-Specific Action Space & Router: A hierarchical scene-graph representation with 98 specialized tools, paired with the CARE router. Ablation studies confirm that the representation, the router, the tools, and self-correction each contribute independently to performance.
A New Benchmark (Figma-Slides): A dataset of 97 human-authored multi-slide editing tasks (94 evaluable), including 12 novel tasks with no PowerPoint analogue. The benchmark is released with execution logs and analysis scripts.

4. Results

The system was evaluated on a 94-task benchmark against two baselines: PPTArena (OpenXML/python-pptx) and Claude-Skill HTML (a coding agent editing HTML).

Instruction Following (IF): ACE significantly outperforms baselines. On the full 94-task benchmark, ACE (with self-correction) achieves an IF score of 4.23 compared to 3.81 for the agentic HTML pipeline (paired $p=.010$ ).
Visual Quality (VQ): While mean VQ scores are statistically indistinguishable from the HTML baseline, blind human raters (26 participants) preferred ACE's output in 58.7% of cases. Crucially, raters preferred the self-corrected output over the single-pass output 81% of the time.
Efficiency: ACE is 1.75× faster and ~44% cheaper than the agentic HTML pipeline. When using the gpt-5.5 backbone, ACE is approximately 7× cheaper than the HTML agent.
Self-Correction Impact: 66% of cases halt after one pass. For the 34% that enter the loop, self-correction improves IF by +0.94 and VQ by +0.78 on average. The "strict-peak rollback" removes all observed regressions.
Robustness: The ranking (ACE > HTML > PPTArena) remains invariant across three different judge families (gpt-5.5, claude-sonnet-4-6, gemini-3.5-flash). Out-of-loop judges recover roughly two-thirds of the self-correction gain, bounding the potential for circularity.

5. Significance and Claims

The paper claims that ACE addresses the fundamental mismatch between legacy document formats and agentic editing by introducing a scene-graph representation that supports auto-layout and hierarchical editing.

Solving the "No Ground Truth" Problem: The authors demonstrate that a rendered-diff, instruction-following critique can serve as a usable, ground-truth-free reward signal for design tasks, enabling effective self-correction without requiring a reference deck.
Scalability: By moving away from absolute coordinate arithmetic and code-generation editing (which breaks on complex decks) toward a semantic scene-graph with context routing, the system scales to multi-slide decks with lower cost and higher reliability.
Human Alignment: The system's ability to improve based on natural language critique, validated by blind human preference, suggests that LLM agents can effectively iterate on design tasks in a manner similar to human designers, provided the feedback loop is grounded in instruction intent rather than rigid reference matching.

The authors note limitations, including the current engineering effort required to bind the 98 tools to different platforms (e.g., PowerPoint, Google Slides) and the fact that interactivity remains a weak category. However, they assert that the core methodology is substrate-agnostic and applicable to any platform with a serializable deck representation and a renderer.