acceptodds
Under review as a conference paper at ICLR 2027

MOVI-Agent: Learning Queryable Software Models from Instructional Videos for Professional GUI Automation

Abstract

Vision-language model (VLM) based agents can operate everyday applications through their graphical user interfaces (GUIs), yet they break down on professional software such as Darktable and KiCad, where dense panels, strict operational ordering, sparse on-screen guidance, and heavy domain terminology demand knowledge that pre-training does not supply. We present MOVI-Agent, a training-free agent that learns how a program works before operating it. From instructional videos it compiles a persistent, queryable software model: a function tree of what the software can do, a state graph of how its interface states connect, and an action database of how each demonstrated step is performed. Execution then becomes structured navigation over this model, and a semantic state backtracking mechanism rewinds to the last verified state whenever it drifts off track. We further construct ProbeGUI, a diagnostic benchmark for professional desktop software: 86 tasks in ten applications with step- and subtask-level error attribution, multi-path matching that credits alternative valid routes, and quantified recovery from injected errors. On ProbeGUI, no baseline exceeds task success; MOVI-Agent more than triples the task success of its GPT-5.4 backend ( to ), surpasses the strongest baseline on all four metrics with significant step- and subtask-level margins, and recovers from of injected errors. A matched control that receives the same videos as flat text shows where structure matters: it leaves step accuracy within 2.3 points but raises task success from to and error recovery from to .

Primary area:
applications to robotics, autonomy, planning
Keywords:
GUI Agents, Multimodal Planning, Error Recovery, Benchmarks and Evaluation, Graph-Based Reasoning

Reviews

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

This paper proposes MOVI-Agent, a training-free GUI agent that constructs a persistent, queryable software model from instructional videos. The model comprises a function tree, a state-transition graph, and an action database, which support planning, navigation, and action retrieval. A multi-role execution framework incorporates visual grounding and semantic state backtracking to handle execution errors. The paper also introduces ProbeGUI, an annotation-driven benchmark containing 86 tasks across ten professional desktop applications, with evaluation at the step, subtask, task, and error-recovery levels. Experiments report improvements over existing baselines.

Critical strengths
  1. The paper addresses the difficulty of operating professional software, where agents often lack application-specific knowledge. Organizing instructional-video knowledge into a function tree, state graph, and action database provides a framework for connecting high-level planning with concrete GUI operations without fine-tuning.
Critical weaknesses
  1. Lack of evaluation on open-source established benchmarks. All experiments are conducted on the newly proposed ProbeGUI benchmark. It therefore remains unclear whether the gains generalize beyond its specific task construction and evaluation metric. Evaluation on an open-source benchmark, such as osworld, with comparable access to instructional demonstrations, would strengthen the evidence for the approach’s broader applicability.
  2. Limited evidence of generalization to new workflows. Section 4 reports that only 8.1% of demonstration–evaluation pairs differ in workflow structure. The evaluation therefore provides limited evidence that the learned software model can combine knowledge from different demonstrations to solve unseen workflows. Such an evaluation would more directly support the central claim of learning reusable software knowledge.
  3. The three-part representation needs stronger justification. Table 2 does not isolate the function tree, state graph, and action database, leaving unclear whether graph navigation adds value beyond action retrieval.
  4. Completion checks under state abstraction are unclear. Since state descriptions omit personalized inputs (§3.2), how does state matching (§3.3) distinguish correct completion from a similar screen containing incorrect task-specific values?
  5. The motivation needs a clearer visual illustration. Figure 1 explains the overall framework, but does not clearly illustrate why the proposed software model is needed. A motivating example showing where existing agents fail and how the function tree, state graph, and action database address those failures would make the design rationale more convincing.
Questions for authors

see weakness

2 comments
AuthorsOpenReview ↗

The state graph supplies the next step that action retrieval misses (1/2)

Thank you for the concrete questions, especially on completion checks under state abstraction. An overview of the five answers:

  • 1. Broader applicability (W1): the gains replicate on a second backend and in a second harness; an equal-access OSWorld comparison first needs a tutorial corpus.
  • 2. New workflows (W2): on the workflow-change tasks, MOVI completes 17 of 28 subtasks before its first failure, versus 12 for both baselines.
  • 3. Why three parts (W3): in 321 of 426 decisions, the state graph's next operation was absent from the retrieved examples.
  • 4. Completion under abstraction (W4): the graph matches the place; the Reflector checks the task on the live screen.
  • 5. Motivating example (W5): in Zettlr, both baselines search the wrong menu, while the model links the function to its entry point.

1. Broader applicability (W1): the gains replicate on a second backend and in a second harness. On ProbeGUI, MOVI leads on GPT-6.1-sol (44 tasks vs. 36 for direct prediction and 30 for OS-Symphony), and OS-Symphony itself completes 10 more tasks (+11.63 pp) when it queries the software model. For the OSWorld comparison with comparable access to demonstrations that you suggest, tutorials must first be assembled for its applications and given to every method: its applications (office suite, browser, mail, media, image and code editors) do not overlap ProbeGUI's ten, and its tasks come without tutorials. ProbeGUI complements OSWorld's end-state checks by pairing each task with a tutorial and scoring intermediate actions, so it shows where an agent first went wrong.

2. New workflows (W2): MOVI completes five more subtasks before its first failure than either baseline. On the seven tasks labeled as workflow changes in Section 4, GPT-5.4 MOVI made 87/118 correct decisions on observations shared by both systems, versus 76/118 without video (+9.32 pp). With GPT-6.1-sol, 116 observations were shared by all three systems on those seven tasks:

Workflow-change subsetCorrect actions on shared observationsSubtasksSubtasks before first failureTasks
MOVI106/11621/2817/283/7
Direct model98/11616/2812/282/7
OS-Symphony96/11618/2812/282/7

We also traced retrieved examples back to their tutorial videos across all 86 GPT-6.1-sol tasks. In 11 tasks, examples from different videos reached different decision steps and matched the actions accepted at those steps, and 8 of those tasks succeeded: a single execution drew on more than one demonstration.

AuthorsOpenReview ↗

The graph matches the place, and the agent checks the task on the live screen (2/2)

3. Why a function tree, a state graph and an action database (W3): each answers a different question. The function tree selects which function to perform, and the action database retrieves how a similar action was performed. The state graph answers a third question: from this interface state, which transition leads toward the selected function, and what follows it? Similarity rank is not execution order. Of 426 decisions where the graph supplied a next operation, its recorded action text was absent from the three retrieved examples in 321. Even when both adjacent operations had unique full-text matches in retrieval, the later one ranked ahead of the current one in 14 of 39 cases. The graph thus supplies an ordered continuation that retrieval alone does not.

Table 2's "w/ Video Description" variant keeps all four MOVI roles and receives the same videos as procedural text, which can describe several steps at once. The full model leads it on every metric, by 4.7 points in task success (15.1% to 19.8%) and 8.3 points in error recovery (54.2% to 62.5%).

4. Completion under state abstraction (W4): the graph matches the place, and the agent checks the task. Section 3.2 represents what the interface lets a user do, not which personalized value happens to be in a field, so two property panels with different values map to the same node. At execution time, the Reflector sees the actual screenshot and the task instruction; it checks for visible contradictions and can ask the Executor to correct one instead of following the next graph step. Reaching a reference node is not itself a completion decision.

In Logisim-4, the instruction required a tunnel labeled in1 instead of a standard wire. The circuit editor was the right interface, but the screenshot showed a wire connecting IN1 directly to the AND gate. The Reflector flagged that violation and requested removal, and the Executor issued Ctrl+Z, the accepted recovery action. The same check applies to a numeric value: in Logisim-1, the Reflector noticed a gate width of 2 against one-bit connections and the visible "Incompatible widths" warning, and the agent changed Data Bits to 1. In both cases the check used concrete screen content that the reusable graph node intentionally leaves out.

5. Motivating example (W5): the screen shows which menus exist, but often not where a function lives. In Zettlr, both direct GPT-6.1-sol and OS-Symphony looked under Edit to create a snippet. MOVI linked the requested function to Assets Manager, then Snippets, and issued the accepted shortcut for opening the manager. The software model supplies that application-specific link between a goal and its entry point, while the screenshot tells the agent how to act here and now. As you suggest, the revised version will add this Zettlr case to Figure 1 as a motivating panel.

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

This paper proposes MOVI-Agent, a training-free GUI agent that converts instructional videos into a software model with three layers, and queries these layers at run time for planning, navigation, action retrieval, and semantic backtracking. The authors also introduce ProbeGUI, an offline benchmark of 86 tasks over ten professional desktop applications, annotated with multi-path matching, failure attribution, and error injection. The authors choose GPT-5.4 as the backend, and the task success rises from 5.8% to 19.8% under the benchmark's scoring protocol.

Critical strengths
  1. The authors raise a practical problem with a clean system design. Learning reusable software knowledge from instructional videos is worthwhile, and the three-layer representation with one dedicated query per layer is a sensible design. Under the reported protocol, the gains in step accuracy and subtask success over every external baseline are statistically significant.
  2. The authors propose a benchmark with diagnostic value. ProbeGUI combines multi-path matching, failure attribution, and an independent error-recovery test, so it carries information beyond a binary task success rate and is useful in its own right.
Critical weaknesses
  1. The structured software model lacks a matched control. In Table 16 the full model's differences from the flat-description variant are non-significant on all four metrics, with task success at 19.8% versus 15.1%. The flat variant uses only the video description retrieved for the current task and also drops state anchoring and backtracking, so the two differ in knowledge content as well as in representation and execution mechanism. The comparison therefore cannot separate gains from broader knowledge coverage from gains from the structured organization itself.
  2. Demonstrations and test tasks are too close to establish transferable software knowledge. Of the 86 demonstration-task pairs, only 25 (29.1%) differ in function and 7 (8.1%) in workflow, while 85 (98.8%) differ in parameters; each application is pinned to one version at one recording resolution, and transfer across versions or window geometry is never tested. Once the function- and workflow-differing pairs are set aside, most tasks amount to redoing the demonstration with different arguments: retrieving the demonstration's step sequence and substituting parameters would already earn a substantial share of the score without any transferable software model. The current results cannot rule out this explanation.
  3. The masked-demonstration ablation shows that demonstrations help, but not how much. Masking the paired demonstration drops task success from 19.8% to 14.0%, exactly the figure of the strongest baseline, OS-Symphony, while step accuracy and subtask success stay higher, so the advantage is not attributable to the paired demonstration alone. But the variant retains knowledge from the application's other demonstrations; it is neither 'no relevant knowledge' nor 'a substantially different task', so it measures neither the size of the demonstration contribution nor a lower bound on generalization. Since the full model's task-success gap over the variant is itself non-significant (roughly 17 tasks versus 12), it cannot be separated from sampling noise.
  4. Offline scoring and single runs do not establish live execution. The authors already state that ProbeGUI uses continue-on-miss, so scores characterize execution along annotated trajectories rather than unrestricted live success. That limitation is never quantified: in a real interface an incorrect action compounds, and semantic backtracking is never exercised on a genuine deviation. With one run per task, gaps of about five tasks, such as 19.8% versus 14.0%, cannot be distinguished from decoding stochasticity.
Questions for authors
  1. Clarify the recovery counts. Table 15's three groups contain 5, 20, and 6 recovered episodes, summing to 31/48 (64.6%), whereas Tables 1 and 16 report 30/48 (62.5%). Both are exact integers (48 x 0.625 = 30; 26/38 = 68.4%, consistent with 31 recovered episodes), so this is not a rounding difference. Which count is correct, and which enters the significance test?
  2. Test generalization. Can the authors report results on the function-difference and workflow-difference subsets, and ideally on tasks, videos, software versions, and window sizes that are genuinely new? This directly probes W2.
  3. Quantify the demonstration contribution. Can the authors compare the structured model, flat text, and the no-paired-demonstration variant under matched accessible knowledge content? Giving OS-Symphony the same video information would further separate the roles of demonstration knowledge, structured organization, and execution framework.
  4. Quantify the offline overhead. Can a small set of tasks with verifiable end states be evaluated in a live closed loop and compared against their offline scores? Repeated runs with reported variance would also show whether the W3 and W4 gaps are stable.
2 comments
AuthorsOpenReview ↗

The recovery count is 30/48, and MOVI leads where no tutorial route can be replayed (1/2)

Thank you for the precise questions and for catching the recovery discrepancy. An overview of the four answers:

  • 1. Recovery count (Q1): 30/48 is correct and is the count tested in Table 16; the revised PDF corrects the one sentence that said 26/38.
  • 2. Generalization (Q2): 39 of the 86 tasks admit no route that follows the tutorial's actions, and Full completes 10 of them versus 4 without video.
  • 3. Demonstration contribution (Q3): where the paired video is the only source, Full leads Flat by 9.09 pp, and OS-Symphony gains 11.63 pp by querying the same model.
  • 4. Live execution and variance (Q4): 0/60 live-replay disagreements, a 5.30 pp lead under first-failure scoring, and the same winner on two backends.

1. Recovery count (Q1): 30/48 (62.5%) is correct and entered Table 16. The overcount came from counting only the first recovery checkpoint, which gives 31/48. Exactly one task differs: Logisim-5 passed its first checkpoint but failed its second, so it is not recovered. By verdict, recovery is 5/10 under on_track, 19/31 under uncertain (the cell Logisim-5 belongs to) and 6/7 under off_track, 30/48 in total. Table 15 reports these as 50.0%, 61.3% and 85.7%, and 65.8% (25/38) for the non-on_track row; the 64.6% beside 61.3% is the uncertain verdict's share of the 48 tasks, not its recovery rate. Only one appendix sentence said 26/38, and the archived bootstrap used the complete-episode outcomes, so Table 16 is unchanged.

2. Generalization (Q2): on the 39 tasks that no tutorial route fits, Full completes more than Flat or the no-video loop. Across all 86 pairs, we checked whether any complete annotated route fits the tutorial's human-labeled action types in order, ignoring values and coordinates, allowing skips and treating each missing label as one wildcard. 39/86 pairs have no such route, including 25 of the 58 parameter-only pairs. On these 39 tasks, Full completed 10, Flat 7 and the no-video loop 4 (on the 25 parameter-only ones: 8, 4 and 1).

"Parameters only" means a setting, name, input or target within the same function (Appendix C.4). In pgAdmin-3, both tasks use Create Table. The tutorial creates student with three columns (integer primary key, bit, text), and the evaluation asks for customers with two (integer primary key, text). After defining the key, the tutorial adds and configures a bit column, whereas the evaluation goes straight to the text column and saves: the procedure is the same, but the GUI actions differ.

On the function- and workflow-change subsets, the full GPT-5.4 system made 8 and 11 more correct decisions on identical recorded observations than the same four-role loop without video (the original labels overlap on four tasks):

Change (tasks)Correct actions on common observations: Full vs. no videoLead (pp)Completed subtasks: Full vs. no video
Parameters only (58)503/609 vs. 462/6096.73102/171 vs. 83/171
Function differs (25)228/300 vs. 220/3002.6736/83 vs. 37/83
Workflow differs (7)87/118 vs. 76/1189.329/28 vs. 8/28

All runs use one version and resolution per application; execution re-predicts every coordinate on the live screen rather than replaying the demonstrator's (Section 3.2).

AuthorsOpenReview ↗

With target knowledge matched, the software model leads the same videos given as text (2/2)

3. Demonstration contribution (Q3): Flat keeps MOVI's loop, and with target knowledge matched the software model leads it. Flat retains the Planner, Reflector, Executor and Grounder; it receives a retrieved description, whereas Full queries an application-wide model for functions, routes and actions. Full vs. Flat therefore tests the software model as the agent uses it, its content and structure together. Retrieved text helps the four-role loop less than it helps direct prediction:

GPT-5.4 execution frameworkNo videoRetrieved tutorial textGain from text
Direct80/264101/264+7.95 pp
Same four roles as MOVI120/264133/264+4.92 pp

To match the target knowledge, we selected all 37 tasks for which every requested function has exactly one confirmed tutorial source, the paired video. Full keeps broader application context, but the documented sources of the 110 target subtasks are the same for every configuration.

ConfigurationSubtasks on these 37 tasksConsecutive subtasksWhole tasksSubtasks on all 86 tasks
Full61/11041/1108/37139/264
Flat51/11033/1105/37133/264
Paired video withheld50/11032/1105/37118/264
No video53/11032/1106/37120/264

On these targets Full leads Flat by 9.09 pp (paired task-bootstrap 95% interval −0.85 to +19.42), four times its 2.27 pp lead over all tasks. Withholding the only source video brings Full down to the no-video level (50/110 vs. 53/110), so the demonstration accounts for 11 of these 110 subtasks. For your suggestion of giving OS-Symphony the same video information, we ran OS-Symphony on GPT-6.1-sol with the software model as a guide queried before each action: it completed 10 more tasks (+11.63 pp) and 10.61 pp more subtasks before the first failure than OS-Symphony without it, so the model's benefit does not depend on MOVI's own loop.

4. Live execution and variance (Q4): offline verdicts transfer, and the lead holds under first-failure scoring. For the 60 logged trajectories replayed in the real applications, 0/60 final verdicts disagreed with offline scoring. To size the effect of continue-on-miss, we stopped credit at the first failed subtask: Full keeps 82/264 consecutive successes versus 68/264 without video (+5.30 pp). Each configuration ran once at temperature 1, and Table 16's paired task bootstrap covers task sampling. Across the two backends we ran, MOVI leads both direct prediction and OS-Symphony in task success (GPT-5.4: 19.8% vs. 5.8% and 14.0%; GPT-6.1-sol: 51.2% vs. 41.9% and 34.9%). We will release ProbeGUI and its tutorials with task resets for closed-loop use.

Reviewer_3uyCOpenReview ↗
Rating
2
Confidence
2(−1)
Informativeness
2(+1)
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents MOVI-Agent, a training-free GUI agent that converts instructional videos into a persistent software model consisting of a function tree, UI state graph, and action database. At runtime, the agent uses this model for planning, action retrieval, visual grounding, state verification, and semantic backtracking. The authors also introduce a benchmark, ProbeGUI, with 86 tasks across 10 professional desktop applications. On ProbeGUI, MOVI-Agent improves GPT-5.4’s task success from 5.8% to 19.8% and error recovery from 45.8% to 62.5%, outperforming the evaluated baselines.

Critical strengths
  1. The paper tries to address a real limitation of current GUI agents: professional software requires persistent knowledge of functions, interface states, and domain workflows. Its explicit software model provides a reusable way to query and execute this knowledge instead of treating tutorial videos as flat context.

  2. ProbeGUI is a useful evaluation contribution. It covers 86 tasks across 10 professional desktop applications and reports different levels of metrics with multi-path matching and deterministic scoring. The matched flat-description control and component ablations help distinguish the benefit of structured software knowledge from the benefit of simply providing video-derived information.

Critical weaknesses
  1. The method relies on in-house instructional videos collected for fixed application versions and resolutions. It is unclear how much video coverage is needed, how the agent handles tasks without a closely related demonstration, and how stale software models are updated after UI or version changes. This limits the scalability and generality of the approach.

  2. The main ProbeGUI evaluation is an offline, annotation-driven simulation in which every task is paired with a related demonstration video. Incorrect actions do not change the real application, while valid but unannotated routes may be penalized. Therefore, the reported gains may not translate to live PC automation on unseen tasks.

  3. Most MOVI-Agent results use GPT-5.4 with the authors’ unified action interface. The paper does not evaluate whether the method transfers to other underlying VLMs or native agent harnesses such as Codex or Claude Code, so it is unclear whether the gains come from the software model itself or from its GPT-5.4-specific orchestration.

Questions for authors
  1. How does MOVI-Agent perform on tasks without a closely related instructional video, and how much video coverage is needed for each application?

  2. How well do the offline ProbeGUI results transfer to live execution, especially when the agent takes a valid but unannotated route?

  3. Do the gains persist with other VLM backends or native agent harnesses, rather than the GPT-5.4 setup used in the main experiments?

2 comments
AuthorsOpenReview ↗

MOVI's gain comes from tutorial knowledge, including functions taught by other videos (1/2)

Thank you for the focused questions on coverage, live transfer and backends. An overview of the three answers:

  • 1. Coverage (Q1): the full model's extra successes all fall on functions a tutorial covers; 80% of an application's coverage needs 4 to 9 of its 7 to 11 tutorials.
  • 2. Live transfer (Q2): replay in the real applications agreed with all 60 offline verdicts, including routes that differ from the reference.
  • 3. Backends and harnesses (Q3): on GPT-6.1-sol, MOVI completes 44 tasks versus 36 and 30, and OS-Symphony gains 10 tasks by querying the software model.

1. Coverage without the paired video (Q1): the gain comes from tutorial-covered functions, including those another video teaches. With each task's paired video withheld, GPT-5.4 MOVI completed 118/264 subtasks and 12/86 tasks, compared with 139/264 and 17/86 with the full corpus. We traced each subtask's target function to the remaining tutorials: for 56 subtasks, at least one other video still teaches the target operation. The table compares MOVI with the same four-role loop (Planner, Reflector, Executor, Grounder) without video guidance.

Tutorial corpusTarget functionMOVINo videoDifference (pp)
FullMapped to a tutorial function123/224104/224+8.48
FullNo catalogue match16/4016/400.00
Paired video withheldAnother confirmed source22/5618/56+7.14
Paired video withheldNo confirmed remaining source96/208102/208−2.88

All 19 net additional subtask successes of the full model occur on tutorial-mapped functions, and where no source remains, MOVI and the no-video loop are within 6 of 208 subtasks. The gain is therefore tutorial knowledge rather than orchestration. For coverage per application, we enumerated every subset of its tutorials; the table gives the smallest number whose mean coverage reaches 80% of the subtask instances covered by that application's full corpus.

AppVideos needed / availableAppVideos needed / available
Orange4/8JASP7/9
Postman6/8Logisim7/10
Zotero6/7KiCad8/9
Audacity7/8Darktable9/11
Zettlr7/8pgAdmin7/8

All runs use the recorded versions. Stored coordinates only identify the demonstrator's target, and execution re-predicts every coordinate on the live screen rather than replaying it (Section 3.2). A release that changes a workflow is handled by re-running the training-free construction on that release's tutorials.

AuthorsOpenReview ↗

MOVI leads on a second VLM, and its software model lifts another agent harness (2/2)

2. Offline to live (Q2): live replay agreed with all 60 offline verdicts. Two authors independently replayed 611 emitted actions in the real applications, checking whether each action advanced the stated goal and whether the final output satisfied the instruction, including when the screen differed from the reference. We selected three tasks per application and two trajectories per task, with a success and a failure whenever both were available. Live replay agreed with the offline verdict for all 60 trajectories, 25 successes and 35 failures (Appendix D.2).

ProbeGUI credits a different way to obey the instruction and rejects a violation of an explicit constraint. KiCad accepts either double-clicking a resistor or opening its properties from the context menu; when a Logisim tip requires editing properties from top to bottom, another order falls outside that task's specification. A route that obeys all stated constraints but is missing from the annotations is exactly the case the manual replay checks.

3. Other backends and harnesses (Q3): MOVI leads on GPT-6.1-sol, and its software model transfers to OS-Symphony. On the same 86 offline ProbeGUI tasks with GPT-6.1-sol, MOVI finished 44 tasks, versus 36 for direct prediction and 30 for unmodified OS-Symphony.

GPT-6.1-sol systemNormal actionSubtaskSequential subtaskTaskRecovery
OS-Symphony (%)82.9568.5651.1434.8868.75
Direct (%)89.3571.9754.1741.8675.00
MOVI (%)90.8476.8962.1251.1679.17
MOVI lead over direct (pp)1.494.927.959.304.17
MOVI lead over OS-Symphony (pp)7.898.3310.9816.2810.42

Sequential subtask success stops giving credit at the first failed subtask, so it separates early from late failure: MOVI completed 164/264 subtasks before its first failure, versus 143/264 for direct prediction and 135/264 for OS-Symphony.

Codex and Claude Code are built for code and terminal tasks rather than GUI actions, so we used OS-Symphony, an open GUI-agent harness with its own planning and grounding loop, as the native harness. Before each action, OS-Symphony selected a catalogue function and queried its guide from the software model; it still chose and grounded the action itself. Against OS-Symphony without the guide on the same tasks and backend, it completed 10 more whole tasks (+11.63 pp) and 28 more subtasks before the first failure (+10.61 pp); normal-action accuracy rose by 1.82 pp and independent subtask success by 4.17 pp. This gain needs no part of MOVI's four-role loop; the guide query before each action adds inference calls.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.