MAI-UI-8B

MAI-UI-8B

Reads a screenshot and an instruction to decide what to tap or type on a phone or computer screen. An 8B model from the MAI-UI family of GUI agents, for developers building device agents.

Made by Tongyi-MAI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: MAI-UI-8B is a vision-language model that looks at a screen image and an instruction and works out how to operate the interface. It belongs to the MAI-UI family of GUI agents, which comes in 2B, 8B, 32B and 235B-A22B sizes. This page covers the 8B model.

Who it suits: Developers who build agents that control phones or computers, and researchers who study GUI grounding and navigation, will use it most. It also suits teams that want to host such a model on their own server.

Industry | Who uses it | How they use it | Example
Software | Agent developers | Drive an app interface from screenshots and instructions | Find the right button on a settings screen
Mobile | Mobile app teams | Test navigation flows with a model that reads the screen | Walk through an app on a phone
Research | AI researchers | Compare GUI grounding and navigation results across model sizes | Run the model against a screen benchmark
Self-hosting | Platform teams | Serve the model behind their own API | Start the vLLM server and connect an agent

People who only need a text chatbot can skip it, because its job is operating on-screen interfaces.

Where to use it:

• A vLLM server on your own machine, which exposes an OpenAI style API
• Python agent code that sends screenshots and instructions to that server
• The transformers library, which the model is tagged for
• Windows, macOS or Linux for downloading the files

Use case | Who | What they get back
GUI grounding | Agent developers | A decision about where on the screen to act
Mobile navigation | Mobile app teams | The next step to take in a phone app
On-device and cloud routing | Research teams | A way to study when to run locally and when to call a cloud model

How to set it up:

• Python
• vllm 0.11.0 or newer and transformers 4.57.0 or newer
• Room for about 17.5 GB of BF16 weights

1. Install the Hugging Face hub tools with pip, and download the files if you want a local copy first.
2. Install vLLM.
3. Start the API server with the model name.

pip install -U huggingface_hub
hf download Tongyi-MAI/MAI-UI-8B

# Install vLLM
pip install vllm

# Start vLLM API server
python -m vllm.entrypoints.openai.api_server \
    --model Tongyi-MAI/MAI-UI-8B \
    --served-model-name MAI-UI-8B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --trust-remote-code

How to use it: Once the server runs, your agent code calls it on port 8000 under the /v1 path, using the served name MAI-UI-8B. Each request carries a screenshot and an instruction. The card does not show a request body, so follow the vLLM documentation for the exact call.

Tool | What it does
--model | Picks the model that vLLM loads
--served-model-name | Sets the name clients use in requests
--port | Sets the port the server listens on, 8000 here
--tensor-parallel-size | Sets how many GPUs share the model, 1 here
--trust-remote-code | Lets code stored in the model repository run

Example: An agent sends a screenshot of a phone settings page and the instruction to open a particular option. The model answers in text that tells the agent what to do next on that screen.

For newcomers and experts: A GUI agent is software that looks at a screen and decides where to click or type. For a first try, start the server from the steps above and send it one screenshot with a short instruction.

The authors describe a self-evolving data pipeline that adds user interaction and MCP tool calls to the navigation data. They also describe a device-cloud setup that routes work by task state and data sensitivity, and an online reinforcement learning stage. Scaling its parallel environments from 32 to 512 added 5.2 points, and raising the step budget from 15 to 50 added 4.3.

A screenshot and an instruction go in
The model picks the next interface action
Your agent carries the action out
A new screenshot goes back to the model

Good to know: Scores: The authors report these figures for the MAI-UI family, and the card does not say which size each comes from.

Title: Benchmark results reported by the authors
MMBench GUI L2: 91.3 percent
AndroidWorld: 76.7 percent
ScreenSpot-Pro: 73.5 percent
OSWorld-G: 70.9 percent
UI-Vision: 49.2 percent
MobileWorld: 41.7 percent

• Device and cloud: The authors say their routing raises on-device performance by 33% and cuts cloud API calls by more than 40%.
• Network: The sample command sets the host to 0.0.0.0, which accepts connections from other machines on the network.
• License: Apache 2.0.
• Cost to run: none named. The sample runs on your own vLLM server and names no paid service.
• Data it reaches: The screenshots and instructions you send to your server. The research setup can route some work to a cloud model.
• Not for: The source names no forbidden uses. It is built for GUI tasks, not general chat.

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 8.8B
• Weights: about 17.5 GB in BF16; about 4.4 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 10,445
• Likes: 206
• License: apache-2.0
• Quantized versions: 7
• Fine-tunes: 1
• Tags: transformers, safetensors, qwen3_vl, image-text-to-text, conversational

Links

• Model: https://huggingface.co/Tongyi-MAI/MAI-UI-8B
• Files: https://huggingface.co/Tongyi-MAI/MAI-UI-8B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Tongyi-MAI/MAI-UI-8B

Then follow the usage in its model card. Nothing in this kit runs by itself.