PaperlayerView exact revision on arXiv

Source-linked AI summary

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

JooYoung Jang, Taegyeong Lee, Jihyeon Park, Nojun Kwak

arXiv:2608.24103v1cs.AI

TL;DR

ACE addresses the difficulty of reliably editing template-based presentations represented as flat, absolutely positioned shapes and evaluating open-ended design edits without a unique ground truth. It combines a hierarchical scene-graph editor, content-aware routing, and self-correction driven by a ground-truth-free instruction-following judge. ACE improves instruction following over an agentic HTML pipeline while reducing time and cost, with visual-quality means statistically indistinguishable from the strongest baseline and blind human preference favoring ACE.

  • Problem

    Flat, absolutely positioned presentation formats force agents to recompute coordinates during edits, while open-ended design lacks a unique ground-truth answer for reliable evaluation.

  • Method

    ACE combines a hierarchical scene-graph action space, CARE content-aware context routing, and a self-correction loop using a ground-truth-free instruction-following judge whose critique guides subsequent edits.

  • Results

    ACE leads instruction following and efficiency, achieving 1.75× faster execution and approximately 44% lower cost than the agentic HTML pipeline, while visual-quality means are statistically indistinguishable from the strongest baseline.

  • Takeaways & Limitations

    A single-turn scene-graph editor can match an internally iterative HTML pipeline, while self-correction produces higher instruction-following performance and blind human raters prefer ACE overall.

  • Takeaways & Limitations

    The evaluated platform scope leaves rebinding ACE’s 98 tools to other presentation APIs and mapping auto-layout onto placeholder layouts as future engineering work, while subjective prompts can yield high output variance.

Abstract

from arXiv · show

Commercial design platforms increasingly edit documents through large language model (LLM) agents, but two practical problems block reliable deployment: legacy document formats expose only \emph{flat}, absolutely positioned elements, so agents must recompute coordinates and routinely break layouts; and design has no unique ground truth, so diff-against-reference metrics penalize valid-but-different outputs. We present \textbf{ACE}, an agentic canvas editor over a \emph{hierarchical scene-graph} with a presentation-specialized action space (98 tools), paired with \textbf{CARE}, a content-aware router that feeds the agent only the relevant slice of each deck (avg.\ $\sim$89\% input-token reduction), and a \emph{self-correction} loop driven by a \emph{ground-truth-free} instruction-following (IF) judge whose natural-language critique is fed back as the next-turn instruction. With a fixed backbone, a scene-graph editor in a \emph{single turn} already matches a same-backbone \emph{agentic} HTML pipeline that iterates internally; adding self-correction lifts ACE significantly above it on instruction following (IF 4.23 vs.\ 3.81 on the full 94-task benchmark, paired $p{=}.010$, replicated by an out-of-loop judge) at 1.75$\times$ the speed and $\sim$44\% lower cost. VQ means are statistically indistinguishable, but 26 blind raters prefer ACE overall (58.7\% decisive win-rate) and prefer the self-corrected output 81\% of the time; the ranking is invariant across three judge families, and out-of-loop judges retain two-thirds of the self-correction gain, bounding circularity. 66\% of cases halt after one pass, and a strict-peak rollback removes every observed regression.

1 Introduction

ACE addresses the difficulty of reliable presentation editing by combining a self-correcting evaluator with a specialized scene-graph editing system and content-aware routing. It targets edits that remain valid even when they differ from a single manual reference.

  • Motivation: Template-based presentation editing preserves expert layouts but still requires laborious, detail-sensitive changes such as reflowing elements and rebuilding charts.LLM-agent systems increasingly automate these edits across PowerPoint, executable programs, and aesthetic layout optimization.
  • ACE: ACE combines a self-correcting agentic canvas editor with a reference-free instruction-following evaluator.The evaluator scores the edit delta against the instruction rather than a single ground-truth answer and feeds its critique into self-correction.
  • Evaluation: 26 blind raters and two out-of-loop judge families validate the reference-free evaluator and preserve the headline rankings.The blind human study reports 76–80% agreement on decided cases, while the out-of-loop judges address potential evaluator circularity.
  • ACE: ACE uses a hierarchical scene-graph action space and a content-aware context router alongside specialized presentation-editing tools.These components are designed to improve editing efficiency and scalability over code-generation editing.
  • Evaluation: ACE is evaluated on 97 multi-slide tasks, including 94 evaluable tasks and 12 novel tasks, and leads coding-agent and OpenXML baselines on instruction following.Its visual-quality means are indistinguishable from the strongest baseline, while blind human preference resolves in ACE’s favor.

2 Related Work

Prior slide-editing systems use code, XML patches, small operation sets, or HTML, while propose–verify–refine methods typically rely on execution errors, rewards, or renders. ACE’s distinction is to provide a specialized scene-graph tool space and a ground-truth-free verification signal for open-ended design editing.

  • Slide Editing Agents: PPTArena and PPTAgent edit PowerPoint decks, while Claude Skills represent slides as HTML and edit them with generic operations.The HTML approach offers consistent output from full-deck context but incurs high cost and latency.
  • Iterative Refinement: Existing propose–verify–refine systems reprompt from geometric metrics, execution errors, REPL logs, or rendered snapshots.These signals support iterative repair when a concrete verification signal is available.
  • Iterative Refinement: Open-ended design editing lacks the execution-error, task-reward, or environment-feedback signal assumed by ReAct and Reflexion.ACE addresses this gap with a ground-truth-free reward based on instruction-following critique.
  • Tool Spaces: ACE provides 98 specialized tools over a scene-graph that combines HTML-like hierarchy with XML-like editability.This differs from Canvas’s 52-tool Figma action space and PPTAgent’s five basic editing tools.

3 Self-Correcting Agentic Canvas Editor

ACE replaces flat, coordinate-based slide editing with a hierarchical scene graph, CARE’s targeted context routing, and a ground-truth-free self-correction loop. Its editor combines responsive layout constraints, semantic tools, selective context, and iterative critique to support reliable multi-slide editing.

  • 3.1 Scene-Graph Domain-Specific Action Space: ACE represents slides as parent–child scene graphs, so parent transformations propagate through descendants instead of requiring per-element coordinate recomputation.Auto-layout can fill or hug parent contents and reflow children when elements are inserted or removed.
  • 3.1 Scene-Graph Domain-Specific Action Space: 98 specialized tools expose semantic operations such as chart and SmartArt creation rather than primitive shape calls.A table-to-chart conversion is described as collapsing from 66 primitive operations to 22 specialized operations, a 3.0× execution-trace reduction.
  • 3.2 CARE: Content-Aware Context Routing: CARE routes instructions into Micro-Spatial, Macro-Programmatic, or Systemic-Token scopes and supplies only the relevant deck slice.The routed representations are target-slide JSON, cross-slide skeleton JSON, or design-system metadata, respectively.
  • 3.3 Self-Correction with a Ground-Truth-Free IF Judge: ACE imitates iterative human design by editing once, judging instruction following from the original-to-prediction delta, and feeding critique into another turn when needed.The loop uses a ground-truth-free IF judge, stops at IF τ=4 or after T=3, and each iteration performs one batched commit.
  • 3.3 Self-Correction with a Ground-Truth-Free IF Judge: Strict-peak rollback returns an earlier iteration when the critic’s logged score declines, removing observed regressions without ground truth.The deployment workflow uses the final iteration unless the critic’s own score indicates that an earlier state was better.

4 Evaluation Suite and Protocol

The evaluation uses a newly curated multi-slide benchmark and judges edits by instruction-grounded changes rather than reproduction of a single reference style. Protocol controls address comparability, visual-validity concerns, and the legacy baseline’s narrower task coverage.

  • 4.1 Evaluation Suite: 97 human-authored multi-slide tasks comprise FIGMA-SLIDE-BENCH-V1, with 94 automatically evaluable cases.The suite contains original and target templates plus an instruction, and includes 12 novel tasks, nine without PowerPoint analogues.
  • 4.2 Evaluation Protocol: The IF judge compares the original-to-prediction edit against the instruction instead of comparing prediction against one ground-truth deck.This protocol evaluates whether user intent was met when multiple valid designs may exist.
  • 4.2 Evaluation Protocol: The VQ judge evaluates alignment, layout, and style against a rubric, using only slides with salient changes for multi-slide edits.The protocol removes PPTArena’s style_target term, which penalized deviations from one prescribed style.
  • 4.2 Evaluation Protocol: Absolute scores are not directly comparable with PPTArena because the study changes the judge, IF protocol, style term, and rendering environment.All pipelines are therefore evaluated under one identical protocol and compared through relative gaps.
  • 4.2 Evaluation Protocol: The controlled OpenXML head-to-head uses a 53-task subset matched to PPTArena’s category distribution and excludes novel-only tasks.Novel-task performance is reported separately because the legacy pipeline cannot represent those tasks.

5 Experiments

ACE is evaluated against agentic HTML and OpenXML pipelines on instruction following, visual quality, efficiency, human preference, judge validity, and component contributions. Across the full benchmark, self-correction improves instruction following while out-of-loop judges and human raters support the main findings.

  • 5.2 Main Result: ACE is 1.75× faster and approximately 44% cheaper than the agentic HTML pipeline, including its self-correction loop.With a gpt-5.5 backbone, ACE is approximately 7× cheaper than the HTML agent.
  • 5.3 Judge Validity: Blind Human Study and Out-of-Loop Judges: Blind raters prefer ACE over HTML overall at a 58.7% decisive win-rate and prefer self-corrected outputs at an 81% decisive win-rate.The study used 26 raters and 935 judgments; human preferences exceed losses in every reported cell.
  • 5.3 Judge Validity: Blind Human Study and Out-of-Loop Judges: Out-of-loop judges preserve the ACE > HTML > PPTArena ranking and recover roughly two-thirds of the self-correction gain.The self-correction IF gain is +0.94 in-loop, +0.61 with Claude, and +0.56 with Gemini.
  • 5.6 Ablations and Component Isolation: A single-pass ACE scores 4.04/3.75 and nearly matches agentic HTML at 4.09/3.89; self-correction raises ACE to 4.45/4.02.The loop adds +0.41 IF and +0.27 VQ on the whole benchmark.
  • 5.6 Ablations and Component Isolation: 66% of tasks halt after iteration 1, while 13 of 18 loop-entering tasks improve and strict-peak rollback removes every observed regression.The 35 halted tasks have mean IF 4.60; rollback increases scores from 4.45→4.49 IF and 4.02→4.06 VQ without harming any task.
  • 5.6 Ablations and Component Isolation: Removing CARE costs up to −0.75 IF, removing specialized tools costs −0.55 to −1.00 IF, and removing self-correction costs −0.41 IF.Without specialized tools, operation counts increase approximately 1.8× on tasks invoking those tools.
  • 5.6 Ablations and Component Isolation: The scene-graph uses 15–31% fewer input tokens per call than OpenXML under identical CARE routing.Per-case savings reach 12–67% as reduced context compounds with fewer agent turns.
  • 5.4 Paired Statistics on the Full Benchmark: IF reaches 4.23 versus 3.81 for HTML on the full 94-task benchmark, with a significant paired comparison.The full-benchmark advantage is significant under both judges, while VQ means are statistically indistinguishable.

Limitations

The evaluation retains a judge-circularity asymmetry, and the platform-specific tool binding and auto-layout mapping remain future work. Subjective prompts also produce high output variance without explicit design-system constraints.

  • Judge circularity: The in-loop IF critic shares a model family with one reported metric, although human and out-of-loop evaluations bound critic-specific effects.Out-of-loop judges recover roughly two-thirds of the measured self-correction gain.
  • Platform scope: Re-binding ACE’s 98 tools to PowerPoint or Google Slides and mapping auto-layout onto placeholder layouts are explicitly scoped as future work.The paper states that both platforms provide serializable representations and renderers, but platform-specific engineering remains unfinished.
  • Prompt scope: Subjective prompts without explicit design-system constraints yield high output variance.

Ethics Statement

The system includes safeguards for human-subject evaluation and deterministic, fallback-based routing, while expanding the editing action space for presentations.

  • Ethics Statement: Adult volunteer raters evaluated anonymized slide renders, no personal data was collected, and benchmark faces were replaced with generic avatars or royalty-free photos.Design assets are used under CC-BY-4.0, and the system is intended to assist rather than replace human designers.
  • System Scope: 98 presentation-editing tools are organized into 11 modules, extending the 52-tool Canvas UI action space.The action-space organization is documented in Table 7.
  • Routing Safeguards: CARE combines a deterministic heuristic with one lightweight LLM call, adopting validated LLM outputs and otherwise falling back to heuristic routing.A final rule reclassifies single-slide decks before context preparation.
  • Routing Safeguards: The classifier uses six cue families for scope, design-system, batch, structural, spatial, and image-gating decisions.Image gating defaults to including visual context on ties, and explicit slide references are clamped to valid indices.
  • Routing Safeguards: Greedy decoding at T=0 makes routing deterministic and reproducible without adding downstream context-selection variance.The single-slide guard rewrites a macro-programmatic decision to a micro-spatial edit for one-slide decks.
  • Efficiency: Under identical CARE routing, scene-graph serialization uses 15–31% fewer input tokens per call than OpenXML.Per-case savings range from 12–67% as reduced serialization and fewer turns compound.

D Cost and Timing Computation

The appendix defines how cost and timing are computed across agentic pipelines and how ACE’s ground-truth-free judge represents and evaluates edits.

  • Cost and Timing: All pipelines are evaluated using logged model calls, including agent turns for every system and ACE’s in-loop judge and CARE router.Failed or no-output cases use the do-nothing baseline, and averages are computed over each pipeline’s logged cases.
  • Cost Drivers: 81% of gpt-5.5 input tokens are cache reads, while its unit prices are approximately 2.4× lower than Claude Sonnet 4.6’s.For Claude Sonnet 4.6, cache writes are the largest cost line and contribute to a $0.518 agent cost.
  • Baselines: Claude-Skill HTML averages $0.968 and 203.0 s over 50 logged cases, including its iterative loop and large HTML context.The supplied passage reports these as logged totals.
  • Comparison: ACEgpt costs $0.134 and is approximately 7× cheaper than the HTML agent while leading on instruction following under all three judges.The PPTArena cost estimate is a deliberate lower bound because per-iteration usage is not logged and true cost may be 1.5–3× higher.
  • Ground-Truth-Free Evaluation: JSONDIFF compares the imported origin deck D0 with the agent’s current state s, never with a ground-truth deck.Stable source IDs align surviving, added, and deleted nodes within one namespace.
  • Ground-Truth-Free Evaluation: The hierarchical diff records slide and node changes, normalizes schema noise, consolidates edits, and appends snapshots or rendered images when needed for judging.Rendered images are attached for visual-content changes, while text-only edits are scored from the structured diff.

F Trajectory Analysis

Trajectory analysis measures task difficulty through agent calls and primitive operations rather than ground-truth outcomes, revealing skewed interaction demands across the benchmark.

  • Trajectory Analysis: Trajectory analysis uses claude-sonnet-4-6 agentic runs to characterize task difficulty without assuming a ground truth.The analysis focuses on execution trajectories rather than reference outputs.
  • Trajectory Analysis: Agent turns have mean 5.6 and median 4, with a right-skewed tail of tasks requiring at least seven turns.Agent turns count LLM calls or assistant messages per task.
  • Trajectory Analysis: Total operations have median 14 and mean 26.1, with approximately 14% of tasks exceeding 50 operations.Operations include commands inside batch_execute calls and standalone tool calls across 56 API types.
  • Benchmark Composition: All 97 tasks were authored manually, with 15 removed cases and 12 novel tasks documented in supplementary tables.Figures provide trajectory, operation, complexity, and benchmark-thumbnail distributions.

H Full Per-Category and Novel-Task Results

The supplementary results report ACE’s instruction-following and visual-quality scores by category and provide separate per-task results for nine novel editing tasks.

  • Per-Category Results: Table 13 reports ACE’s per-category instruction-following and visual-quality results on 94 evaluable tasks.These results use the Claude Sonnet 4.6 backbone and gpt-5.5 judge, matching Table 5.
  • Per-Category Results: The per-category evaluation uses instruction following and visual quality as its two reported metrics.The passage identifies both metric families but does not provide their category-level values.
  • Novel-Task Results: Table 14 gives per-task scores for the nine novel editing tasks.The novel-task results are reported separately from the full 94-task category evaluation.

I Blind Human Study: Protocol and Full Results

A blind, side-randomized study compared ACE with Claude-Skill HTML and compared self-corrected outputs with single-pass outputs. Human preferences favored ACE overall and strongly favored self-correction.

  • Protocol: 26 raters cast 935 judgments across 51 ACE-vs-HTML and 17 self-correction cases after excluding two low-quality raters.The study used blind, side-randomized pairwise comparisons of instruction, before-render, and after-render.
  • Judge–human agreement: The in-loop judge matched blind human majorities on decided cases, supporting agreement between judge rankings and human preferences.Ties were excluded because they provide no directional agreement.
  • ACE vs. Claude-Skill HTML: 58.7% overall decisive win-rate favored ACE over Claude-Skill HTML, with IF at 59.6% and VQ at 57.1%.All reported win-rate confidence intervals excluded 0.5.
  • Self-correction: Humans preferred self-corrected outputs about 81% of the time over single-pass outputs.This preference included VQ, although VQ never controlled the stopping signal.

J Out-of-Loop Judges and Same-Backbone Anchor

Out-of-loop evaluation tested whether self-correction gains depended on the critic that guided the loop, while same-backbone comparisons tested ACE against established baselines. The evidence retained most of the gain and showed ACE leading the strongest same-backbone baseline.

  • Out-of-loop judges: Out-of-loop judges recovered roughly two-thirds of the self-correction gain, bounding the critic-specific component at about one-third.The comparison rescored identical iteration-1-to-final pairs and used byte-identical halted cases as a noise-floor control.
  • Benchmark demands: The benchmark’s reasoning turns and API operations both have long-tail distributions, testing efficiency alongside endurance in long-horizon editing.Operation counts cover multiple operation types, with the top 12 accounting for most of 2,454 total operations.
  • Same-backbone anchor: ACE led the strongest same-backbone OOXML baseline by more than 2 IF points under every judge.The comparison used ACE and PPTArena on gpt-5.5 across 53 tasks with the judge swapped out of the loop.

K CARE: Quality Ablation and Routing Audit

CARE routes each instruction to a task-relevant representation, and ablations examine its quality effects and routing reliability. The results indicate that targeted context preserves quality, specialized operations reduce execution burden, and routing errors are rare and recoverable.

  • Routing scope: CARE excludes three large decks whose full context exceeds the 1M-token window, direct evidence that routing keeps those decks runnable.The ablation therefore runs on 16 multi-slide tasks where CARE actually reduces context, excluding single-slide no-op cases.
  • Quality ablation: CARE’s context ablation lowers quality when the entire deck replaces the routed slice, not merely increasing cost.On 16 multi-slide tasks, the drop was not caused by context overflow and was uncorrelated with deck size.
  • Routing audit: 52/53 routing judgments were exact or borderline, with 1 under-scope error and 0 over-scope errors.The sole under-scope case involved deck-wide grid/alignment cleanup and was lifted from IF 3.0 to 4.0 by self-correction.
  • Rollback: Strict-peak rollback changes IF from 4.45 to 4.49 and VQ from 4.02 to 4.06, with no task harmed.The rule uses only the in-loop IF critic and returns an earlier iteration when its logged score declines.
  • Specialized tools: Specialized graphics tooling reduces the Table-to-Chart execution trace from 66 primitive operations to 22.Removing specialized tools inflated operation counts by approximately 1.8× on active tasks.
Loading 2608.24103v1…