<think>**Translating phrase precisely** </think> Ant Open-Source Visual Closed-Loop Model

<think>Planning markdown-preserving translation

</think>

Ant Group Advances Multimodal Models from “Looking at Images and Answering” to “Looking at Results and Modifying Actions”

On September 9, Ant Group announced the open-source release of Ling-3.0-flash-VL, the first native multimodal model in its Ling series. Rather than simply adding a vision encoder on top of Ling-3.0-flash, it was designed at the level of both training and inference mechanisms as a multimodal system capable of continuously reading visual feedback and correcting its execution process.

The model has 124B total parameters, with 5.5B parameters activated per inference pass. It natively supports image, text, and video inputs, and offers a context window of up to 256K tokens. BF16 and FP8 versions are already open-sourced on Hugging Face and ModelScope, while FP4 and INT4 versions are planned for release soon. The model is also now available on Ling Studio for free trial use.

What deserves the most attention about this release is not that it is yet another model that “supports image input,” but that Ant is attempting to solve a more practical problem in multimodal Agents: Can a model inspect what it has generated, and continue modifying it after discovering problems?

From One-Time Generation to a Verifiable Task Loop

Traditional vision-language models typically work as follows: given an image, the model analyzes it and then outputs text, code, or operating instructions. This process is suitable for image question answering, OCR, content description, and similar tasks, but its shortcomings become obvious when dealing with complex tasks that require execution.

For example, when asked to generate frontend code from a screenshot of a webpage, a model may be able to identify buttons, cards, navigation bars, and font hierarchies, and output a seemingly complete HTML and CSS structure. However, once the code is actually rendered, common problems include inconsistent spacing, misaligned elements, color discrepancies, failed responsive layouts, and even page structures that bear little resemblance to the original image.

By looking only at the input image, the model has no way of knowing what the page it generated actually looks like. It can only “guess” whether the code is correct.

The visual feedback loop introduced by Ling-3.0-flash-VL attempts to fill this gap. The model’s task process is organized as follows:

1. Observe: Understand the image, video frame, or current software interface state;
2. Act: Generate code, click controls, call tools, or perform the next operation;
3. Verify: Read the rendered result, interface changes, or new visual input;
4. Correct: Compare the expected result with the actual result and adjust the code or operating strategy;
5. Continue execution: Proceed until the task is completed or a stopping condition is reached.

The difference from a single-turn VLM can be compared to the difference between “looking at construction blueprints and proposing a renovation plan” and “inspecting the work while construction is underway.” The former relies on a one-time judgment, while the latter allows the system to continually rework the result based on conditions at the site.

This mechanism is particularly suitable for tasks whose results can be visualized but are difficult to evaluate through text alone. Examples include frontend page generation, GUI automation, desktop software operation, cross-application workflows, and assisted analysis of medical images or complex reports.

124B Total Parameters, but Only 5.5B Activated Per Inference

At the architectural level, Ling-3.0-flash-VL continues the MoE approach used by Ling-3.0-flash. The model has 124B total parameters, but only 5.5B activated parameters per inference pass. In other words, it retains the capacity of a relatively large parameter pool while using sparse routing to avoid computing all parameters for every request.

This is particularly important for multimodal models. Visual inputs themselves introduce additional computational demands: a high-resolution image may be split into a large number of visual tokens, while video adds a temporal dimension on top of that. If a model activates all parameters, the cost of long contexts, real-time video, and multi-turn interaction can quickly rise.

Ling-3.0-flash-VL uses an arbitrary-resolution vision encoder, avoiding the crude approach of scaling all images to a fixed size before processing them. For webpage screenshots, dashboards, tables, and medical documents, resolution directly affects the recognition of small text, boundaries, and local structures. In theory, an arbitrary-resolution strategy is better suited to these inputs.

The language backbone retains a 42-layer hybrid architecture, with KDA and Gated MLA arranged alternately at a ratio of 5:1. KDA is more geared toward efficiently processing long sequences and maintaining state, while MLA is used to preserve stronger global information interaction. The goal of combining the two is to strike a balance between long-context capabilities and inference costs.

The model also introduces VideoRoPE to handle spatial and temporal positional information in videos. For real-time video conversations, the model needs to know not only “what is in the frame,” but also “what happened when.” This is a common challenge when extending static-image models directly to video: if temporal relationships are not modeled properly, the model may conflate actions occurring at different points in time.

The 256K-token context provides a larger workspace for long documents, long videos, and multi-turn visual interactions. It can process a relatively lengthy technical document, multiple related attachments, and a record of multiple rounds of operations within a single task, without repeatedly breaking the context. However, 256K is the model’s maximum context window; it does not mean the model can retain every detail in the window without loss. In real-world applications, retrieval, compression, and state management will still affect performance.

Native Joint Training: Visual Inputs Do Not Come at the Expense of Text Capabilities

According to Ant, Ling-3.0-flash-VL uses native multimodal joint training rather than first training a text model and then adding visual capabilities through an additional adaptation stage. The company disclosed that, in the Artificial Analysis Intelligence Index v4.1.1 evaluation, Ling-3.0-flash-VL scored four points higher than the text-only Ling-3.0-Flash.

This result is worth noting. Multimodal training often creates a practical problem: the model gains visual capabilities, but its text reasoning, coding, and instruction-following abilities deteriorate. The reasons are straightforward. Images and videos consume substantial training budgets and context capacity, while the model must also learn visual alignment, language generation, and cross-modal reasoning simultaneously.

If adding visual capabilities causes a model’s pure-text performance to improve rather than decline, that at least suggests the joint-training process did not significantly sacrifice the capabilities of the language backbone. Of course, the specific composition of the four-point improvement, the evaluation samples, and its statistical significance still require confirmation through additional independent testing. For developers, it is not enough to look at a single overall score; greater attention should be paid to performance in individual categories such as coding, long-context processing, tool calling, and multimodal tasks.

Image-to-Webpage Generation Is the Most Direct Testbed for the Visual Feedback Loop

For image-to-webpage tasks, Ling-3.0-flash-VL can first analyze the overall layout, component relationships, and visual hierarchy in a screenshot, and then generate the corresponding code. More importantly, it can render the generated result, use the rendered page as new visual input, compare it with the target screenshot, and then revise the code.

This changes the fundamental paradigm of image-to-code generation.

In the past, models were typically responsible only for “generating the first version.” Developers still had to open a browser, inspect the page, and manually tell the model what was wrong. Now, the model can perform part of the visual regression testing within its own workflow: if the title is mispositioned, it adjusts the CSS; if the card width is incorrect, it recalculates the layout; if the button color or border radius is inconsistent, it continues modifying the styles.

In the official Image-to-WebDev Arena evaluation, the model competed under the codename linthium and scored higher than GPT-5.4. If this result can be reproduced in more independent environments, it would indicate that open-source models have achieved the ability to compete with closed-source frontier models on specific visual coding tasks.

However, this result should still be interpreted cautiously. Image-to-webpage evaluations are often affected by data distribution, rendering environments, evaluation metrics, and the number of allowed iterations. How many rounds of self-correction the model is permitted to perform, whether it can call a browser, and whether the frontend framework and assets are fixed can all change the final score. Leading on an individual benchmark does not mean that it comprehensively surpasses GPT-5.4 in general multimodal reasoning.

For developers, what matters more than a one-line claim that it “performed better” on a leaderboard is whether the complete model weights are available and whether the visual feedback stage can be integrated into their own browsers, IDEs, and Agent frameworks. Only after open-sourcing will these questions have the opportunity to be answered through real-world engineering tests.

GUI Agents: Models Can Finally See the “Results of Their Actions”

GUI Agents are another natural application scenario for the visual feedback loop.

An Agent capable of operating a computer should not merely generate click coordinates based on a user’s description. It needs to know what the current window contains, whether the button is actually present, whether the page changed after clicking, and whether it should backtrack or take another route after an operation fails.

Ling-3.0-flash-VL can identify interface structures and perform cross-tool operations. Ideally, it could copy data from a browser to a spreadsheet and then write the results into a document or email. It could also open a project in a development environment, modify files, run a program, and then continue processing based on feedback from the interface or terminal.

The core difficulty in these tasks has never been simply “understanding a screenshot,” but handling state changes. A button may be temporarily unavailable due to loading delays, a pop-up may block the target area, or a webpage may shift control positions because of a change in resolution. Only by incorporating the new interface state into its reasoning can an Agent avoid executing a dozen consecutive operations on the basis of an incorrect state.

Of course, visual feedback cannot automatically solve the reliability problems of GUI Agents. A model may still misidentify buttons, click repeatedly, ignore permission dialogs, or lose track of its objective during a long task. Production environments also need action allowlists, permission isolation, rollback mechanisms, and human confirmation. Directly placing a model in front of a real computer without execution-layer safeguards is still not a mature solution.

Medical Report Scenarios: The Focus Is Cross-Document Integration, Not Replacing Physicians

Another application direction disclosed by Ant is medical report interpretation. The model supports cross-document data integration and risk flagging. It can analyze multiple reports, examination results, and charts within a single task, and attempt to identify abnormal information that requires attention.

The value of multimodal capabilities here is relatively clear: medical information often exists simultaneously in text, tables, images, and time series. Reading an individual report is not particularly difficult; the challenge is connecting information from different dates and examination items.

However, medicine is a high-risk domain. Model outputs can only serve as supporting information and cannot directly replace diagnosis, prescriptions, or clinical decisions. A visual feedback mechanism may reduce errors in format interpretation and information omission, but it cannot guarantee that medical judgments are correct. Actual deployment must address privacy protection, data de-identification, explainability, accountability, and physician review.

Open-Source Versions and Deployment Value: The Real Highlights Are FP4 and INT4

At present, Ling-3.0-flash-VL provides BF16 and FP8 weights. BF16 is better suited to preserving model accuracy and supporting secondary development, but it also requires more GPU memory. FP8 can reduce memory usage while keeping accuracy degradation within a controllable range, making it closer to practical inference deployment.

Ant plans to release FP4 and INT4 versions soon, and these two versions will be more attractive to developers. A model with 124B total parameters still presents deployment challenges even if only 5.5B parameters are activated per inference pass. MoE inference requires loading or managing the full set of expert parameters, so quantized versions will directly affect the hardware requirements, memory usage, and concurrency capacity of single-machine deployments.

However, low-bit quantization is not free. The vision encoder, cross-modal connector layers, and language backbone may differ in their sensitivity to quantization. If a visual feedback task requires multiple rounds of iteration, even a slight decline in single-round accuracy may be amplified into a significant deviation in the final result. Developers need to test image question answering, code generation, page rendering, and GUI operation separately, rather than judging whether a quantized version is usable solely through general text benchmarks.

From a broader roadmap perspective, Ling-3.0-flash-VL’s advantage does not lie in continuing to increase parameter count, but in combining relatively large expert capacity, low activation volume, and multimodal feedback mechanisms. This approach is more closely aligned with the practical requirements of Agents: models need to be called frequently, respond quickly, and execute continuously, rather than merely produce a polished answer in a single request.

Assessment: This Is Not a “Multimodal Chat Model,” but an Agent Execution Node

Ling-3.0-flash-VL’s product positioning has shifted from “understanding images” to “completing visual tasks.” Its greatest potential value is unlikely to be making chatbots better at describing photos, but rather embedding the model into workflows with tools, state, and verification stages.

It is well suited to the following types of tasks:

• Image-to-webpage and frontend code generation: Automatically render, compare, and revise code after generating it;
• GUI automation: Identify interface states, perform cross-application operations, and adjust the path based on results;
• Video understanding and real-time interaction: Track event changes in long videos and continuous visual streams;
• Long-document and multi-document analysis: Jointly process text, tables, images, and attachments;
• Agent workflows requiring visual acceptance testing: Such as report generation, webpage testing, and office automation.

Its limitations are equally clear: visual feedback increases the number of inference rounds, so actual end-to-end latency may not correspond to single-pass token speed; the total parameter count of the MoE still creates deployment and memory-management pressure; and much of the performance information currently comes from Ant’s official disclosures. Third-party evaluations of different quantized versions, long-task stability, and real-world tool-calling success rates remain insufficient.

Therefore, the significance of Ling-3.0-flash-VL lies in more than being “another 124B open-source model.” It advances the competitive focus of open-source multimodal models from visual understanding on the input side to result verification on the output side. Whether a model can understand an image is no longer the only question. Whether it can recognize what it has done wrong and continue correcting it is the real dividing line for whether Agents can be deployed successfully.

Three things are worth watching next: the actual accuracy and memory usage of the FP4 and INT4 versions; the task success rate of the visual feedback loop in open tool environments; and whether independent evaluations can reproduce its performance on the Image-to-WebDev Arena. If all three hold up, Ling-3.0-flash-VL will become one of the more engineering-oriented and deployment-worthy open-source multimodal models released this year.

References

• IT Home: Ant Group’s First Native Multimodal Model in the Ling Series, Ling-3.0-flash-VL, Released as Open Source: Model parameter scale, architecture, visual feedback mechanism, evaluation results, and open-source plans.
• Hugging Face: Ling-3.0-flash-VL Model Page: Model weights and open-source version information for developers to further review and test for deployment.