PaperlayerView exact revision on arXiv

Source-linked AI summary

UI-Mate: Advancing Open-Weight Foundation GUI Agents with In-Context Demonstrations

Zihan Ding, Longxu Dou, Qi Gao, Xiangwu Guo, Shengchao Hu, Zilong Huang, Zihang Jiang, Lei Ke, Mengcheng Lan, Weixian Lei, Hanxuan Li, Honglin Li, Xiyun Li, Zaitang Li, Leowei Liang, Xin Luo, Haozhe Ma, Jiayi Mao, Zhoujie Pan, Can Qin, Tianyuan Qu, Weiqi Wang, Wenkai Wang, Yonglin Wang, Yuxin Wang, Chenxu Wu, Yingchen Yu, Chenyu Zhang, Yuhao Zheng

arXiv:2608.15930v1cs.AIcs.CV

TL;DR

GUI agents still face training-data and interaction bottlenecks that limit reliable deployment. UI-Mate combines environment-grounded training with adaptive in-context demonstrations, achieving 41.0% strict success on OSWorkerBench and improving long-horizon execution with demonstrations.

  • Problem

    GUI-agent progress is limited by scarce executable, verifiable, capability-diverse training data and instructions that omit user-specific procedures.

  • Method

    UI-Mate combines a closed-loop environment-grounded training pipeline with adaptive subtask-level workflows derived from multimodal demonstrations.

  • Results

    UI-Mate-27B advances open-weight computer use and achieves 41.0% strict success on OSWorkerBench, improving over Qwen3.6-27B by 17.7 percentage points.

  • Takeaways & Limitations

    Demonstrations substantially improve the consistency and reliability of long-horizon GUI execution.

  • Takeaways & Limitations

    The 45-task variant-demo setting lacks a systematic aggregate result because performance was not yet sufficiently stable for a main benchmark claim.

Abstract

from arXiv · show

Foundation GUI agents can automate complex digital tasks, but deployment is hindered by scarce and biased training data, ambiguous prompts, and unreliable execution. Routine workflows rely on user-specific tools and tacit conventions, so unstated instructions can produce arbitrary variations across runs. We present UI-Mate, a foundation GUI agent that integrates an environment-grounded training stack with in-context demonstration learning. UI-Mate makes three contributions: A Scalable Environment-Grounded Training Stack: A closed-loop data engine automates task generation, environment construction, rollout, filtering, capability balancing, SFT, and online RL across massively parallel environments via unified task-verifier bundles. In-Context Demonstration Learning: A mechanism that transforms multimodal demonstrations into flexible subtask-level workflows, follows relevant demonstrated steps, and re-plans from the live interface. OSWorkerBench Benchmark and Insights: A benchmark of 100 long-horizon office tasks across 41 applications that supports instruction-only and demonstration-guided evaluation. Its demonstration resources separate a 33-task self-demo setting, built from successful strong-agent rollouts of the same targets, from a 45-task variant-demo setting, built from human recordings of related but non-identical tasks. Experiments show that UI-Mate-27B sets a new open-weight state of the art on general computer-use benchmarks, scoring 77.0% on OSWorld-Verified and 66.2% on WindowsAgentArena. On OSWorkerBench, it reaches 41.0% strict success and 76.9% progress, outperforming its Qwen3.6-27B base by 17.7 and 24.5 points. On the 33-task self-demo subset, one demonstration raises strict success from 17.2% to 35.4% and progress from 67.9% to 81.1%, substantially improving long-horizon reliability. Project page: https://ui-mate.github.io.

1 Introduction

UI-Mate addresses training and interaction bottlenecks in foundation GUI agents through environment-grounded training and adaptive in-context demonstrations. It introduces OSWorkerBench to evaluate long-horizon office work and reports strong open-weight benchmark performance and improved execution with demonstrations.

  • Contributions: UI-Mate combines environment-grounded training with in-context demonstration learning to address scalable data generation and underspecified procedural intent.Its training pipeline jointly constructs tasks and executable environments, filters rollouts, diagnoses capability coverage, and supports SFT and online RL; demonstrations become adaptive subtask workflows rather than rigid replays.
  • Benchmark: OSWorkerBench introduces 100 long-horizon office tasks spanning 41 normalized applications and 10 job families, with controlled instruction-only and demonstration-guided evaluation.The benchmark includes Long-Memory and Multi-App task categories, while paired comparisons hold the target instruction, initialized environment, interaction budget, and verifier fixed.
  • Results: 77.0% on OSWorld-Verified and 66.2% on Windows Agent Arena are achieved by UI-Mate-27B, establishing the strongest open-weight results among the compared systems.These results are reported alongside evaluation on OSWorkerBench and a demonstration-guided OSWorld-Verified subset.
  • Results: 41.0% strict success and 76.9% progress on OSWorkerBench improve over the Qwen3.6-27B base model by 17.7 and 24.5 percentage points, respectively.The two improvements correspond directly to strict success and progress in that order.
  • Results: 65.8% average task score with one demonstration rises from 40.3% on a 30-task OSWorld-Verified subset, indicating substantially improved long-horizon execution reliability.The comparison changes demonstration availability while keeping the evaluation task setting otherwise comparable.

2 Overview

UI-Mate formulates computer use as verifier-based interaction with an operating-system environment and extends it with state-grounded, subtask-level demonstration workflows. Its overview connects environment-grounded data and training, DemoCUA, OSWorkerBench, and a shared execution harness into one agent lifecycle.

  • General computer use: A computer-use task pairs a natural-language instruction with an environment containing an operating system, installed applications, and user files.The agent operates directly in this environment.
  • General computer use: Each decision turn uses the instruction, bounded recent history, and screenshot observation to emit one or more consecutive actions.Interaction length is measured in decision turns, and execution ends with a terminal action or exhausted step budget.
  • General computer use: Task success is determined by an executable verifier inspecting the final environment state and returning the binary outcome R(τ) ∈{0, 1}.The agent optimizes the expected verifier outcome rather than relying on the trajectory alone.
  • Demonstration-guided computer use: Demonstrations are segmented into subtasks with goals, completion criteria, and advisory visually grounded action descriptions, while the live screenshot retains veto power over suggested steps.A subtask_complete action advances the workflow pointer only when the observed screen satisfies the current completion criterion.
  • UI-Mate system overview: UI-Mate combines an environment-grounded data pipeline, general computer-use training, DemoCUA, OSWorkerBench, and a unified harness for training, procedural adaptation, evaluation, and deployment.OSWorkerBench contains 100 long-horizon office tasks across 41 applications, with 33 self-demo targets and 45 human-recorded variant-demo targets.

3 Data Pipeline

UI-Mate builds a closed-loop data pipeline that converts diverse instructions into executable, realistic environments and uses validated rollouts, capability coverage, and human trajectories to improve training data. For reinforcement learning, capability-guided sampling and configuration synthesis jointly scale behavioral diversity, interaction contexts, and difficulty while preserving executability and reward reliability.

  • Instruction Curation: Four complementary instruction sources balance realism from everyday user tasks with systematic coverage of the agent’s functional surface.Sources include open-source computer-use datasets, atomic subtasks, and additional task-generation mechanisms.
  • Environment Construction: Each instruction becomes a runnable environment through LLM-generated setup code that creates or retrieves resources and configures the operating system, applications, and task state.Real documents, presentations, spreadsheets, images, videos, audio, and websites reduce synthetic artifacts and better reflect irregular working materials.
  • Rollout Quality: Two-stage trajectory filtering checks task and environment validity before evaluating step-level outcomes against expected deliverables and visible state transitions.Multimodal judging rejects ambiguous or infeasible tasks and retains trajectories only when rollout evidence supports the required deliverables.
  • Capability Balancing: A hierarchical capability taxonomy maps tasks to application, coarse-capability, and fine-grained-operation levels, enabling coverage-gap detection, targeted generation, and consistent data allocation.A separate cross-application domain captures behaviors such as transferring and transforming information between applications.
  • Human Data Integration: Human-annotated trajectories complement automated rollouts by capturing natural interaction patterns and long-tail behavior, then undergo validation, observation repair, and rollout-aligned relabeling.Teacher-generated descriptions and reasoning follow the rollout interface while human action parameters remain fixed, with consistency and leakage checks applied.
  • RL Data Scaling: Capability-guided sampling and configuration synthesis couple instruction scaling with environment construction, adding capabilities, interaction contexts, and difficulty rather than paraphrases or noisy rewards.This coupled design preserves the executability and reliability required for reinforcement-learning-from-verifiable-rewards data.

4 Training UI-Mate for General Computer Use

UI-Mate is trained with supervised fine-tuning on verified, capability-balanced trajectories, followed by agentic reinforcement learning in verifiable GUI environments. The two-stage stack develops executable GUI interaction and improves long-horizon planning, state tracking, error recovery, and task completion.

  • Training stages: SFT equips UI-Mate to produce executable protocol responses, ground semantic targets to screen coordinates, and select actions from screenshots and interaction history.
  • Agentic RL: Agentic RL optimizes task-level success through online interaction in verifiable environments rather than action imitation.The pipeline combines adaptive task sampling, grouped rollouts, verifier-based credit assignment, and asynchronous GRPO updates.
  • Training data: SFT retains only trajectories whose required outcomes pass step-level verification, then balances coverage across applications, capability levels, and task lengths.The resulting mixture spans atomic operations, single-application workflows, and cross-application tasks, with and without explicit intermediate reasoning.
  • Agentic RL: Decision-turn centering corrects trajectory-length bias by centering advantages under the decision-turn measure without dividing by group standard deviation.This preserves reward scale and avoids unstable amplification when group outcomes are nearly uniform.
  • Agentic RL: Optional PCM uses teacher annotations to concentrate learning on informative decisions, rewarding progress and recovery while penalizing causal errors, failed corrections, redundancy, and blocked steps.It is applied only when a task group contains at least one verified successful trajectory; otherwise training follows the outcome-only path.

5 DemoCUA: Learning from In-Context Demonstrations

DemoCUA converts recorded desktop executions into subtask-level workflows with goals and verifiable completion criteria, then uses them as adaptive guidance grounded in live screenshots rather than scripts. Its training design prevents blind workflow copying by exposing incomplete demonstrations and mismatched workflow–screen relationships.

  • Demo acquisition and representation: Demonstrations are normalized, vision-language annotated, and segmented into coherent subtasks with goals and explicitly checkable completion criteria.Self-demos come from successful stronger-agent rollouts on identical tasks, while variant-demos are human recordings of related but non-identical tasks.
  • Demo usage: At inference, the harness summarizes completed, current, and upcoming subtasks while omitting coordinates and low-level actions, requiring adaptation to the live interface.The agent marks each subtask complete before advancing to the next.
  • Training against shortcut learning: Demo-augmented training combines full-alignment and partial-misalignment workflows so the model learns to correct demonstrations when they diverge from the current screen.Incomplete workflows omit intermediate actions such as focus clicks, scrolling, and popup dismissal, while retaining the full trajectory as supervision.
  • Runtime example: 323 demonstration actions are segmented into 7 subtasks in the Godot timer-and-bullet-firing example, whose episode takes 289 steps overall.At runtime step 105, subtask 4 of 7 is current, and the agent declares it complete at step 106.
  • Limitations: The workflow’s placement at the beginning of context invalidates the shared prefix after each subtask update, preventing efficient KV-cache reuse.Future work proposes moving the workflow to the end so context grows append-only and cache reuse continues throughout the episode.

6 OSWorkerBench: Realistic Cross-Application Office Workflows with Multimodal Demonstrations

OSWorkerBench is a 100-task benchmark spanning 41 applications that evaluates realistic cross-application office workflows under instruction-only and demonstration-guided protocols. Its construction combines capability-grounded synthesis, executable checkpoint evaluators, human verification, and separate self-demo and variant-demo resources.

  • Benchmark scope: 100 realistic office tasks span 41 normalized applications and 10 consolidated job families, with 67 Long-Memory and 49 Multi-App capability subsets.All tasks support instruction-only evaluation; the Multi-App subset additionally requires dynamic information transfer across applications.
  • Benchmark construction: Capability-grounded synthesis builds workflows from verified executable and observable application functions while controlling breadth, depth, and reasoning difficulty.Difficulty increases multiple dimensions jointly through applications, information transfers, access points, records, distractors, branches, dependencies, and estimated human-reference horizon.
  • Evaluation design: Checkpoint-based evaluators measure functional outcomes using record checks, prerequisite gates, and weighted business outcomes rather than reference-trajectory imitation.Evaluators are tested on untouched, golden, partial, and negative terminal states, then reviewed with representative agent executions and revised when mismatches occur.
  • Demonstration settings: 33 same-task strong-agent rollouts form the self-demo setting, while 45 human recordings of related but non-identical tasks form the variant-demo setting.Self-demos preserve screenshots and action types while omitting concrete pixel coordinates; variant demos test intermediate-state retention, stage ordering, and cross-application handoffs.
  • Cross-application breadth: 99 tasks require at least two applications, 68 require three or four, and the mean is 3.26 applications per task, with a maximum of 7.Slack appears in 65 tasks, followed by Gmail in 34, Google Sheets in 31, Salesforce in 23, and Google Calendar in 19.

7 Evaluations

UI-Mate achieves competitive open-weight performance across general computer-use, WindowsAgentArena, and OSWorkerBench evaluations, with especially strong gains on long-horizon workflows. Scaling primarily improves application-level coordination, while late-stage omissions remain a key failure mode.

  • General computer-use benchmarks: 77.0% average OSWorld-Verified score places UI-Mate-27B above Kimi-K2.6 (73.1%) and Qwen3.7-Plus (73.3%), while approaching GPT-5.5 (78.7%).It also exceeds ScaleCUA-Qwen3.5 (68.7%), EvoCUA-32B (56.7%), and UI-TARS-1.5 (25.4%).
  • WindowsAgentArena: 66.2% task success makes UI-Mate-27B the strongest open-weight WindowsAgentArena agent, exceeding Kimi-K2.6 (63.3%) by 2.9 percentage points.It trails Claude Sonnet 4.8 (69.3%) by 2.6 points and GPT-5.5 (70.4%) by 4.2 points.
  • OSWorkerBench: 41.00% overall binary success and 76.86% progress improve over Qwen3.6-27B by 17.67 and 24.51 percentage points, respectively.At 9B, UI-Mate improves binary success from 5.05% to 34.00% and progress from 18.11% to 66.55%.
  • Long-horizon workflows: 28.57% Multi-App success and 32.84% Long-Memory success surpass Qwen3.6-27B (7.48% and 12.94%) and Kimi-K2.6 (18.37% and 25.37%).UI-Mate-27B’s median trajectory contains 71 decision turns, and 40 trajectories extend to at least 100 turns.
  • Limitations and evaluation resources: A 35.86-percentage-point gap between progress and binary success indicates substantial partial progress, with late-stage omissions such as missing fields or final notifications remaining important failures.The benchmark also includes a separate 45-task variant-demo resource and a 10-task pilot, while GameDev adds 10 tasks averaging more than 200 human actions.

8 UI-Mate App

UI-Mate App turns a configured vision-language model into a desktop computer-use agent that observes screens, executes mouse and keyboard actions, and records demonstrations without requiring application plugins or APIs. Its modular architecture supports configurable serving, live run control, workflow-guided execution, and platform-specific desktop bridges.

  • Core functionality: UI-Mate drives applications directly through mouse and keyboard, requiring no plugin, API, or scripting interface for installed applications.It also records demonstrations for in-context learning in the same environment.
  • Architecture: The application contains no model and sends OpenAI-format requests to a configured endpoint, while a separate harness handles prompting, action selection, and completion judgement.The frontend, backend, harness, and platform-specific bridge form four architectural layers connected by JSON-line events.
  • Demonstration workflows: A native recorder and Demo2Workflow convert user demonstrations into editable workflows grouped into named subtasks that guide later autonomous runs.Guided runs provide workflow progress and recorded steps for the current subtask, and the agent advances the workflow when it reports subtask completion.
  • Serving: About 45 s to 10–20 s is the typical step-time reduction from six-bit 9B on-device serving, 720p captures, prompt-prefix reuse, and cached image features.Self-hosted QuaRot-style W8A8 quantization and speculative decoding reduce a step from 3–5 s to 2–3 s without application changes.

9 Related Work

Related work spans the evolution of computer-use agents from modular scaffolds to native end-to-end models, alongside increasingly realistic GUI benchmarks. Demonstration-guided methods provide procedural knowledge, but UI-Mate distinguishes itself by distilling demonstrations into adaptable subtask-level intent.

  • Computer Use Agents: Computer-use agents have progressed from modular planning, grounding, and reflection scaffolds toward native models that integrate perception, grounding, and action end-to-end.Native foundation agents increasingly train on large trajectory corpora and close the loop with environment interaction.
  • Computer Use Benchmarks: GUI-agent benchmarks span static grounding, offline web navigation, and interactive state-verified environments across web, mobile, and desktop operating systems.Recent suites increase realism through long-horizon workflows, dynamic mid-task events, interleaved GUI–CLI execution, trajectory auditing, scientific workflows, and professional deliverables.
  • Computer Use Benchmarks: Most standard protocols specify tasks through instructions and environment artifacts without explicitly controlling demonstration availability for the same target.This limitation motivates benchmark settings that distinguish instruction-only evaluation from demonstration-guided evaluation.
  • Demonstration-Guided Computer Use: Demonstration-guided computer use ranges from brittle fixed-sequence RPA to procedural representations with parameterization, composition graphs, state cards, visual keyframes, or semantic action traces.These approaches progressively add flexibility and mechanisms for recognizing when a procedure applies and verifying progress.
  • Demonstration-Guided Computer Use: UI-Mate distills human recordings or agent rollouts into subtask-level procedural intent and can selectively follow, skip, or adapt demonstrated steps.This contrasts with ShowUI-Aloha’s primary transfer of one taught procedure across task instances sharing the same workflow logic.

10 Discussion and Future Work

The discussion proposes verifier-grounded progress credit while identifying variant-demo transfer as an unresolved limitation. Existing quantitative results use same-task self-demonstrations, whereas OSWorkerBench’s related-task demonstrations lack stable aggregate evidence.

  • Verifier-Grounded Progress Credit: Verifier-grounded progress credit could reward milestone completion and recovery, penalize regression, and preserve process-reward alignment with executable outcomes.The environment remains authoritative through a terminal residual, while deterministic checks score verifiable milestones and learned judges are limited to uncertain cases.
  • Beyond Self-Demo: the Variant-Demo Setting: All quantitative DemoCUA results use the self-demo setting, pairing 33 OSWorker-Subset targets with successful same-task rollouts from a stronger GUI agent.These findings demonstrate execution guidance but should not be interpreted as procedural transfer across task variants.
  • Beyond Self-Demo: the Variant-Demo Setting: OSWorkerBench’s variant-demo setting contains 45 human-recorded demonstrations from related but non-identical source tasks, without a systematic aggregate result.A preliminary pilot on ten targets was net positive when the demonstrated segment was replicated to match the target entity count, but performance was too unstable for a main benchmark claim.

11 Author Contributions · Appendix · A Source of Task Instructions

This material acknowledges contributors, lists core contributors, and describes four complementary sources for constructing task instructions. The sources combine converted open-source tasks, rollout-derived atomic capabilities, real-content workflows, and capability-tree-driven gap filling.

  • 11 Author Contributions: The authors thank all contributors, including those not listed in the paper, for their support and efforts.
  • Core Contributors: Authors within each role are listed alphabetically by last name, including the named Core Contributors.
  • A Source of Task Instructions: Open-source instructions are cleaned and platform-converted from computer-use datasets, while removing unavailable, ambiguous, or unverifiable tasks.The process preserves operational intent while adapting application and platform references, such as replacing an Ubuntu application with a Windows equivalent.
  • A Source of Task Instructions: Failed or stalled rollouts are decomposed into independent subtasks that target difficult atomic operations and guide focused data collection.This approach supports evaluating and improving atomic capabilities that agents demonstrably find challenging.
  • A Source of Task Instructions: Real documents, spreadsheets, presentations, and static websites provide concrete entities and relationships for authentic cross-application workflows.Content previews replace artificial placeholders, while application manuals inform realistic operational patterns.
  • A Source of Task Instructions: Capability trees organize application functionality into operational modes and fine-grained capabilities to expose underrepresented operations.The resulting targeted instructions fill capability gaps left by datasets, rollouts, and real-file collection.

B Details of DemoCUA Data Generation

DemoCUA scores rollouts with a hybrid evaluator covering whole-task completion, per-subtask completion, and demonstration-following adherence. Its Filter & Repair phase preserves usable data by applying deterministic normalization and LLM-based recovery instead of discarding fixable trajectories.

  • Score: Rollouts are scored across three dimensions: whole-task completion, per-subtask completion, and demo-following adherence.A VLM judge evaluates task success from a visual chain and subtasks from boundary frames and self-reports, while rule-based metrics assess completion rate and execution-order alignment.
  • Score: Whole-task completion uses a Skeptical-Auditor VLM prompt to assess task success from a visual chain.This is designated S1 in the scoring scheme.
  • Score: Per-subtask completion uses VLM evaluation of subtasks from boundary frames and self-reports.This is designated S2 in the scoring scheme.
  • Score: Demo-following adherence is measured with rule-based Subtask Completion Rate and Execution-Order Alignment metrics.These metrics correspond to S3–S4.
  • Filter & Repair: Filter & Repair recovers valid training data through deterministic and LLM-based repairs rather than discarding trajectories with fixable errors.Deterministic rules normalize formats by collapsing duplicate reports, closing unclosed trajectories, re-deriving subtask IDs, and stripping leading WAIT or empty actions; an LLM synthesizes missing boundary reports when transitions lack explicit calls.

C Details of GameDev Tasks

This section presents 20 curated GameDev task case studies across two tables, with verbatim instructions and rubric-based evaluation. Each case is evaluated independently, and rubric checks carry equal weight within the case.

  • Case studies: The section contains 20 curated task case studies, split evenly across Tables 10 and 11.Each table presents ten cases.
  • Evaluation: Instructions are provided verbatim, while rubric entries enumerate artifact checks.The rubric checks are equally weighted within each case.
  • Evaluation: Cases are independently evaluated, with all listed rubric checks carrying equal weight within each case.This evaluation rule is stated for the second set of case studies.

D GameDev Performance of Kimi-K2.6

Kimi K2.6 performs strongly on long-horizon GameDev tasks without demonstrations, while demonstrations further improve mean performance and most non-ceiling tasks. The largest gains occur on QGIS and two Godot tasks, suggesting improved coverage of fine-grained artifact requirements.

  • Overall performance: 83.46 mean score without demonstrations already fully solves three tasks.Results are evaluated over five runs.
  • Overall performance: 5.00 points is the mean-score gain from demonstrations, increasing performance from 83.46 to 88.46.Demonstrations improve six of the seven tasks not already at ceiling.
  • Task-level gains: 30.00 points is the largest task-level gain, occurring on QGIS.The next-largest gains are 13.68 on godot-04 and 9.41 on godot-05.
  • Task-level gains: Demonstrations improve coverage of fine-grained artifact requirements across the evaluated GameDev tasks.The reported gains are 30.00 points on QGIS, 13.68 on godot-04, and 9.41 on godot-05.

E Details of the OSWorld-Subset under DemoCUA setting · F Details of the OSWorker-Subset under DemoCUA setting

Under DemoCUA, self-demonstrations substantially improve OSWorld-Subset performance and shorten model trajectories. On OSWorkerBench, demonstrations improve average task scores, while examples show how they help preserve long-horizon task state.

  • E Details of the OSWorld-Subset under DemoCUA setting: 65.75% average score with self-demonstrations, up from 40.27% without them, a gain of 25.48 percentage points on the 30-task OSWorld subset.Performance improves on 18 tasks, remains unchanged on eight, and decreases on four, indicating some negative transfer.
  • E Details of the OSWorld-Subset under DemoCUA setting: 18 OSWorld tasks improve with self-demonstrations, while eight remain unchanged and four decrease.The per-task results were evaluated over five runs using the corresponding mean success rates.
  • E Details of the OSWorld-Subset under DemoCUA setting: 30.0 average model steps with self-demonstrations, down from 33.3 steps while task completion improves.The trajectory becomes shorter despite the added demonstration context.
  • E Details of the OSWorld-Subset under DemoCUA setting: 0.86 rank correlation with human demonstration step counts under demonstrations, up from 0.66 without demonstrations.Demonstrations make model trajectory lengths track human demonstrations more closely.
  • F Details of the OSWorker-Subset under DemoCUA setting: 13.29 percentage points is the average task-score improvement from demonstrations on the 33-task OSWorkerBench self-demo subset.Each demonstration is a successful stronger-agent rollout of the same task, represented by screenshots and action types without concrete pixel coordinates.
  • F Details of the OSWorker-Subset under DemoCUA setting: 52.97% score and 106.7 average steps describe the no-demonstration outcome for a task requiring coordinated email, Salesforce, calendar, and Slack actions.The model classified all six emails but processed only one of two Hot leads before incorrectly declaring completion.
Loading 2608.15930v1…