1 Introduction↩︎

Image creation and editing have advanced rapidly with diffusion models, instruction-guided editors, and multimodal large language models (MLLMs) [1]–[3]. Yet many practical requests still exceed a single model call. A user may ask an assistant to generate a scene, locate and segment an object, replace only that region, add text or another object, crop the result, and enhance its resolution. Such requests require generation, localization, segmentation, editing, compositing, OCR, geometric transformation, and enhancement to be coordinated within one coherent workflow.

These workflows differ from standard image generation or single-step editing in three key ways. First, they are long-horizon: later operations depend on visual artifacts produced by earlier tools. Second, they are visually grounded: after each tool call, the agent must inspect the intermediate output instead of assuming success. Third, they are stateful: multiple images, masks, crops, extracted objects, and edited variants may coexist, and the agent must select the correct asset for each subsequent operation. These properties make complex image creation and editing a trajectory-learning problem rather than a simple prompt-to-image or instruction-to-image task.

Existing multimodal tool-use research addresses parts of this problem but not the full setting. Early tool-augmented systems connect language models with visual foundation models or external experts for multi-step reasoning and editing [4]–[8]. Recent agentic MLLMs improve active visual perception, search, and executable reasoning [9]–[13], but their tasks mainly target understanding, search, or reasoning. Image-editing systems and datasets, including instruction-guided editing and photo-retouching agents [2], [14]–[19], are closer to our target domain, yet typically focus on single-model editing or retouching in specialized environments. They do not provide large-scale executable trajectories that combine heterogeneous tools, intermediate visual observations, and explicit multi-asset state.

To address this gap, we introduce CanvasCraft, a large-scale multimodal tool-use dataset for complex image creation and editing workflows. CanvasCraft contains two complementary subsets. CanvasCraft-SFT provides fully annotated execution trajectories with user instructions, optional input images, step-level reasoning, tool calls, parameters, outputs, intermediate visual artifacts, and final images. CanvasCraft-RL provides task specifications with expected tool sets, enabling reinforcement learning to explore tool ordering, parameterization, recovery, and stopping strategies without imitating a fixed trajectory.

We instantiate CanvasAgent, a tool-augmented MLLM trained in two stages. Supervised fine-tuning on CanvasCraft-SFT provides an initialization for valid tool invocation and cross-tool dependencies. Reinforcement learning on CanvasCraft-RL then refines the policy with GRPO and a hybrid trajectory-level reward combining final-output alignment, visual quality, reasoning validity, rule-based executability, and efficiency penalties. During execution, CanvasAgent follows a visual-first protocol and maintains explicit image-asset references, allowing it to revise plans, switch tools, or roll back to earlier outputs.

Our contributions are summarized as follows:

• We introduce CanvasAgent, the first tool-augmented multimodal agent designed for complex image creation and editing. CanvasAgent moves beyond passive visual perception by actively orchestrating heterogeneous visual tools for generation, editing, extraction, composition, transformation, and enhancement through multi-turn reasoning.

• We construct CanvasCraft, the first large-scale multimodal tool-use dataset for complex image creation and editing. CanvasCraft covers diverse creation scenarios, tool combinations, and multi-turn visual workflows, with CanvasCraft-SFT providing fully annotated multi-step execution trajectories and CanvasCraft-RL providing diverse and challenging task specifications for reinforcement learning.

• We design a task-specific hybrid reward for complex visual creation and integrate it into a two-stage SFT+GRPO training framework. The reward combines LLM-as-judge signals for image-prompt alignment, aesthetic quality, and trajectory validity with rule-based process checks and efficiency penalties, enabling robust optimization of final images and tool-use processes.

2 Related Work↩︎

2.0.0.1 Tool-Augmented Multimodal Agents

Tool use has become a central mechanism for extending language and multimodal models beyond direct generation. ReAct [20] formalizes the reason-action-observation pattern, and early multimodal systems connect language models with visual foundation models or expert modules for planning, execution, and programmatic visual reasoning [4]–[8], [21]. Recent agentic MLLMs further develop active visual inspection, search, and executable reasoning through operations such as cropping, zooming, Python execution, and heterogeneous tool use [9]–[13], [22]–[25]. These works mainly target perception, visual search, reasoning, or general multimodal assistance. Our work instead focuses on complex image creation and editing workflows, where the agent must produce a final visual artifact by coordinating generation, localization, editing, compositing, OCR, and enhancement tools across stateful trajectories.

2.0.0.2 Image Editing and Creation Workflows

Image generation and editing models have made substantial progress on individual operations. Latent diffusion models enable high-quality synthesis [1], and instruction-guided editors improve controllable editing, generation, and text rendering [2], [14]–[17]. These models are strong building blocks, but they typically execute a single instruction in one model call and do not explicitly manage multi-step tool dependencies or multiple intermediate visual assets.

Photo-retouching agents are closer to our setting because they coordinate editing operations over multiple steps. JarvisArt [18] controls Lightroom operations with an MLLM agent, and JarvisEvo [19] studies a self-evolving edit-evaluate-reflect loop. However, their environment is primarily designed for photo retouching. Our setting targets open-ended image creation and editing workflows that may require generation, grounding, segmentation, object extraction, compositing, cropping, OCR, geometric transformation, and super-resolution within the same trajectory.

2.0.0.3 Learning Tool-Orchestration Policies

Learning effective tool use requires more than exposing a model to tool descriptions. Supervised fine-tuning can teach invocation schemas and reasoning-action formats, but imitation alone may overfit to static demonstrations and fail to discover better long-horizon strategies. Reinforcement learning has therefore been used to optimize tool-use policies, from PPO [26] and GRPO [27] to recent search, visual reasoning, and tool-use systems [28]–[35].

Complex image creation and editing pose a different optimization problem. The agent must select tools, set tool parameters, track intermediate assets, and decide whether the current visual result is sufficient. Reward design must therefore evaluate both the final output image and the execution process. We address this with a two-stage SFT+GRPO framework and a hybrid reward that jointly optimizes visual reasoning, image quality, trajectory validity, and robust tool-use behavior.

3 Method↩︎

This section describes the data construction and training framework of CanvasAgent, illustrated in Fig. 1. We first construct CanvasCraft, a large-scale multimodal tool-use dataset for complex image creation and editing. It contains CanvasCraft-SFT, which provides fully annotated multi-step trajectories, and CanvasCraft-RL, which provides diverse task-level specifications for RL training. We then train CanvasAgent with a two-stage SFT+RL framework: supervised fine-tuning bootstraps stable tool-use behavior from expert trajectories, while reinforcement learning with GRPO improves long-horizon planning with a task-specific hybrid reward. CanvasAgent operates with 11 specialized visual tools covering generation, editing, localization, segmentation, extraction, compositing, geometric transformation, OCR, and super-resolution. During execution, it perceives the current visual state, reasons over intermediate assets, and plans subsequent tool calls, enabling adaptive multi-tool orchestration guided by user instructions and evolving visual feedback.

3.1 CanvasCraft Dataset and Construction↩︎

To train CanvasAgent for complex image creation and editing, we construct CanvasCraft around two principles: coverage and diversity. Coverage ensures that the data spans essential visual operations, while diversity encourages variation in reasoning difficulty, trajectory length, and tool combination. CanvasCraft contains two complementary subsets. CanvasCraft-SFT provides executable multi-step trajectories for supervised tool-use learning, whereas CanvasCraft-RL provides task-level specifications for RL-based policy exploration.

3.1.1 Dataset Construction↩︎

3.1.1.1 CanvasCraft Tool Set

3.0pt

CanvasCraft is built on a unified toolkit of 11 heterogeneous visual tools, including generation, editing, grounding, segmentation, extraction, compositing, cropping, OCR, rotation, flipping, and super-resolution. The full tool specification is provided in Table 1. Each tool is implemented as a low-level operation with structured JSON-style schema, enabling flexible composition into multi-step visual workflows. Because visual tool use depends on intermediate image states, CanvasCraft emphasizes tool chaining, asset management, and long-horizon workflow execution.

3.1.1.2 Construction of CanvasCraft-SFT.

CanvasCraft-SFT provides executable trajectory supervision for visual tool orchestration. Instead of collecting only input–output image pairs, each sample records how a user instruction is decomposed and completed through real tool execution, including step-level reasoning, tool calls, structured parameters, intermediate assets, and final outputs. This allows the Agent to learn valid tool invocation, asset referencing, and cross-tool dependencies in multi-step visual workflows. Formally, each sample is denoted as \(d_{\mathrm{SFT}}=(Q,I,\tau,I_{\mathrm{final}})\), where \(Q\) is the user instruction, \(I\) denotes the optional input image set, \(\tau\) is the executable tool-use trajectory, and \(I_{\mathrm{final}}\) is the final output image.

As shown in Fig. 2, we construct CanvasCraft-SFT through a tool-chain-driven pipeline. We first design tool-chain templates covering atomic visual operations and representative inter-tool dependencies. For each template, we select appropriate input images sampled from PICO-Banana-400K [36], and reverse-engineer a natural user instruction from the intended tool-use behavior. The instruction is then executed in the tool environment to produce reasoning traces, JSON-style tool calls, intermediate assets, and final images. We retain only trajectories that pass quality control, including checks for tool-call parsability, parameter validity, asset-reference consistency, execution success, and redundancy.

3.1.1.3 Construction of CanvasCraft-RL.

Unlike CanvasCraft-SFT, CanvasCraft-RL only contains the expected tool set serves as weak supervision, allowing the agent to explore alternative tool ordering, parameterization, verification, and stopping strategies during rollout. Each sample is represented as \(d_{\mathrm{RL}}=(Q,\mathcal{I}_0,\mathcal{T}^{})\), where \(Q\) is the user instruction, \(\mathcal{I}_0\) denotes the optional input image set, and \(\mathcal{T}^{}\) is the expected tool set for the task.

As shown in Fig. 3, CanvasCraft-RL is constructed around three task dimensions: Reasoning (R), Trajectory Length (L), and Tool Diversity (D). These dimensions describe the reasoning complexity, expected execution length, and tool heterogeneity of each task, respectively. We first generate diverse task seeds to cover these three dimensions, and then expand each seed into a natural user instruction with an expected tool set \(\mathcal{T}^{*}\). After task generation, each sample is characterized along the R/L/D dimensions and assigned difficulty levels according to the criteria in Table 2. The generated tasks are then filtered by DeepSeek-V4-Flash and further verified by human annotators to remove ambiguous, overly simple, or R/L/D-inconsistent instances. For visually grounded tasks, we generate one or more initial images aligned with the instruction.

Together, CanvasCraft-SFT and CanvasCraft-RL provide complementary supervision: the former teaches executable tool-use patterns through complete trajectories, while the latter enables reinforcement learning to optimize flexible planning and dynamic multi-tool orchestration under task-level weak supervision.

4pt

3.1.2 Dataset Composition↩︎

CanvasCraft contains 140K SFT trajectories, 10K RL task specifications, and a manually curated 250-sample evaluation benchmark. A representative data instance is shown in Fig. 4. The dataset covers diverse visual tools, tool-chain structures, and task difficulties, supporting both supervised tool-use bootstrapping and RL-based policy optimization.

CanvasCraft-SFT providing broad coverage of all 11 visual tools and diverse executable supervision through fully annotated tool-use trajectories. The trajectories range from single-tool operations to short dependency chains and high-complexity multi-turn workflows. In particular, 3.8K examples involve longer execution paths, richer tool combinations, and more involved inter-tool dependencies, enabling the model to acquire valid tool invocation formats, basic tool dependencies, and initial long-horizon execution patterns.

10pt

CanvasCraft-RL is organized along reasoning difficulty, trajectory length, and tool diversity (R/L/D), with an emphasis on medium and hard levels; the full distribution is reported in Table 3. Unlike CanvasCraft-SFT, this subset only provides task-level supervision rather than fully annotated trajectories, encouraging the agent to learn task decomposition, state-dependent planning, and heterogeneous tool orchestration during reinforcement learning.

3.2 Two-Stage Training Framework↩︎

Based on the two subsets of CanvasCraft, we train CanvasAgent with a two-stage SFT+GRPO framework as shown in Fig. 1. SFT bootstraps stable tool-use behavior from complete executable trajectories, while GRPO optimizes rollout-level multi-tool planning under weak supervision. This design combines the reliability of trajectory imitation with the flexibility of reinforcement learning-based policy exploration.

3.2.1 SFT for Tool-Use Bootstrapping↩︎

In the SFT stage, CanvasAgent is trained on CanvasCraft-SFT with the standard next-token prediction objective. Given complete expert trajectories, the model learns valid reasoning-action formats, JSON-style tool calls, parameter generation, cross-tool dependencies, and references to intermediate visual assets. This stage stabilizes subsequent reinforcement learning, since direct RL over executable visual tools often leads to invalid tool calls, unstable rollouts, and sparse rewards. Nevertheless, SFT is limited to imitating demonstrated trajectories and cannot sufficiently explore alternative tool-use strategies, motivating the RL stage.

3.2.2 RL for Image Planning and Manipulation↩︎

After SFT initialization, we further optimize CanvasAgent on CanvasCraft-RL with group relative policy optimization (GRPO) [27]. For each task, GRPO samples multiple executable rollouts and updates the policy according to their relative rewards, without requiring an additional value model. This stage encourages the agent to explore different task decompositions and tool-use strategies under weak supervision. The optimization signal comes from our task-specific hybrid reward, which evaluates both final visual quality and tool-use process validity.

3.3 Hybrid Reward Design↩︎

Diverse image creation and manipulation tasks are difficult to evaluate because they involve multiple intermediate steps, diverse tool choices, and subjective visual quality. To guide RL training, we design a task-specific hybrid reward that evaluates both the final output and the execution trajectory:

\[\begin{align} R(\tau) &= \underbrace{0.3 \cdot R_{\mathrm{align}}(\tau) + 0.1 \cdot R_{\mathrm{aes}}}_{\text{Outcome Score}}(\tau) + \underbrace{0.2 \cdot R_{\mathrm{traj}}(\tau) + 0.4 \cdot R_{\mathrm{rule}}}_{\text{Process Score}}(\tau). \end{align}\]

3.3.1 Outcome Score↩︎

Outcome scores are computed with expert LLM-as-judge evaluators.

3.3.1.1 Alignment Score.

\(R_{\mathrm{align}}\) evaluates whether the final image satisfies the user’s instruction. Given the image-prompt pair and the final image, it focuses on requested objects, attributes, actions, spatial relations, colors, text, quantities, and edited regions.

3.3.1.2 Aesthetic Score.

\(R_{\mathrm{aes}}\) evaluates the perceptual quality of the final image. It takes the final image as input and scores composition, color, lighting, clarity, texture naturalness, style consistency, artifacts, and blur. This score is independent of instruction alignment and trajectory quality.

These judges capture semantic fidelity and visual quality, which cannot be fully measured by deterministic rule-based signals alone.

3.3.2 Process Score↩︎

3.3.2.1 Trajectory Score.

\(R_{\mathrm{traj}}\) evaluates whether the trajectory is reasonable for the task. It takes the whole trajectory and the expected tool set as input. The judge focuses on process quality, including whether the agent decomposes the task properly, selects appropriate tools, follows valid tool dependencies, and avoids irrelevant or unnecessary operations. It does not directly judge the final image.

3.3.2.2 Rule-based Reward.

While LLM judges evaluate high-level semantic, perceptual, and reasoning quality, rule-based rewards provide deterministic feedback on low-level executability. We define the rule-based reward as a combination of format reward, action reward, and efficiency penalty: \[R_{\mathrm{rule}}(\tau) = 0.4 \cdot R_{\mathrm{format}}(\tau) + 0.6 \cdot R_{\mathrm{action}}(\tau) - \lambda_{\mathrm{eff}} P_{\mathrm{eff}}(\tau), \label{eq:process95reward}\tag{1}\] The format reward \(R_{\mathrm{format}}\) verifies whether the model follows the required reasoning-action protocol. It checks the presence of valid <reason> and <tool_call> blocks, whether tool calls can be parsed as valid JSON, whether each turn contains at most one tool call, whether termination is used properly, and whether the response avoids unsupported extra formatting. This reward enforces syntactic compliance with the agent interface

While the format reward checks well-formed syntax, the action reward evaluates whether each tool invocation is executable under the current visual state. Given a trajectory \(\tau\) with \(N\) parsed tool calls, we compute \[R_{\mathrm{action}}(\tau)=\frac{1}{N}\sum_{i=1}^{N} q_i, \label{eq:action95reward95avg}\tag{2}\] where the per-action validity score \(q_i\) is defined as \[q_i = 0.25 r_i^{\mathrm{name}} + 0.25 r_i^{\mathrm{schema}} + 0.20 r_i^{\mathrm{ref}} + 0.20 r_i^{\mathrm{spec}} + 0.10 r_i^{\mathrm{exec}}, \label{eq:step95quality}\tag{3}\]

The five sub-scores are computed as \[\begin{alignedat}{2} r_i^{\mathrm{name}} &= \mathbb{I}\!\left[f_i \in \mathcal{T}\right], &\qquad r_i^{\mathrm{schema}} &= \mathbb{I}\!\left[\mathrm{Req}(f_i) \subseteq \mathrm{NonEmptyArgs}(a_i)\right], \\ r_i^{\mathrm{ref}} &= \frac{1}{|\mathrm{Refs}(a_i)|} \sum_{v \in \mathrm{Refs}(a_i)} \mathbb{I}\!\left[v \in \mathcal{A}_{i-1}\right], &\qquad r_i^{\mathrm{spec}} &= \mathbb{I}\!\left[\mathrm{SpecCheck}(f_i,a_i,\mathcal{A}_{i-1})=1\right], \\ r_i^{\mathrm{exec}} &= \mathbb{I}\!\left[\mathrm{Exec}(a_i)\geq 0\right]. \end{alignedat} \label{eq:reward95components}\tag{4}\]

Here, \(f_i\) is the selected tool, \(a_i\) denotes its structured arguments, \(\mathcal{T}\) is the set of valid tools, and \(\mathcal{A}_{i-1}\) is the set of available visual assets before step \(i\). The term \(r_i^{\mathrm{name}}\) checks tool-name validity, while \(r_i^{\mathrm{schema}}\) verifies whether the required arguments of tool \(f_i\) are present and non-empty. The reference score \(r_i^{\mathrm{ref}}\) checks whether all image or asset references in the arguments point to valid assets in the current state. The tool-specific score \(r_i^{\mathrm{spec}}\) encodes operation-dependent constraints, such as valid bounding boxes for localization and segmentation, valid masks for extraction, valid positions for compositing, and required asset types for object overlay. Finally, \(r_i^{\mathrm{exec}}\) indicates whether the corresponding tool execution succeeds.

After a successful image-producing tool call, the resulting asset identifier is added to the asset state: \[\mathcal{A}_{i} = \mathcal{A}_{i-1} \cup \{\mathrm{OutputID}(f_i,i)\} \quad \text{if } f_i \in \mathcal{T}_{\mathrm{img}} \text{ and } r_i^{\mathrm{exec}}=1, \label{eq:asset95update}\tag{5}\] otherwise \(\mathcal{A}_{i}=\mathcal{A}_{i-1}\). Therefore, \(R_{\mathrm{action}}\) evaluates whether each tool call is compatible with the evolving visual asset state and executable within the tool environment.

3.3.2.3 Efficiency Penalty.

The efficiency penalty discourages degenerate or unnecessarily costly trajectories: \[P_{\mathrm{eff}}(\tau) = P_{\mathrm{error}}(\tau) + P_{\mathrm{repeat}}(\tau) + P_{\mathrm{length}}(\tau) + P_{\mathrm{cost}}(\tau) + P_{\mathrm{miss}}(\tau), \label{eq:efficiency95penalty}\tag{6}\] Here, \(P_{\mathrm{error}}\) penalizes failed tool executions, \(P_{\mathrm{repeat}}\) penalizes adjacent repeated or near-repeated tool calls, \(P_{\mathrm{length}}\) penalizes overly long reasoning segments, \(P_{\mathrm{cost}}\) discourages excessive tool usage beyond the expected interaction budget, and \(P_{\mathrm{miss}}\) penalizes missing key expected tools. These terms prevent the agent from improving trajectory scores by blindly invoking more tools, and instead encourage concise, purposeful, and task-relevant tool orchestration.

Together, the hybrid reward balances semantic alignment, visual aesthetics, reasoning validity, rule adherence, and execution efficiency. By combining semantic, perceptual, procedural, and symbolic constraints, it reduces reward hacking and provides rich supervision for robust multi-step visual creation.

4 Experiments↩︎

4.1 Experiment Settings↩︎

4.1.0.1 Evaluation set.

We evaluate all models on the CanvasCraft-RL evaluation split, which contains \(250\) samples. Each sample includes a user instruction, an optional input image, and a reference tool set used only for reward computation.

4.1.0.2 Compared methods.

We compare three groups of methods. First, we evaluate general-purpose MLLMs equipped with the CanvasCraft tool set, including LLaVA-OneVision-7B, Qwen3-VL-8B-Instruct, and Qwen3-VL-32B-Instruct. These models use the same tools but are not trained on CanvasCraft. Second, we include Qwen-Image-2.0, Wan2.7-Image, and GPT-Image-2 as image-only reference models. Since they directly generate or edit the final image without producing reasoning–action–observation trajectories, their results serve only as outcome-level references. We therefore report only alignment and aesthetic scores for these models. Finally, we compare two CanvasCraft-trained variants. CanvasAgent (SFT) is trained only on CanvasCraft-SFT, while CanvasAgent (SFT+RL) is our full model trained with supervised fine-tuning followed by GRPO-based reinforcement learning on CanvasCraft-RL.

4.1.0.3 Training setup.

All experiments are conducted on \(8\) NVIDIA A800 GPUs over \(7\) days. Six GPUs are used for model training, and the remaining two GPUs host all \(11\) visual tools locally for executable rollout. The base model for all trained variants is Qwen3-VL-8B-Instruct. The LLM-as-judge model is Qwen3.5-Plus.

4.1.0.4 Metrics.

We report six metrics. Overall Reward is the final hybrid reward for trajectory-level evaluation. Alignment Score measures whether the generated image satisfies the user instruction. Aesthetic Score measures visual quality and appeal. Trajectory Score evaluates the reasoning and tool-use trajectory. Rule-based Score measures format validity, parameter validity, and efficiency. Trajectory Length reports the average number of executed tool calls.

4.2 Experimental Results and Analysis↩︎

Table 4 presents the overall evaluation results on the full evaluation set. We report the hybrid reward, three LLM-as-judge scores for alignment, aesthetics, and trajectory quality, the rule-based score, and the average trajectory length.

Compared with Qwen3-VL-8B-Instruct, CanvasAgent (SFT) improves the overall reward from \(0.426\) to \(0.557\) and raises the trajectory judge score from \(0.092\) to \(0.576\). This shows that CanvasCraft-SFT teaches structured reasoning–action formats and executable tool-use trajectories. However, CanvasAgent (SFT) still underuses the tool set, producing only \(1.320\) tool calls on average compared with the expected \(3.592\) calls. Supervised learning therefore establishes initial tool-use capability but remains limited in active multi-tool planning.

CanvasAgent (SFT+RL) further improves all major metrics. Compared with CanvasAgent (SFT), it increases the overall reward from \(0.557\) to \(0.821\), image–prompt alignment from \(0.613\) to \(0.869\), trajectory quality from \(0.576\) to \(0.849\), and the rule-based score from \(0.467\) to \(0.785\). The average number of tool calls also increases from \(1.320\) to \(5.436\), indicating that RL encourages richer multi-step visual manipulation. These results show that CanvasCraft-RL and the hybrid reward help CanvasAgent learn dynamic task decomposition, tool planning, and adaptive decision-making from intermediate visual observations.

During RL training, the number of tool calls first increases and then gradually stabilizes or decreases, suggesting a transition from active exploration to more efficient tool orchestration under the guidance of process and efficiency rewards.

We include Qwen-Image-2.0, Wan2.7-Image, and GPT-Image-2 as image-only reference models. Since these models directly generate or edit the final image without producing reasoning–action–observation trajectories, we report only outcome-level metrics, namely alignment and aesthetic scores. Their alignment scores are lower than CanvasAgent (SFT+RL), suggesting that strong image-only models still struggle with complex image editing tasks that require multi-step tool orchestration.

4.3 Ablation Studies↩︎

Table 5 ablates the training strategy and reward design. SFT-only training establishes executable reasoning–action patterns, reaching an overall reward of \(0.557\) and a trajectory score of \(0.576\). RL from scratch improves the overall reward to \(0.604\), but lowers alignment and aesthetics to \(0.472\) and \(0.666\), suggesting unstable exploration without an SFT initialization. SFT+RL performs best across all metrics, reaching \(0.821\) overall reward, \(0.869\) alignment, \(0.762\) aesthetics, and \(0.849\) trajectory score.

The reward ablations show that outcome and process signals are complementary. Removing the outcome reward preserves a high trajectory score (\(0.907\)) but hurts alignment and aesthetics (\(0.320\) and \(0.565\)), while removing the process reward drops the overall reward and trajectory score to \(0.379\) and \(0.357\). The full hybrid reward gives the most balanced performance, guiding both final image quality and executable tool-use behavior.

4.4 Case Study↩︎

Figure 5 presents a representative multi-image editing task. The user provides three input images: a storefront sign containing readable English text, a blank sign panel for reconstructing the translated sign, and a rainy street scene into which the final sign should be inserted. Solving this task requires substantially more than direct image generation or editing. The agent must localize the original sign, extract and recognize its text, reconstruct the translated sign on the blank panel, and finally composite the result into the target scene while preserving perspective, lighting, scale, and reflections.

CanvasAgent completes this task through a multi-turn reasoning and tool-use trajectory involving perception, extraction, editing, OCR, and compositing tools. During execution, the agent generates and manages multiple intermediate visual assets, including segmentation masks, extracted sign regions, reconstructed sign panels, and edited scene images. These assets are explicitly referenced by subsequent tool calls, enabling the agent to coordinate multiple input images and intermediate results within a unified trajectory.

This case also demonstrates closed-loop visual tool orchestration. After performing transformation or editing operations, CanvasAgent invokes perception tools such as grounding and OCR to inspect intermediate results and verify whether the generated content satisfies the task requirements. The agent then uses these observations to guide subsequent editing and compositing decisions. This behavior demonstrates that CanvasAgent does not merely generate a final image in a single step; instead, it actively manipulates visual states through iterative reasoning, tool execution, observation, and refinement.

4.5 Human Evaluation↩︎

We conduct a user study on \(12\) CanvasCraft evaluation samples to assess whether our judge-based evaluation aligns with human preferences.. Annotators score each output from 1 to 5 on Task Alignment, Key Details Alignment, and Aesthetic Quality.

As shown in Table 6, CanvasAgent achieves the best scores across all dimensions, indicating better instruction satisfaction, key information preservation, and visual quality. The three dimensions also align with our judge design for alignment, semantic/text correctness, and aesthetics.

5 Conclusion↩︎

We present CanvasAgent, a tool-augmented multimodal agent for complex image creation and editing. Rather than treating image generation as a single black-box call, CanvasAgent decomposes open-ended visual requests into executable multi-step tool trajectories. CanvasCraft provides the supervision needed for this setting, with 140K SFT trajectories and 10K curated RL task specifications spanning diverse editing, composition, perception, and verification behaviors. The two-stage SFT+RL pipeline first grounds the model in executable tool use and then improves both final image quality and trajectory reliability through a hybrid reward. Across automatic and human evaluations, CanvasAgent shows consistent gains from supervised trajectory learning, reinforcement learning, and the combination of outcome- and process-level feedback.

Limitations and future work. CanvasAgent currently uses a fixed set of 11 tools, relies on an external MLLM judge, and requires real tool execution during RL rollout. Future work will study dynamic tool discovery, learned or self-evaluation rewards, more efficient rollout strategies, user feedback, self-improvement, and extensions to video creation and editing.

6 LLM-as-Judge Prompts Details↩︎

6.1 Prompt for Alignment Score↩︎

6.2 Prompt for Aesthetic Score↩︎

6.3 Prompt for Trajectory Score↩︎

6.4 CanvasCraft-SFT Distribution↩︎

8pt

3.5pt

6.5 Broader Impacts↩︎

CanvasAgent can improve controllable visual creation by decomposing complex editing instructions into interpretable tool-use trajectories, reducing manual effort in design, prototyping, and image editing workflows. However, stronger generation and editing capabilities may also be misused for deceptive or harmful visual content. We therefore emphasize responsible release, dataset filtering, and clear documentation of intended uses and limitations.

References↩︎

---

1. Corresponding author.↩︎