Ling-3.0-flash-VL

Ling-3.0-flash-VL

Overview

Ling-3.0-flash-VL adds visual understanding and visual agent capability to Ling-3.0-flash. It inherits the base model's Mixture-of-Experts design — 124B total parameters with 5.5B activated per inference step — and extends it to accept images and video.

The notable result is not that it sees. It is that seeing made it better overall: on the Artificial Analysis intelligence index this model scores 42 against 38 for the text model it was built from. Multimodal training raised general capability rather than adding an isolated skill next to it.

It was built to act on what it sees rather than describe it. Its strongest published results sit in document intelligence and agentic multimodal work — reading a page, operating an interface, completing a task across steps.

At a Glance

Architecture

Vision is attached through three components:

The language backbone:

The 5:1 ratio is what makes a very long context affordable at this size. Five linear-attention blocks for every full-attention block means most of the depth carries a constant recurrent state rather than a growing key-value cache, while regular full-attention layers restore exact retrieval where it matters.

Sparsity is aggressive — 8 routed experts of 512 means under two percent of the routed pool works on any given token, which is what keeps 5.5B active out of 124B total.

The first two blocks are dense. Early layers do broad, general feature mixing rather than specialised work, and routing them through experts costs more than it returns.

Capabilities

What It Was Built To Do

Three workflows inclusionAI highlights, all of which close a loop rather than answer a question.

Coding with visual feedback. Give the model a screenshot or design reference. It generates the site, renders it in a browser, captures the result, compares that against the reference, and updates the code. Build, inspect, revise — with the model judging its own output rather than a human doing it each cycle.

Style transfer from a single image. Give it a website screenshot or an everyday photograph as a visual reference, and it applies that style to a new site: layout, colour palette, typography, and UI components.

GUI agent. It identifies interface elements, plans each step, and operates the interface autonomously — task understanding through to execution.

The common thread is that the model looks, acts, looks again. A model that only describes an image cannot do any of these.

Recommended Use Cases

• Document intelligence — the strongest published result in the table below, and the clearest case for choosing this model.
• UI and browser automation — leading results on web navigation and multimodal agent benchmarks.
• Visual counting and perception — accurate on tasks where models commonly miscount.
• Frontend development from design references — a highlighted capability, though see the honest note under the benchmark table.
• Video understanding — where temporal encoding matters, not just sampled frames.
• Long-horizon multimodal agents — the low activated-parameter count is what makes extended visual agent runs practical.
• Medical report interpretation — a published capability, evaluated on an in-house benchmark that has not been released, and requiring professional review in any case.

Using Ling-3.0-flash-VL on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: inclusionAI/Ling-3.0-flash-VL

Quick start — cURL

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "inclusionAI/Ling-3.0-flash-VL",
    "messages": [
      {
        "role": "user",
        "content": "Two services write to the same row without a transaction. Walk through the failure modes in order of likelihood and propose the smallest fix for each."
      }
    ],
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 16384
  }'

Document extraction — Python

The workload with the strongest published result.

import os
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)


def encode(path: str) -> dict:
    """Build an image content block from a local file."""
    with open(path, "rb") as handle:
        data = base64.b64encode(handle.read()).decode("utf-8")
    return {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{data}"}}


response = client.chat.completions.create(
    model="inclusionAI/Ling-3.0-flash-VL",
    messages=[
        {
            "role": "user",
            "content": [
                encode("invoice_page.png"),
                {
                    "type": "text",
                    "text": (
                        "Extract every line item as JSON with fields: description, quantity, "
                        "unit_price, line_total. Preserve the table structure. Report the "
                        "currency exactly as printed. Use null for any illegible field — "
                        "do not infer."
                    ),
                },
            ],
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
    extra_body={"top_k": 20},
)

print(response.choices[0].message.content)

Instructing the model to return null rather than infer is not optional in document work. An invented figure is undetectable downstream.

Visual feedback loop — Python

Where the model judges its own output. Render the generated page, screenshot it, and send both images back for comparison.

response = client.chat.completions.create(
    model="inclusionAI/Ling-3.0-flash-VL",
    messages=[
        {
            "role": "user",
            "content": [
                encode("design_reference.png"),
                encode("rendered_output.png"),
                {
                    "type": "text",
                    "text": (
                        "The first image is the design reference. The second is the rendered "
                        "output of the current code. List every visual difference, ordered by "
                        "how noticeable it is, and give the specific CSS change that fixes each. "
                        "Report only differences you can actually see in both images."
                    ),
                },
            ],
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
    extra_body={"top_k": 20},
)

print(response.choices[0].message.content)

The instruction to report only visible differences matters. Without it, a model asked to compare two images will produce plausible-sounding differences that are not there.

Design reference to code — Python

response = client.chat.completions.create(
    model="inclusionAI/Ling-3.0-flash-VL",
    messages=[
        {
            "role": "user",
            "content": [
                encode("design_reference.png"),
                {
                    "type": "text",
                    "text": (
                        "Build this layout as a single responsive HTML file with inline CSS. "
                        "Match spacing, hierarchy, and colour as closely as the image allows. "
                        "Where the reference is ambiguous, state the assumption in a comment "
                        "rather than inventing a value silently."
                    ),
                },
            ],
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
    extra_body={"top_k": 20},
)

Node.js — DEVUP AI SDK

npm install devupai

import DevupAI from "devupai";
import { readFileSync } from "node:fs";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const encoded = readFileSync("screenshot.png").toString("base64");

const response = await client.chat.completions.create({
  model: "inclusionAI/Ling-3.0-flash-VL",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "image_url",
          image_url: { url: `data:image/png;base64,${encoded}` },
        },
        {
          type: "text",
          text:
            "Identify every interactive element in this interface. For each, give its label, " +
            "its type, and its approximate position. Report nothing you cannot actually see.",
        },
      ],
    },
  ],
  temperature: 1.0,
  top_p: 0.95,
  max_tokens: 16384,
});

console.log(response.choices[0].message.content);

Fast path without thinking

For classification and routing, where deliberation adds latency and nothing else.

response = client.chat.completions.create(
    model="inclusionAI/Ling-3.0-flash-VL",
    messages=[
        {
            "role": "user",
            "content": [
                encode("page.png"),
                {"type": "text", "text": "Classify this page: invoice, contract, form, or other. One word."},
            ],
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=32,
    extra_body={
        "top_k": 20,
        "chat_template_kwargs": {"enable_thinking": False},
    },
)

Streaming with usage

stream = client.chat.completions.create(
    model="inclusionAI/Ling-3.0-flash-VL",
    messages=messages,
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
    stream=True,
    stream_options={"include_usage": True},
    extra_body={"top_k": 20},
)

for chunk in stream:
    if not chunk.choices:
        if chunk.usage:
            print(f"\n\nTokens — in: {chunk.usage.prompt_tokens}, out: {chunk.usage.completion_tokens}")
        continue

    delta = chunk.choices[0].delta
    if getattr(delta, "content", None):
        print(delta.content, end="", flush=True)

Images consume a substantial number of input tokens, and a visual feedback loop sends two of them on every iteration. stream_options.include_usage is how you watch that rather than discover it afterwards.

Delegating access with a scoped JWT

Visual agent loops run unattended and send images on every turn. Issue a token restricted to this model with an expiry and a spending limit instead of sharing your API key:

curl -X POST "https://api.devupai.com/v1/scoped-jwt" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key_name": "auto",
    "models": ["inclusionAI/Ling-3.0-flash-VL"],
    "expires_delta": 3600,
    "spending_limit": 200
  }'

The returned token is used exactly like an API key in the Authorization header. Requests for any other model, or past the expiry or spending limit, are rejected.

Recommended Generation Parameters

Inherited from the base model, which states these strongly for general inference.

top_k support varies by serving stack. Lowering the temperature is not recommended.

Benchmark Results

As reported by inclusionAI.

Read this table honestly. Against the three comparison models inclusionAI selected, this model leads on five of twelve benchmarks and trails on the rest. It leads where the design intent says it should — document intelligence, web navigation, visual counting — and trails on STEM reasoning across all three of those benchmarks.

One result deserves attention. Frontend coding is among the capabilities inclusionAI highlights, yet on Vision2Web this model scores 57.69 against 62.90 for a considerably smaller competing model. The visual feedback loop described above is a workflow advantage rather than a raw benchmark advantage — worth testing on your own case rather than assuming either way.

And one is unverifiable. AntBench-Medical shows the widest margin in the table, and it is an in-house benchmark that has not been released. Treat it as a claim rather than a measurement until it is.

Overall capability

On the Artificial Analysis intelligence index the model scores 42, against 38 for the text-only model it is built from — the same foundation, with multimodal training raising general capability rather than adding an isolated skill.

Best Practices

• Send images at sufficient resolution. Dense text in documents fails silently when downscaled too far.
• Instruct the model to report only what it can see. Asked to compare two images, a model will otherwise produce plausible differences that are not there.
• Instruct it to return null rather than infer on any extraction task.
• Use the feedback loop rather than one-shot generation for visual coding work. A single pass wastes what the model was built for.
• Disable thinking on classification and routing paths. It is enabled by default.
• Keep temperature at 1.0. Lowering it is explicitly not recommended.
• Keep reasoning_content in its own field. Never merge it into content.
• Watch input token counts. A feedback loop sends two images per iteration.
• Bound every agent loop with an iteration ceiling and a scoped token.

Limitations

• Text output only. The model reads images and video but generates only text. No image generation.
• STEM reasoning trails the comparison set on all three published benchmarks in that category.
• Frontend coding trails a smaller competing model on the published benchmark, despite being a highlighted capability.
• The medical result is on an unreleased in-house benchmark. Clinical output requires professional review regardless.
• Thinking is on by default, and the trace shares your output budget.
• Visual comparison is not measurement. The model judges differences qualitatively; it does not compute pixel-level diffs.
• A domain extension, not a new foundation. For text-only work, evaluate the base model.
• Not a safety layer. Apply your own moderation and validation before acting on model output in a production system.