Testing Fan Browser Agent: Auto-Filling a Korean Visa Application End-to-End

When a Browser Agent Meets a Tedious Visa Application

Visa applications have always been a headache: lengthy online forms, upwards of thirty personal details to fill in, passport scan uploads, and the complex offline appointment process for submitting materials. These tasks are highly repetitive, time-consuming, and monotonous — exactly the kind of scenario where a Browser Agent can deliver real value.

A Browser Agent is an LLM-powered automation agent that controls a web browser to complete complex tasks, much like a human user. Its core technology stack typically spans three layers: a perception layer (capturing page state via screenshots, DOM parsing, or accessibility trees), a reasoning layer (where the LLM plans the next action based on current state and goal), and an execution layer (simulating mouse clicks, keyboard input, and other interactions via browser automation frameworks like Playwright or Puppeteer). Compared to traditional RPA (Robotic Process Automation) tools, the biggest advantage of a Browser Agent is its ability to generalize — rather than writing custom rule scripts for each website, it relies on the language model's understanding of page semantics to make dynamic decisions.

This article documents a developer's complete real-world test of their self-built Fan Browser Agent, attempting to fully automate a Korean tourist visa application. As the author put it: "Visa applications sound really difficult, which makes them perfect for a Browser Agent — there are so many forms to fill out." This observation cuts to the core value of Browser Agents: freeing people from the mechanical grind of web-based tasks.

Step 1: Autonomously Understanding the Process and Requirements

The test started with a single natural language command: "Hi, I'd like to travel to Korea — can you help me apply for a visa?"

Instead of jumping straight into action, the Agent first proactively "reviewed the process and requirements." It opened the official Korean Visa Application Center website, mapped out the full application path — online e-application form → appointment booking → in-person document submission — and identified that the entire process would require the user to provide over 30 pieces of personal information.

This step demonstrates a key capability of modern Browser Agents: task planning. Task planning is a core module in modern AI Agent architectures — essentially decomposing a high-level goal into a sequence of executable subtasks. In the LLM era, this is typically achieved through Chain-of-Thought reasoning or the ReAct (Reasoning + Acting) framework, where the model outputs its reasoning process before deciding on each action. For multi-stage tasks like visa applications, the Agent needs to identify the directed dependency graph of "fill form → book appointment → submit in person" and understand that certain steps (like booking) can only be triggered after prior steps are complete. This is fundamentally different from the linear scripts of early rule engines, and reflects the LLM's genuine understanding of process semantics.

Step 2: High-Speed Automatic Form Filling

Faced with over thirty fields to fill in, the author took a smart approach — preparing a data file in advance and letting the Agent read it to auto-populate the form.

"Data loaded. Starting to fill in the form now." What followed exceeded the author's expectations. Throughout the entire process, the author "didn't touch the mouse or keyboard once," as the Agent blazed through all the form fields at remarkable speed — a blur to watch.

Form automation is one of the most typical Browser Agent use cases, and also where technical challenges are most concentrated. Modern web forms often include dynamic conditional logic (e.g., selecting a nationality auto-updates the city list), JavaScript-rendered custom controls, and obstacles like CAPTCHA verification. A high-quality Browser Agent needs stateful awareness — re-evaluating the page state after each field is filled, rather than simply iterating through form elements in sequence.

Particularly interesting was how it handled dropdowns and combo boxes. The author observed that the Agent "had a clear strategy — it knew what to do first and what to do next," ultimately completing all four combo box selections (4/4) successfully. This shows it wasn't just identifying page elements, but sequencing its actions according to form logic rather than mechanically filling fields top to bottom.

Testing Fault Tolerance in a Real Scenario

A valuable incident occurred during testing: when uploading a passport scan, the Agent reported "file upload failed." The reason was that the author had deleted the corresponding file beforehand.

This unexpected hiccup actually validated an important strength of the Agent — accurately identifying the cause of failure and reporting it honestly, rather than pretending to succeed or freezing up. The industry generally classifies Agent fault-tolerance behavior into three tiers: silent failure (worst), throwing an exception and halting (middle), and identifying the root cause and recovering or reporting it (best). In this test, the Agent accurately pinpointed "file not found" as the root cause — a Tier 3 fault-tolerance behavior and an important indicator of Agent robustness. In practice, honestly reporting errors and precisely locating problems is often more valuable than forcing a task to "complete." Setting aside the intentionally deleted file, the application form itself was essentially complete — Step 1 was a success.

Step 3: Appointment Booking and the Reality Boundary

After completing the application form, the Agent followed the pre-planned flow into Step 2 — booking an in-person appointment to submit materials — and automatically navigated to the Shanghai Visa Center's appointment page.

The result was exactly what the author expected: no appointments were currently available. But the Agent didn't stop at "failed" — it read the page and extracted the specific reason: appointment slots open every Sunday and Monday morning at 9 AM, and no slots were available at the current time.

This detail once again highlighted what sets it apart from a regular script: the ability to understand the business rules on the page and extract key information for the user, making it clear "when to come back and try again." This is precisely the core advantage of Browser Agents over traditional RPA tools — traditional RPA relies on fixed XPath or CSS selectors to locate elements, so any UI change can break the preset script; a Browser Agent uses the language model's semantic understanding of page content to locate elements, so even after a website redesign, it can continue working based on its understanding of the underlying business logic.

Core Capabilities and Boundaries of Browser Agents

This Korean visa application test clearly outlines the current capability profile of Browser Agents:

• Task planning: Independently breaks down multi-step processes and understands the order of operations;
• Bulk data entry: Combined with local data files, rapidly completes large volumes of form fields;
• Complex control handling: Correctly interacts with dropdowns, combo boxes, and similar elements;
• Error feedback: Accurately identifies the cause of failures and reports them to the user.

As the author summarized, these tools are "perfectly suited for this kind of task — it's not just talk, it actually goes and does the work."

Of course, the test also revealed real-world boundaries: the Agent cannot bypass the visa center's appointment slot rules, and it relies on the user having all required documents prepared in advance. It is better understood as a highly efficient and reliable "digital assistant" — focused on automating tedious mechanical operations, while final decisions and document preparation still require human oversight. It's also worth noting that in enterprise contexts, Browser Agents and traditional RPA are often complementary rather than competing — LLM reasoning brings generalization capabilities, but also introduces uncertainty and additional latency costs. Each type of tool has its own applicable boundaries.

For web-based tasks with clear processes and high repetition — such as visa applications, flight bookings, and bulk form submissions — Browser Agents are demonstrating genuine productivity value. As model capabilities continue to improve, there is every reason to expect them to take on a larger "hands-on" role across more real-world scenarios.

Key Takeaways