Papers for

enterprise automation teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Affora enables software interfaces friendlier for automated agents

Affora: A Design System for Agent-Friendly Interfaces

Abstract: Computer-use agents increasingly operate software designed for people, but interfaces often leave actions or task state unclear to machine readers. We present Affora, a design system that supports both readers while preserving visual freedom and familiar human workflows. Three controlled studies examine component implementations, visual variation, and interaction-design principles. Their findings inform guidance from individual components to complete sites, supported by reusable implementations and executable checks. Agent performance depends on the interaction meaning available through its interface representation; substantial visual variation remains possible when that meaning is preserved. Evaluation on independently authored interfaces shows gains where Affora addresses existing deficits, but limited effects where those deficits are absent or outside its coverage. A workflow case provides preliminary evidence of reduced interaction cost. Affora connects user experience and agent experience through a shared interface rather than a separate agent-only surface.

Wed 16 SeptHuman-Computer InteractionArtificial IntelligenceSoftware Engineering
The gist
Using software usually assumes a human is in control, but now automated agents also interact with interfaces designed for people. The authors introduce Affora, a design system that helps make software interfaces clearer to these agents while still looking familiar to humans. They ran studies showing how different designs affect both humans and agents, and created reusable components that keep the meaning clear even if the look changes. Affora connects what users experience and what agents read through the same interface, improving agent interactions in many cases.
Open 2609.19125v1

EchoPath enables efficient replay of GUI tasks with image-based targeting

EchoPath: Execution-Level Replayable Memory for GUI Agents

Abstract: Computer-use agents increasingly operate browsers, software, and desktop applications via CLI or API portals, but graphical user interface (GUI) still plays an important role in common industrial production scenarios. GUI agents commonly employ fresh observe-plan-ground-act loops, which is inefficient for enterprise tasks that repeatedly update records, process forms, configure tools, and export reports. We introduce EchoPath, a model-agnostic harness that converts artifact-validated GUI trajectories into standardized, parameter-controlled callable memories, analogous to Model Context Protocol (MCP)-style tool calls rather than unstructured experience records. Each memory stores task-intent keys, application and state preconditions, flexible input parameters, GUI evidence, validation provenance, and lifecycle state, so the host agent invokes a targeted procedure only when it can be deterministically replayed in the current runtime. The core mechanism enabling replay is an image-based target-reaiming algorithm that treats stored coordinates as visual evidence, matches the remembered GUI target against the current screen, and emits corrected operation coordinates before execution. During replay, EchoPath rebinds only declared modifiable inputs and rejects ambiguous or incompatible steps to bounded grounding repair or fresh planning. In experiments with real computer-use tasks, EchoPath reduced median token cost by more than 90% and median execution time by about 60%. These results support a bounded form of enterprise GUI memory: validated execution experience can become a controllable callable asset for recurrent work rather than only context for another reasoning pass.

Tue 15 SeptArtificial Intelligence
The gist
Using graphical user interfaces to repeat tasks on computers is often slow because the software has to figure out what to do every time from scratch. The authors created EchoPath, a system that remembers how tasks were done before by saving images and details about the process. When needed again, EchoPath matches parts of the screen visually to replay the exact steps, making the tasks much faster and cheaper to run. It also only runs steps that it can do reliably, avoiding errors.
Open 2609.16635v1

Llm agents study new environments without task guidance first

Studying Without a Syllabus: Task-Agnostic Environment Preprocessing

Abstract: Before an LLM agent tackles tasks in a new environment, it can inspect available corpora and tools and construct reusable resources such as indices, scripts, or procedural guidance. Most automated adaptation methods, however, rely on task examples, trajectories, or evaluation feedback to decide what to build. Existing task-agnostic approaches avoid this supervision but commit in advance to a preparation strategy for a particular type of environment. We study a more open-ended setting: can an agent study an unfamiliar environment without a syllabus, i.e. before test time and without knowledge of the downstream task distribution, and choose how to prepare it? We formalize task-agnostic environment preprocessing, in which a studying system explores an environment under a budget and produces artifacts for a frozen solver. We compare unaided and archive-equipped meta-agents with fixed synthetic-practice and corpus-processing methods across six heterogeneous benchmarks. A meta-agent variant achieves the highest Avg@3 reward on five benchmarks, while fixed corpus processing remains best on the largest corpus benchmark. Larger study budgets do not reliably improve downstream reward. Nevertheless, studied artifacts reduce the test-time sampling needed to reach a given score, demonstrating how reusable preparation can shift computation from repeated test-time attempts to a pre-task study phase.

Wed 9 SeptArtificial IntelligenceComputation and LanguageMachine Learning
The gist
When large language model (LLM) agents work in new environments, they usually prepare by looking at examples or feedback tied to specific tasks. This paper explores whether these agents can instead study their surroundings without any task hints, before doing the actual work. The authors created a framework where the agent explores and builds helpful tools without knowing what tasks it will face later. They found that some smart exploration methods improved performance in several test scenarios, although just spending more time studying didn't always help. Their work shows that careful early preparation can save effort later when the agent actually solves tasks.
Open 2609.10824v1