claude-news
paperEmergent Mind·25 Oct 2026

Evolving Agent Interfaces in Computer Use Agents

Evolving the interfaces that computer-use agents see makes them up to 3.8x better.

Depth 4/5Score 4.47

Abstract

The paper demonstrates that evolving interfaces for computer-use agents significantly improves their performance and efficiency, achieving a 3.8-fold increase in binary success on OSWorld V2 tasks while reducing task-solving cost from $1.39 to $1.10. Agent S4, a population-based evolutionary system, constructs and refines interfaces using synthetic tasks, crossover, and mutation techniques, selecting the best repositories through held-out validation tasks. The paper’s findings indicate that interface evolution facilitates both intermediate progress and complete-task reliability, supporting the agent’s efficiency in long-horizon and specialized task environments, such as scientific software. Problem formulation and central claim “Evolving Agent Interfaces” (2610.28601) argues that the interface through which a computer-use agent observes and manipulates its environment should be treated as an evolvable agent component rather than as a fixed, human-designed prerequisite. The paper targets a specific failure mode of current computer-use agents: a capable model may still be forced to perform inefficient, error-prone operations because it can access an application only through screenshots, mouse clicks, keystrokes, or a narrow collection of manually specified tools. In such settings, the model often compensates with additional inference and interaction steps instead of obtaining a more appropriate representation of the task state. The paper defines an interface as a mechanism connecting an agent to part of a computer through an action language and an observation language. A GUI interface, for example, accepts pointer and keyboard actions and returns screenshots; a shell or application API accepts structured requests and returns textual or structured observations. An Evolving Agent Interface is a reusable executable interface constructed or revised from task experience, together with supporting knowledge about its capabilities, configuration, workflows, and appropriate usage. These components are stored in a persistent repository RR. For a fixed task agent AA, the objective is to select a repository that maximizes expected task performance over a target task distribution. The important restriction is that the task agent’s model and harness remain fixed during evolution. Agent S4 changes the repository of interfaces and usage knowledge, not the underlying LLM, invocation mechanism, permissions, or task budget. The paper’s central methodological claim is that …

Explained

What happened

Agent S4 (Simular AI, UC Santa Cruz and others; arXiv 2610.28601) makes computer-use agents improve by designing their own interfaces: the tools, shortcuts and how-to notes they use to operate apps. Code: github.com/simular-ai/agent-s.

Results with the open Qwen3.8-27B model:

  • OSWorld V2: 21.3%, which is 3.8x the same model with fixed hand-made interfaces. That beats GPT-5.5 (13.0%) and Claude Opus 4.8 (20.6%) at about 4.3% and 1.5% of their cost.
  • ScienceBoard: success from 41.4% to 58.6% with the same model.

Why it works

A computer-use agent is limited by its interface: clicking raw pixels is slow and error-prone, while a well-designed tool (an API call, a keyboard shortcut, a script for a common workflow) turns ten fragile steps into one. Today those interfaces and the guidance on when to use them are hand-written, which doesn't scale to every app and model.

Agent S4 automates it:

  1. Task agents attempt synthetic training tasks. No success labels are needed.
  2. A meta-agent reads their trajectories, spots where they struggled, and builds or revises interfaces and usage notes in a shared repository.
  3. Population-based evolution: many repository variants compete, and the ones that score best on held-out validation tasks survive. This favours changes that generalize instead of overfitting to training tasks.

The bigger pattern

Better agents don't only come from better models. The harness (tools, prompts, memory) matters just as much, and it can be optimized automatically. A smaller model with a great toolset can beat a frontier model with a generic one. This is the same lesson as Claude Code skills or MCP servers: good tool design multiplies model capability.

What it means in practice

  • When building agents, invest in high-level tools over raw primitives. A narrow tag command is far more reliable than letting the agent edit the database directly.
  • Consider letting an agent propose tool and skill improvements from its own failure logs, with a validation set to accept or reject them.
  • Cost: a well-tooled open model can match frontier models for narrow workflows at a fraction of the price.