Your AI agent's memory is a broken filing cabinet. This fix proves it.

When an AI agent is asked to open a spreadsheet, extract data, update a chart, and email the result, the typical approach is to feed it a growing log of screenshots, mouse clicks, and system responses. As the task stretches across dozens of steps, that raw history turns into a swamp. Critical information, a file path, a verified edit, a URL, gets buried under failed attempts and stale observations. This is exactly the kind of subtle trap that catches agents in production, as the subtle trap waiting for AI agents in production describes.

That is the problem researchers from UC San Diego and Aether AI Lab set out to solve with StructAgent, a framework whose central insight sounds almost paradoxical: to make agents more reliable over long tasks, give them less context. But the context it keeps has to be structured, verified, and causally linked to what actually advances the task.

In experiments reported in a new paper, StructAgent improved the success rate of a 9-billion-parameter model from 27.0% to 46.9% on OSWorld-Verified, a benchmark for long-horizon computer use. With a stronger 27-billion-parameter backbone, it jumped from 31.6% to 62.2%. Using the MiniMax-M3 model, it hit 78.9%, a new state-of-the-art for open-source methods on that benchmark. The MiniMax-M3 backbone is the same architecture that quietly matched Claude Opus on another coding benchmark, as reported here.

The authors quote Edsger Dijkstra: “The purpose of abstracting is not to be vague, but to create a new semantic level in which one can be absolutely precise.” The paper reads as an extended argument for that principle applied to agent design.

The raw history problem

Current digital agents, whether powered by LLMs or VLMs, typically consume interaction history as a flat sequence: screenshots, accessibility trees, action outputs. Over many steps, that context grows to include intermediate edits, failed attempts, and partial completions. The agent has no principled way to separate what matters from what does not. The design philosophy here parallels Microsoft's bet on orchestration over model size, as Microsoft's MagenticLite project shows: small models can handle complex tasks when the orchestration is right.

StructAgent replaces this with a unified state containing three typed components: current requirements, useful values (file paths, URLs, extracted data), and verified evidence. Rather than inferring progress from a growing log, every module, planner, actor, verifier, reads from and writes to this shared state. The critical rule is that no progress can be committed without a verifier-backed decision.

How it works

The framework runs a loop. The planner reads the current state and selects a subgoal. The actor attempts that subgoal in the environment. The verifier checks whether valid progress was made. Only if the verifier finds evidence does the state update. This is stricter than approaches where the actor self-declares completion, or where a final judge checks only the final screenshot.

The verifier uses structured probing: it can check files on disk, command outputs, URLs, accessibility trees, not just the screen. In a multi-application task, for example, the actor might appear to export an image from a document, but the verifier can check the file system for the actual exported file. If the file is missing, the subgoal stays pending, blocking a false completion.

This discipline enables several capabilities: progress checkpointing (the state itself is a resume point), targeted failure recovery (the verifier diagnoses whether a failure was caused by missing evidence, a conflicting requirement, or an environment blocker), and tool-assisted execution (reusable procedures that still require verifier-backed commits).

The numbers

The controlled experiments on OSWorld-Verified use a 100-step budget and a common scoring pipeline. The results show that StructAgent improves every backbone tested, with the largest gains on weaker models. The implication is that the framework compensates for a model's limited ability to extract signal from raw history.

Office applications (spreadsheets, documents) see the clearest improvements, likely because these environments expose durable intermediate states like cell values and file contents. Cross-application tasks remain the hardest setting. Even with the strongest backbone, performance on multi-app scenarios lags behind simpler domains. The verifier's evidence surface is less reliable across application boundaries.

The framework generalizes beyond desktop environments. In Minecraft, StructAgent replaced desktop evidence sources with inventory-based checks. It achieved a 76% task-weighted average success rate across five tool tiers, compared to 59% for the published Optimus-1 baseline. The largest gains came on the Iron and Golden tiers, where long dependency chains make verified subgoal tracking especially useful.

Why it matters

StructAgent arrives at a moment when the AI industry is pushing hard toward agentic systems, models that can act autonomously over extended periods. But benchmarks like OSWorld-Verified show that even the best models fail on long tasks. The paper frames the problem as an agent-design issue, not just a model-scaling one. Its approach reframes verification from a final gate to an ongoing commitment mechanism. This systems-level view aligns with the thinking behind parallel agents, where coordination and state isolation become the real challenges.

The failure analysis of score-zero trajectories is revealing even about StructAgent itself. Actor failures accounted for 33% of cases, but planner and verifier failures each accounted for 30%. No single module explains all failures, which the authors argue supports the systems-level view: long-horizon reliability requires better evidence design, stronger verifier training, and domain-aware execution support.

The paper also shows that structured verification beats visual-only verification. When the structured and visual verifiers disagreed, in 100 intermediate cases reviewed manually, the structured verifier was correct 63% of the time, compared to 31% for the visual-only verifier. The advantage came from latent evidence: files, command outputs, URLs that are not reliably visible in screenshots.

The open questions

StructAgent's gains are largest when environments expose checkable state: files, URLs, accessible data structures. In purely visual domains, some browser tasks and image-heavy applications, the advantage shrinks. The paper suggests richer app-specific checks and verifier training as the next bottlenecks.

Another open question is how this approach scales to even longer tasks or to multi-agent setups. The state abstraction is designed to be shared across modules, but the paper does not test multi-agent scenarios. The authors note in their conclusion that the paradigm could extend to web agents, embodied agents, and multi-agent collaboration, but leave the implementation as future work. Given the industry's move toward multi-agent orchestration, as OpenAI's explicit bet on workspace agents shows, this is an obvious next frontier.

StructAgent also does not escape the cost of verification. Each verifier call adds latency and compute. For the 100-step budget used in experiments, that overhead is manageable, but for tasks running thousands of steps, the verifier itself becomes a bottleneck.

Still, the results are hard to ignore. A framework that lifts a 9-billion-parameter model from 27% to 47% on a hard benchmark, without scaling the model, suggests that how an agent tracks its own progress may be as important as the model's raw ability. The paper's core argument, that long-horizon execution needs a causal structure for progress, not just a bigger context window, is one the industry is likely to grapple with as agentic tasks grow longer.

The code and project page for StructAgent are publicly available. The authors have signaled that the state-centered design is not limited to desktop tasks, but a general paradigm for making agents that can honestly track what they have and have not accomplished.