From perfect demos to live websites
AI browser assistants confidently handle short, clean scenarios: finding a product, placing an order, filling out a form. But as soon as such an agent lands on a real website — with slow loading, unexpected pop-ups, shifting layouts, and dozens of intermediate clicks — the picture changes. In reality, the AI must hold its goal across a long chain of actions, notice its own mistakes and correct them, and navigate cluttered interfaces.
What does a "long-horizon scenario" look like in practice? It's not one click or even ten: an agent may perform 30–40 or more steps before reaching the desired outcome. Each step depends on the previous one, and a single error can undo all the effort. Moreover, real web pages are constantly changing: layouts shift, new elements appear, and data loads asynchronously. A model trained on static demonstrations gets lost under such conditions.
The problem is that most existing approaches are trained on simplified demonstrations and are not designed for this level of complexity. Simply scaling the model doesn't help here: the gap between lab conditions and the real web requires rethinking the entire pipeline — from action execution to final evaluation.
A unified framework for long horizons
This is exactly the challenge the AIMAE team set for itself with Wuying-Browser-Agent — an open-source framework that covers all levels of browser agent operation. Instead of focusing on just one part, the authors aligned execution, control, optimization, and evaluation.
Let's look at each level in more detail. Execution is how the agent interacts with the page: clicking, typing text, switching tabs. Control is monitoring actions and intervening in time if something goes wrong. Optimization is the training process that tunes the model toward successful trajectories. And finally, evaluation is the way to measure how well the agent handles tasks in the real web. All these levels must work in concert, otherwise the system falls apart over long distances.
Three key components power the system:
- Structured browser harness — a set of stable primitives for executing actions. It gives the agent a predictable environment and helps manage context with a focus on decision-making. Instead of relying on unreliable selectors or random timings, the agent receives clear commands that are executed consistently.
- RUIC-SFT — a supervised fine-tuning method on error-recovery trajectories and interactions with complex UI elements. The model learns not only from successful chains but also from how to get out of a dead end.
- DAO-GRPO — an optimization algorithm that improves credit assignment over long horizons through potential-based reward shaping and divergence-weighted step weighting. Each action is evaluated by its contribution to the overall result, not in isolation.
This approach allows the model not just to execute perfect steps but to react to real-world interference and understand which actions actually move it toward its goal. The framework already shows that aligning the pipeline yields more than simply increasing model size.
BrowserBench: a test for real length
How do you verify that an agent is truly ready for the real web? Existing benchmarks are often too short and fail to expose characteristic failures over long distances. A typical test may consist of 5–10 steps, while in real life an agent has to work much longer. So the team built their own — BrowserBench. It's a bilingual set of 350 tasks taken from real websites, with an average scenario length of nearly 38 steps.
That length is a fundamental difference. On short tasks, an agent can act almost at random and still get a high score. On long ones, every error accumulates, and without proper credit assignment the system quickly goes off course. BrowserBench makes these failures visible and helps identify which mechanisms need improvement.
The results speak for themselves. Wuying-Browser-Agent with 27 billion parameters achieves 80.6% on WebVoyager, 66.7% on Online-Mind2Web, and 65.1% on BrowserBench — a new open-source record on browser-use benchmarks. The same pipeline transfers successfully to other domains: an average score of 73.8 on the Tau2-Bench, Claw-Eval, and BFCL-v4 sets.
Notably, the success is achieved not on one specific task but across several independent tests at once. This means the framework learns general principles of working with web interfaces rather than adapting to a particular benchmark. Good generalization is a sign that the agent truly understands what it's doing, not just memorizing patterns.
What this means for the development of AI agents
The main takeaway isn't the specific numbers, impressive as they are. What matters more is the approach: for an agent to work in the real world, we need to stop chasing individual records on clean demonstrations and instead build the entire system around long, messy scenarios. Wuying-Browser-Agent shows this is achievable, and in an open form — researchers can reproduce its results and build on them.
This approach also has practical value. Imagine needing to compare terms across a dozen websites, book tickets, or fill out a long form. Right now you have to do this manually because no assistant can hold context for that long. With a framework like Wuying-Browser-Agent, such tasks could be automated in the near future.
Browser agents are no longer a lab experiment — they're becoming a practical tool. All that's left is to wait for such systems to appear in everyday browsers and take over the routine — from shopping to filling out documents. And judging by this framework, the wait won't be long.
