acceptodds
Under review as a conference paper at ICLR 2027

ComAct: COM as a Unified Action Space for Professional Software Agents

Abstract

Current computer-use agents remain fundamentally limited on professional software. GUI-based agents struggle with fragile visual grounding and error accumulation over long action sequences, while MCP- and API-based agents require programmable interfaces that closed-source commercial software rarely provides. We observe that the Component Object Model (COM), a Windows-native interface widely supported by commercial professional applications, provides programmatic access to their full functionality through a uniform invocation mechanism. We therefore present ComAct, which uses COM as a unified action space across professional applications, replacing long, fragile GUI actions with compact executable COM programs. We stress-test ComAct on industrial CAD and build ComCADBench, comprising 1,000 tasks across three mainstream CAD applications, spanning standalone design tasks and multi-stage engineering workflows. Frontier models fail almost completely under GUI interaction but achieve non-trivial success when switched to ComAct, and the same switch also yields consistent zero-shot improvements on Office, Adobe, and OS-shell tasks. Yet off-the-shelf models still exhibit a large gap between executable code and task-correct outputs. To close this gap, we build ComForge} a scalable platform of parallel real computer environments for large-scale training, and train a self-correcting agent through a three-stage progressive framework with continuous geometric rewards. Experiments show our agent achieves state-of-the-art performance on ComCADBench, particularly on long-horizon workflows, and generalizes well to external CAD benchmarks. The environment, code and data will all be publicly released.

Primary area:
foundation or frontier models, including LLMs
Keywords:
computer-use agents, MLLM, component object model, code synthesis, computer-aided design

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_3ZPaOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes ComAct, which lets computer-use agents act on an action space defined by the Component Object Model. It also introduces ComCADBench, which tests agents' task performance on mainstream CAD applications. Agents with ComAct showcase significantly better performance compared to agents with GUI interaction. It also proposes to train agents on COM with a 3-stage framework, which improves a 9B model's ability to act within the ComAct framework by a large margin, achieving better performance than frontier models.

Critical strengths

The potential of this proposed paradigm shift is huge (only from my point of view, but I am not very familiar with the current status and needs of CUAs). I see that COM is a better choice compared to GUI, especially in applications that are complex, require long-term interactions and need expertise. COM also seems to be better choice than API as it is more widely accepted in multiple software families. So I find the paper's motivation convincing.

The paper also proposes a three-stage training framework and trains a 9B model by optimizing (1) COM code generation, (2) code revision, and (3) task completion. The results demonstrate the potential of COMAct for training capable smaller-scale agents.

This paper is also well written and very easy to follow.

Critical weaknesses

I am not familiar with the field, but here are some concerns I think should be clarified.

First, I don't know how widely COM is used. For example, in WindowsAgentArena, I see that there are tasks that are not COM-compatible (the authors used only the "COM-compatible subsets").

Second, results are mainly focused on CAD tasks, with limited evaluation on other domains and applications that COM also applies to, as claimed in the paper. Moreover, the trained 9B model is not evaluated on WindowsAgentArena. Does the learned COM code generation ability transfer to other domains?

I also suggest including the backbone model name in Table 2, with a note that it is trained. The label "Ours" alone is confusing to readers.

Questions for authors

Since the authors reports strong performance on multi-task workflows, how does the success rate change as a function of the number of sequential operations / subtasks?

Also, please address my questions in the weaknesses section if you'd like to.

1 comment

Dear Reviewer 3ZPa,

Thank you for your encouraging feedback and for recognizing our convincing motivation and paradigm potential. Below are our point-by-point responses.


Response to W1: Coverage of COM across software

COM is widely used in professional software. In WindowsAgentArena, the COM-incompatible applications are general-purpose browsers and lightweight utilities (e.g., Clock and Calculator), whereas most heavy professional applications support COM for cross-application communication and data exchange. For instance, in ScreenSpot-Pro (Li et al., 2025b), a visual grounding benchmark for professional software, all 16 covered professional applications support COM. We also list 34 COM-compatible professional applications across 6 domains in Appendix E.8 (Table 22).


Response to W2: Beyond-CAD evaluation & Cross-domain transfer

We focus on industrial CAD because it combines 3D spatial reasoning, strict numerical precision, and dependent multi-step workflows, making it a demanding testbed for COM. Beyond CAD, Table 3 already evaluates ComAct across three additional categories (OS Shell, MS Office, and Adobe Suite) on WindowsAgentArena (Bonatti et al., 2024) and ProSoftArena (Ai et al., 2026), showing consistent zero-shot gains over GUI for both frontier and open-source models.

We further evaluated our trained 9B agent on WindowsAgentArena (Table R1). It shows limited transfer to non-CAD tasks, which is expected given our small, CAD-only post-training dataset. While COM unifies how applications are invoked, each application still defines its own objects and methods (e.g., sketches and features in CAD vs. workbooks and cells in Excel), making cross-domain transfer challenging. Still, this 9B result does not reflect the ceiling of COM code generation. We expect larger models trained on broader, high-quality COM data to generalize across domains, and our CAD COM dataset contributes toward that goal.

Table R1. ComAct task success rate (%) on WindowsAgentArena.

ModelOS ShellOffice
Qwen3.5-9B (base)33.326.3
Qwen2.5-VL-72B36.426.3
GPT-566.742.1
Ours (Qwen3.5-9B, CAD-trained)29.221.1

Response to W3: Table 2 label suggestion

Thank you for the suggestion. We have updated "Ours" in Table 2 to "Ours (Qwen3.5-9B, trained)" to specify the backbone model and its trained status.


Response to Q1: Success rate vs. number of sequential operations

We grouped tasks by the number of required sequential operations and plotted each model's full-workflow success rate across groups in Appendix E.10 (Figure 11). As the number of operations increases, overall success rate declines for all models, while our trained ComAct agent outperforms all baselines by a large margin on the longest workflows.


Thank you again for your helpful feedback, which has strengthened our paper. We hope our responses address your concerns, and we would greatly appreciate your consideration in updating your score.

Best regards, The Authors

Reviewer_YixHOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

The paper proposes ComAct, in which agents operate professional Windows applications by generating executable Python programs that invoke COM interfaces. It introduces ComCADBench, a 1,000-task benchmark spanning three commercial CAD applications, and ComForge, an execution platform for training and evaluation in real software environments. A 9B agent is trained through instruction-to-code supervision, multi-turn refinement, and GRPO with continuous geometric rewards. The experiments evaluate the benefits of COM interaction and domain-specific training, with additional evaluations on external CAD benchmarks and COM-compatible desktop tasks.

Critical strengths
  1. A good benchmark and systems contribution. The work goes beyond isolated shape generation to cover assembly, editing, engineering drawings, mass-property analysis, and interference detection in real commercial applications. Pairing these tasks with executable reference programs, environment reset, and artifact-level evaluation provides useful infrastructure for studying and training professional-software agents.
  2. Strong empirical performance against relevant baselines. The trained 9B model achieves an overall success rate (SR) of 79.1%, compared with 43.5% for GPT-5 and 53.5% for Claude-Sonnet-4.6 under few-shot prompting—a 25.6-percentage-point improvement over the stronger of these baselines. It also achieves 74.5% SR on multi-stage workflows. Importantly, the evaluation goes beyond comparisons with unsuccessful GUI agents: it includes general-purpose models operating in the same COM environment, with a shared prompt structure and code-revision budget. These comparisons provide meaningful evidence for the effectiveness of the training pipeline within the chosen interaction interface.
  3. A well-motivated training progression. The three stages target distinct failure modes: incorrect API usage, failure to recover from execution errors, and executable programs that produce incorrect geometry. In particular, Stage 3 selects tasks whose programs execute successfully but fail task verification, directly targeting the gap between executability and correctness through geometric rewards. The cumulative ablation shows consistent incremental gains: SolidWorks modeling SR increases from 52% after Stage 1 to 76% after Stage 2 and 81% after Stage 3.
Critical weaknesses
  1. The paper contrasts COM with API-based interaction, although ComAct itself generates programs that invoke application-specific COM APIs. A common invocation mechanism is useful, but it does not by itself establish full functional coverage or a fundamentally distinct interaction paradigm. The paper should distinguish the practical benefits of adopting COM from its broader claims about a unified action space.

  2. Table 5 establishes that successive training stages improve performance, but each transition changes multiple factors. Stage 2 introduces additional training data, teacher-corrected trajectories, screenshots, and terminal feedback alongside multi-turn supervision. The three stages use 12K, 30K, and 2,156 samples, respectively. Stage 3 changes not only the training objective but also the trainable parameter set, switching from LoRA to full-parameter optimization. Consequently, several important questions remain unresolved: whether multi-turn training outperforms high-quality single-turn supervision with comparable data; whether screenshots contribute beyond terminal feedback; whether continuous geometric rewards outperform binary task-success rewards or further supervised training; and how much of the Stage-3 gain comes from updating more parameters. Targeted controls with comparable data and optimization budgets, while holding the trainable parameter set fixed, would make the contribution of each design choice clearer.

  3. The main GUI baselines are allowed up to 35 interaction turns, whereas COM agents receive a budget of five code revisions. Since a single COM program can execute dozens of API calls, these budgets are not directly comparable in terms of the operations they permit. The additional 100-step GUI experiment is useful, but it does not isolate the benefits of programmatic access from those of composing many operations into one action.

Questions for authors

Q1. What exactly does the evaluator certify beyond surface geometry? For assembly tasks, are joint types and remaining degrees of freedom checked in the native software state?

Q2. How much improvement comes specifically from using execution feedback? Please report first-attempt success and the fraction of initially failed tasks recovered through revision, ideally distinguishing execution errors from artifact mismatches.

Q3. Can the Stage-3 improvement be separated from the change to full-parameter training? A continued-SFT control with the same trainable parameters and a comparable optimization budget would address this confound.

I would be open to increasing my score if you can answer these questions. I am more inclined to accept this article.

3 comments

Dear Reviewer YixH,

Thank you for your detailed and constructive feedback. We appreciate your recognition of our benchmark and systems contribution. Below are our point-by-point responses to your concerns and questions.


Response to W1: COM vs. APIs & Unified action space

API/MCP scope. The API/MCP baselines in our paper refer to existing CUA methods built on open-source libraries or manually wrapped external endpoints (e.g., REST APIs, MCP servers), which use fragmented protocols, expose limited surface features, and rarely support closed-source commercial software. By contrast, COM is a native binary interface built into commercial Windows software. Although ComAct still invokes application-specific COM APIs, it accesses native software capabilities directly through a uniform win32com binding, without per-app wrappers or waiting for vendors to open MCP servers.

Functional coverage. COM's high functional coverage comes from its underlying architecture, not just a common calling mechanism. As the native binary standard for macros, plugins, and automation on Windows, COM is how developers expose core internal functionality when building commercial software. As shown in Table 7, these three CAD platforms alone natively expose 12,376 interfaces in SolidWorks, 24,269 objects in Inventor, and 4,078 interfaces in AutoCAD, directly covering deep workflows such as modeling, assembly, drawings, and interference detection.

Unified action space. Our claim specifically targets professional software, which is predominantly closed-source, Windows-based, and natively COM-supported. COM unifies interaction across different professional applications into one execution framework through a common object-method-property calling pattern.

We agree that the practical benefits of adopting COM should be distinguished more clearly from broader claims about a unified action space, and we have tightened our wording in the Abstract, Section 1, and Section 3 accordingly.



Response to W2 & Q3: Controlled ablations of training stages

  1. Single-turn vs. multi-turn supervision. We built two matched datasets from the Stage 2 trajectories (30K samples): the single-turn set keeps only the instruction and final correct code, while the multi-turn set keeps execution feedback and revision steps. Both start from the same Stage 1 checkpoint with identical trainable parameters and are evaluated on 300 ComCADBench tasks with up to 5 code revisions (Table R1). Multi-turn supervision raises final SR from 75.3% to 81.7%. Among 84 tasks where both failed on the first attempt, single-turn recovered 18 while multi-turn recovered 37, showing that feedback and revision traces add training value beyond final-answer supervision.

Table R1. Single-turn vs. multi-turn supervision under matched data.

Training SetupSW 3D-MInv. 3D-MInv. Asm.Overall SR (%)
Final correct code only (single-turn)70.082.074.075.3
Feedback & revision (multi-turn, Ours)76.087.082.081.7
  1. Terminal-only vs. terminal + screenshot feedback. We compared both settings on 30 ComCADBench tasks (Table R2). Without screenshots, the agent more often declares completion when code runs without errors yet produces a wrong artifact (e.g., missing intended operations or mismatched geometry). Screenshots expose the visible artifact state, helping the agent check geometry and judge true task completion.

Table R2. Terminal-only vs. terminal + screenshot feedback.

FeedbackSW 3D-MInv. 3D-MInv. Asm.Overall SR (%)
Terminal only80.090.090.086.7
Terminal + screenshot90.090.090.090.0
  1. Continuous geometric vs. binary reward. Continuous geometric rewards distinguish how close candidates are to the target within each group. Figure 3 compares binary and continuous reward distributions: when all candidates in a group fail, binary rewards are all 0, giving zero group advantage and stalling updates, whereas continuous rewards still rank candidate quality and provide optimization signal (also shown in Table R3).

  2. Continued SFT & trainable parameters (Q3). We chose LoRA for SFT and full parameters for RL based on early experiments: LoRA learned COM coding and error recovery well while avoiding the general instruction-following drop seen with full-parameter SFT, whereas full-parameter GRPO directly updates weights from geometric rewards without LoRA rank limits and outperformed LoRA in early tests. To isolate parameter count, we built 1,840 SFT samples from Stage 3's 2,156 tasks (316 tasks yielded no fully correct rollout) and compared full-parameter continued SFT (1 epoch) against full-parameter GRPO from the same Stage 2 checkpoint using the exact same trainable parameters (Table R3). Continued SFT slightly improves code validity but fails to fix geometric deviations, leaving overall SR 3.7 percentage points below full-parameter GRPO. This confirms that Stage 3 gains come from geometric optimization rather than updating more parameters.

Table R3. Stage 3 controls from the same Stage 2 checkpoint with fixed full parameters.

Stage 3 MethodSW 3D-MInv. 3D-MInv. Asm.Overall VR / SR (%)
Stage 2 checkpoint88.0 / 76.095.0 / 87.093.0 / 82.092.0 / 81.7
+ Full-param continued SFT90.0 / 77.096.0 / 87.094.0 / 83.093.3 / 82.3
+ Full-param GRPO (binary reward)89.0 / 78.095.0 / 88.094.0 / 85.092.7 / 83.7
+ Full-param GRPO (continuous geo, Ours)90.0 / 81.096.0 / 89.095.0 / 88.093.7 / 86.0

Full details and reward distributions are added in Appendix E.5 (Tables 17–19).



Response to W3: GUI vs. COM budget comparison

Composing multiple CAD operations into a single executable script is a key advantage of COM. While GUI agents must select objects, enter parameters, and confirm step by step, COM specifies objects, parameters, and operation order directly in code, improving both accuracy and efficiency.

To further isolate the effect of step limits, we compared GUI and COM under matched time (60 min/task) and matched token (170k tokens/task) budgets using the same model and the same 40 tasks (Tables R4 and R5).

Table R4. Matched-time comparison (60 min/task, 40 tasks; SR % and actual cost).

MethodSW 3D-M (10)Inv. 3D-M (10)Inv. Asm. (10)ACAD 2D-S (10)Overall SR (%)Traj. Time (s)Tokens (k)
GPT-5 (GUI)0.00.00.010.02.53,500700.0
GPT-5 (COM, few-shot)40.070.060.060.057.545045.0
Ours 9B (COM)80.090.090.090.087.51007.5

Table R5. Matched-token comparison (170k tokens/task, 40 tasks; SR % and actual cost).

MethodSW 3D-M (10)Inv. 3D-M (10)Inv. Asm. (10)ACAD 2D-S (10)Overall SR (%)Traj. Time (s)Tokens (k)
GPT-5 (GUI)0.00.00.00.00.0300167.5
GPT-5 (COM, few-shot)40.060.050.060.052.545042.5
Ours 9B (COM)80.090.090.080.085.0906.5

With all step and revision caps removed, COM still significantly outperforms GUI under both matched resource budgets. Detailed results are added in Appendix E.1 (Tables 13–14).


Response to Q1: Evaluator scope & Assembly checks

Beyond surface geometry, the evaluator checks whether engineering drawings contain all required views and annotations, and verifies mass-property and interference-detection outputs element by element against the ground truth.

For assembly tasks, we use Chamfer distance to measure agreement between the final assembly and ground-truth geometry without checking joint types or remaining degrees of freedom (DOF). Even so, Chamfer distance already captures the performance differences between models. As shown in Table R6, we checked native joint types and remaining DOF on 20 assemblies across two models. Each model's success rate changes by at most 5.0 percentage points, and relative rankings remain unchanged.

Table R6. Native joint-type and DOF verification.

ModelGeometry OnlyGeometry + Native Joint & DOFGeometry RankNative-Check Rank
GPT-5 (few-shot)55.050.0#2#2
Ours 9B85.085.0#1#1

Detailed results are added in Appendix E.6 (Table 20).


Response to Q2: First-attempt success & revision recovery

Thank you for the suggestion. Table R7 reports the first-attempt success rate and revision recovery rates for three representative models under the same revision budget (full results are added in Appendix E.7 (Table 21)). For our agent, 74.2% of tasks succeed on the first attempt, 30.0% of initial execution failures are recovered, and 3.7% of initial artifact mismatches are recovered.

Table R7. First-attempt SR and revision recovery rates.

ModelFirst-Attempt SRFinal SRRecovery: Exec. ErrorRecovery: Artifact MismatchOverall Recovery
GPT-5 (few-shot)38.043.512.52.38.9
Qwen3.5-9B (few-shot)12.514.82.71.62.6
Ours 9B74.279.130.03.719.0

Most recovery gains come from fixing execution errors using terminal feedback, whereas silent artifact mismatches without error signals remain harder to correct.


Thank you again for your detailed review and encouraging remarks. We hope these additional controls and analyses address your questions, and we would greatly appreciate your consideration in raising your score.

Best regards, The Authors

Reviewer_4rMZOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes ComAct, which lets agents operate commercial software by generating Python programs that invoke COM interfaces. It introduces ComCADBench, a set of 1,000 tasks across SolidWorks, Inventor, and AutoCAD, and ComForge, a parallel Windows execution platform. A 9B agent is trained in three stages: instruction-to-code learning, multi-turn correction, and optimization with geometric rewards. The trained agent performs strongly on CAD tasks, particularly multi-stage workflows.

Critical strengths
  1. A valuable problem and benchmark. Professional CAD software requires precise operations and produces artifacts that can be checked against task requirements. Evaluating generated work inside three commercial applications is a useful contribution.

  2. A coherent training pipeline. COM programs provide direct software control, execution feedback supports correction, and geometric rewards address cases where code runs but creates the wrong artifact. The stage ablations show incremental gains on the evaluated single-task categories.

Critical weaknesses
  1. The GUI–COM comparison is difficult to interpret under different action budgets. GUI baselines receive up to 35 actions, while one COM program can contain many API calls. The additional 100-step GUI test is useful, but it does not fully establish how much of the gap comes from the interface rather than the number of operations needed to finish a CAD task. Comparisons under matched time, token, or execution-cost budgets would strengthen the paper’s central claim.

  2. The benchmark may not adequately represent open-ended engineering requests. Some instructions are generated from structured CAD data and specify exact coordinates and geometric parameters; multi-stage tasks are formed by composing individual tasks. These choices enable precise evaluation, but may emphasize translating detailed specifications into COM scripts. The paper reports human review of only a subset of generated instructions and provides limited evidence on less fully specified engineering tasks.

Questions for authors
  1. Could the authors compare GUI and COM agents under matched total time, token, or execution-cost budgets? For the enhanced 100-step GUI baseline, where do failed trajectories typically stop, and how far are they from completing the task?

  2. What proportion of generated instructions received human review? Could the authors evaluate on requirements written independently by engineers, without textualizing structured CAD models?

  3. Table 5 ablates training stages mainly on single-task categories. Could the authors report the same stage-by-stage results on complete multi-stage workflows to substantiate the claimed long-horizon gains?

2 comments

Dear Reviewer 4rMZ,

Thank you for your constructive feedback and for recognizing our work as a valuable problem and benchmark with a useful contribution. Below are our point-by-point responses to your concerns.


Response to W1 & Q1: Matched-budget comparison & GUI failure analysis

Combining multiple CAD operations into one script is a key advantage of COM. Rather than selecting objects, entering parameters, and confirming step by step, COM specifies geometry and execution order directly in code. Also, our 35-turn GUI budget counts turns (1 to 3 atomic actions per turn), and extending it to 100 steps with GPT-5.4 + SoM still yields 0.0% SR. This shows that visual grounding errors and error accumulation, not step limits, are the main bottleneck.

To compare both paradigms under equal resources, we ran matched-time (60 min/task) and matched-token (170k tokens/task) evaluations on 40 single tasks (10 per category) from identical initial states, removing all turn and revision caps (Tables R1 and R2).

Table R1. Matched-time comparison (60 min/task, 40 tasks; SR % and actual cost).

MethodSW 3D-M (10)Inv. 3D-M (10)Inv. Asm. (10)ACAD 2D-S (10)Overall SR (%)Traj. Time (s)Tokens (k)
GPT-5 (GUI)0.00.00.010.02.53,500700.0
GPT-5 (COM, few-shot)40.070.060.060.057.545045.0
Ours 9B (COM)80.090.090.090.087.51007.5

Table R2. Matched-token comparison (170k tokens/task, 40 tasks; SR % and actual cost).

MethodSW 3D-M (10)Inv. 3D-M (10)Inv. Asm. (10)ACAD 2D-S (10)Overall SR (%)Traj. Time (s)Tokens (k)
GPT-5 (GUI)0.00.00.00.00.0300167.5
GPT-5 (COM, few-shot)40.060.050.060.052.545042.5
Ours 9B (COM)80.090.090.080.085.0906.5

Under both matched budgets, COM achieves much higher success rates with far less time and fewer tokens, confirming that the gap comes from the interface rather than the action budget.

Failure analysis. GUI baselines consistently stop early, e.g.:

  • Switching across menus, workbenches, or commands before drawing the first valid shape or placing the first part;
  • Entering the right command but getting stuck on plane selection, endpoint clicks, dimension input, or confirmation, leaving a partial sketch or an unconstrained part;
  • Selecting the wrong object after one simple feature or constraint and failing to recover;
  • Completing a few steps with partial geometry while still missing key features or constraints.

Over 70% of failed runs stop before completing a single valid feature or constraint, far from final modeling and export. Full results and failure cases are added in Appendix E.1–E.2 (Tables 13–14, Figure 9).



Response to W2 & Q2: Human review & Open-ended engineering tasks

Our CAD tasks are drawn from established real-world datasets of human designs (Text2CAD, SketchGraphs, and Fusion360 Gallery), reflecting real industrial design complexity. Keeping exact geometric parameters enables reproducible automatic evaluation and RL training. Even with detailed specifications, models must still perform 3D spatial reasoning, compose complex COM APIs, and fix execution errors rather than simply translating text into scripts.

Human review. We screened generated instructions during dataset construction and estimated from our logs that about 90 instructions across all 7 task categories underwent manual review for geometric consistency and engineering phrasing. Of these, 94.4% (85/90) passed directly, and ambiguous cases were excluded.

Open-ended engineering tasks. We asked two engineers to independently write 3 open-ended tasks without textualizing structured CAD models: pillow-block bearing modification, 2 mm valve gasket design, and gear oil pump core assembly. Each method was given up to 60 minutes per task, and final artifacts were verified item by item by engineers. A task counts as successful (SR) only when all required criteria are met, and we also report the requirement completion rate (CR) in Table R3.

Table R3. Results on 3 engineer-authored open-ended tasks (60 min/task; SR / CR % and actual cost).

MethodBearing Edit (1)Gasket & Pump Asm. (2)Overall SR / CR (%)Traj. Time (min)Tokens (k)
GPT-5 (GUI)0.0 / 50.00.0 / 20.00.0 / 30.060900
GPT-5 (COM)100.0 / 100.00.0 / 50.033.3 / 66.734240
Ours 9B (COM)0.0 / 60.00.0 / 25.00.0 / 36.723230

On these open-ended tasks, COM still clearly outperforms GUI in success rate, completion rate, and efficiency. In addition, Table 3 (WindowsAgentArena and ProSoftArena) and Table 4b (out-of-domain CADPrompt) further support the effectiveness of ComAct on unstructured instructions. Full tasks and results are added in Appendix E.3 (Table 15, Figure 10).


Response to Q3: Multi-stage workflow ablation

Thank you for the suggestion. We report the stage-by-stage ablation on complete multi-stage workflows in Table R4, where a workflow counts as successful only if all subtasks pass. Stage 1 generates the full workflow in one turn, while Stages 2 and 3 are evaluated under the same 5-revision budget, reporting both first-attempt and final success rates.

Table R4. Stage-by-stage ablation on complete multi-stage workflows (first-attempt / final SR, %).

Stage3D-M+E3D-M+D3D-M+MPAsm.+IDOverall SR (%)
Stage 162.7 / -39.2 / -56.8 / -60.0 / -54.7 / -
+ Stage 265.0 / 77.745.0 / 57.260.0 / 69.265.0 / 74.558.8 / 69.7
+ Stage 370.0 / 81.050.0 / 61.065.0 / 72.070.0 / 80.063.8 / 73.5

Stage 2 improves over Stage 1 across all workflow categories, and multi-turn revision brings additional gains over the first attempt. Although Stage 3 RL is trained only on single-task geometry, its improvements still transfer to complete multi-stage workflows. We have added these results to Appendix E.4 (Table 16).


Thank you again for your helpful feedback, which has strengthened our paper. We hope our responses address your concerns, and we would greatly appreciate your consideration in updating your score.

Best regards,

The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.