CanItRun Logocanitrun.

UI-Mate 27B

UI-Mate 27B needs roughly 19.0 GB VRAM at Q4_K_M quantization (61.1 GB at FP16). 78 GPUs we track can run it fully in VRAM at 8k context.

78 GPUs run this natively · 21 with CPU offload

Tencent27B params256k contextApache 2.0Commercial use ok
Q4_K_M total
19.0 GB
at 8k context
Smallest GPU
24 GB
NVIDIA RTX 4090, at Q4_K_M
KV cache, full context
17.2 GB
16 of 64 layers cache
Inputs
Text · Image
Apache 2.0, released August 2026
OSWorld-Verified
77.0
Tencent's own reported score
OSWorkerBench progress
76.9%
vs 52.4% for the Qwen 3.6 27B base
Available quants
BF16 only
no GGUF requant at launch

UI-Mate 27B is a 27B parameter dense model developed by Tencent. Released 16 August 2026 under Apache 2.0 by Tencent's Hunyuan Frontier team (arXiv:2608.15930). It's a GUI-agent fine-tune of Qwen 3.6 27B, not a new architecture: config.json confirms the identical 64-layer hybrid stack, sixteen repeats of three Gated DeltaNet layers followed by one Gated Attention layer, so only 16 of 64 layers keep a growing KV cache. Instead of chat text, it takes live desktop screenshots plus a task instruction and emits structured mouse and keyboard actions, trained with supervised fine-tuning followed by agentic reinforcement learning in executable GUI environments.

To run UI-Mate 27B locally: Because the layer shape is unchanged from Qwen 3.6 27B, the VRAM math is identical: a Q4_K_M build would run roughly 16.4GB of weights, about 19GB in total at 8k context, comfortable on a 24GB card (RTX 4090, RTX 3090, RTX 5090). The catch at launch is that no such build exists yet: Tencent published only BF16 safetensors, and no community GGUF quantization had appeared within days of release, so vLLM against the full BF16 checkpoint (about 54GB) is the only way to run it today. The reference serving setup retains five screenshots in context and needs a server configured for at least six images.

Tencent reports 77.0 on OSWorld-Verified and 66.2 on WindowsAgentArena, and on its own OSWorkerBench suite of 100 long-horizon office tasks, 41.0% strict success and 76.9% progress versus 23.3% and 52.4% for the Qwen 3.6 27B base checkpoint it was fine-tuned from. These are computer-use agent evals, not general knowledge or coding benchmarks, so they aren't directly comparable to Qwen 3.6 27B's own MMLU-Pro or SWE-bench scores.

The same hybrid stack as Qwen 3.6 27B, retrained to click and type

UI-Mate 27B isn't a new architecture. It's a GUI-agent fine-tune of Qwen 3.6 27B, and its config.json confirms the layer shape carried over unchanged: 64 layers built from sixteen repeats of three Gated DeltaNet layers followed by one Gated Attention layer. What's different is the job: instead of predicting the next word in a chat reply, it takes a screenshot of a desktop plus a task instruction and predicts the next mouse click, keystroke, or scroll.

Gated DeltaNetlinear attention, fixed-size stateGated Attention4 KV heads × 256 dim
layer 13:1 pattern × 16layer 64

16 of 64 layers keep a KV cache that grows with the full context. The other 48 hold a fixed-size recurrent state, so their memory cost does not move as the context window grows.

Only the 16 Gated Attention layers keep a per-token KV cache; the 48 Gated DeltaNet layers carry a constant-size recurrent state instead, exactly as in Qwen 3.6 27B. The reference agent loop keeps five screenshots in its rolling context, and each screenshot spends far more tokens than a line of chat text, so this cache math matters more here than it does for a text-only assistant: the agent burns through its context budget on images, not words.

What a full 262,144-token context actually costs

The layer shape is identical to Qwen 3.6 27B's, so the KV-cache math is too. It's worth restating here because a screenshot-driven agent fills its context with image tokens far faster than a chat session fills it with words, so the long-context case is more likely to come up in practice than it is on a text chatbot.

02040608032k64k128k192k256k17.2 GBUI-Mate 27B68.7 GBall-attention 27B
UI-Mate 27B: 16 of 64 layers cacheThe same 27B if all 64 layers used full attention

KV cache only, at FP16. Weights and activation overhead sit on top of these figures.

Filling the whole 262,144-token window costs 17.2 GB of KV cache instead of 68.7 GB. Add 16.4 GB of hypothetical Q4_K_M weights and the full-context total is 37.7 GB, which a 24GB card can't hold but a 48GB workstation card can. The catch at launch is that no Q4_K_M build exists yet: today the only real download is the native 54.0 GB of BF16 weights, putting the full-context total at 79.7 GB instead.

VRAM at each quantization

UI-Mate 27B natively supports a longer context window, but the table below is capped at 8k for comparability; its hybrid attention stack keeps KV cache growth well below linear.

QuantWeightsKV cacheTotal
FP32108.0 GB0.54 GB121.6 GB
BF1654.0 GB0.54 GB61.1 GB
FP1654.0 GB0.54 GB61.1 GB
Q8_028.7 GB0.54 GB32.8 GB
Q6_K22.2 GB0.54 GB25.4 GB
Q5_K_M19.2 GB0.54 GB22.1 GB
Q4_K_Mrec16.4 GB0.54 GB19.0 GB
Q3_K_M13.0 GB0.54 GB15.2 GB
Q2_K10.3 GB0.54 GB12.1 GB
NVFP4cuda13.5 GB0.54 GB15.7 GB

KV cache is calculated at 8k context (FP16). Note that NVFP4 only runs on CUDA GPUs. Turn on TurboQuant in the calculator above for lower KV cache estimates.

Quantization × context: where it would fit, once builds exist

This table applies the same standard quant ladder every model page on this site uses, projecting hypothetical file sizes from the architecture rather than a real download. Until a community GGUF appears, only the BF16 row reflects a file that actually exists today; the rest is a preview of where this model will land once one does, and Qwen 3.6 27B's own quants (identical architecture) are a reasonable stand-in for gauging real download sizes in the meantime.

Total VRAM needed by quantization and context length, with the GPU class each figure requires.
Quant8k ctx32k ctx128k ctx256k ctx
Q8_032.8 GB48 GB card34.5 GB48 GB card41.8 GB48 GB card51.4 GB80 GB card
Q6_K25.4 GB32 GB card27.2 GB32 GB card34.5 GB48 GB card44.1 GB48 GB card
Q5_K_M22.1 GB24 GB card23.9 GB24 GB card31.1 GB32 GB card40.8 GB48 GB card
Q4_K_Mrec19.0 GB24 GB card20.8 GB24 GB card28.0 GB32 GB card37.7 GB48 GB card
Q3_K_M15.2 GB16 GB card16.9 GB24 GB card24.2 GB32 GB card33.8 GB48 GB card
Each cell shows the smallest card that holds it:Consumer GPUWorkstation GPUDatacenter GPU

Benchmarks

Independent benchmark scores for UI-Mate 27B are not yet listed on the Open LLM Leaderboard v2. A GUI-agent fine-tune of Qwen 3.6 27B from Tencent's Hunyuan Frontier team: it reads live desktop screenshots and emits structured mouse/keyboard actions instead of chat text. Tencent reports 77.0 on OSWorld-Verified, 66.2 on WindowsAgentArena, and 41.0% strict success / 76.9% progress on its own OSWorkerBench suite (arXiv:2608.15930), all specialized computer-use evals, not general knowledge or coding benchmarks. Released 16 August 2026 with only BF16 safetensors weights; no community GGUF quantization existed yet at launch, so llama.cpp/Ollama users have nothing to load until one appears. See the HuggingFace model card for reported evaluations.

Fine-tuning turns Qwen 3.6 27B into a much stronger GUI agent

Tencent's own ablation is the most direct evidence that the GUI-agent training actually did something: the same OSWorkerBench suite of 100 long-horizon office tasks, run on UI-Mate 27B and on the untouched Qwen 3.6 27B checkpoint it started from.

OSWorkerBench strict success
UI-Mate 27B
41.0
Qwen 3.6 27B base
23.3
OSWorkerBench progress
UI-Mate 27B
76.9
Qwen 3.6 27B base
52.4

Tencent Hunyuan Frontier, "UI-Mate: Advancing Open-Weight Foundation GUI Agents with In-Context Demonstrations," arXiv:2608.15930 (16 August 2026). Vendor-reported, not yet independently reproduced.

Strict success (the task fully completed with no partial credit) rises from 23.3% to 41.0%, roughly 1.8x the base model's rate. Progress (partial credit for correct steps) rises from 52.4% to 76.9%. The base checkpoint already understands desktop screenshots; what the GUI-agent fine-tune adds is the discipline to actually finish a multi-step task rather than drift off course partway through.

GPUs that run UI-Mate 27B natively (78)

Show 73 more
Plus 21 GPUs that run it with CPU offload (slower)

Notes

A GUI-agent fine-tune of Qwen 3.6 27B from Tencent's Hunyuan Frontier team: it reads live desktop screenshots and emits structured mouse/keyboard actions instead of chat text. Tencent reports 77.0 on OSWorld-Verified, 66.2 on WindowsAgentArena, and 41.0% strict success / 76.9% progress on its own OSWorkerBench suite (arXiv:2608.15930), all specialized computer-use evals, not general knowledge or coding benchmarks. Released 16 August 2026 with only BF16 safetensors weights; no community GGUF quantization existed yet at launch, so llama.cpp/Ollama users have nothing to load until one appears.

Hugging Face ↗Released 2026-08-16

Compare UI-Mate 27B with other models

How to run UI-Mate 27B locally

816244880160320

Q4_K_M needs 19.0 GB: fits a single high-end consumer GPU (24 GB).

vLLM (the reference serving stack; no llama.cpp/GGUF build exists at launch)

vllm serve tencent/UI-Mate-27B \
  --dtype bfloat16 \
  --max-model-len 65536 \
  --limit-mm-per-prompt image=6

LM Studio: Not available in LM Studio at launch: it needs a GGUF build, and none existed for UI-Mate 27B in the days after release. Qwen 3.6 27B's own GGUFs are a preview of what one would look like, since the architecture is identical.

Why this quantization? There is no quantized build to recommend yet. Tencent shipped only BF16 safetensors, roughly 54.0 GB of weights, so an 80 GB card (A100 80GB, H100 80GB) is the realistic floor today. Once a community GGUF appears, expect the same Q4_K_M-at-roughly-16.4-GB story as Qwen 3.6 27B, since the two share an identical 64-layer hybrid stack.

Who is UI-Mate 27B for?

Teams evaluating GUI-automation agents who already have access to an 80 GB+ datacenter GPU or a cloud instance, not home-lab users on a single consumer card. Wait for a GGUF quant if a 24 GB card is what you have.

Best for

  • Prototyping a computer-use agent that operates real desktop applications from screenshots
  • Long-horizon, multi-step office/OS automation tasks (the OSWorkerBench-style use case it was tuned for)
  • Environments where the reference vLLM + OpenAI-compatible serving setup is already in place

Not ideal for

  • Any single consumer GPU (16 GB or 24 GB), until a GGUF quant exists
  • Ollama or LM Studio users, since no official tag or community quant shipped at launch
  • General chat or coding use: it was trained and evaluated as a GUI agent, not a chat/coding model
  • Safety-critical or production automation without an isolated test environment first, per Tencent's own guidance

So should you run it?

Not on a home GPU today, at least not yet. The architecture is the same 24GB-friendly hybrid stack as Qwen 3.6 27B, but Tencent shipped only BF16 weights at launch, no GGUF, no Ollama tag, so the real download is 54.0 GB and a full-context session runs to about 79.7 GB, well past any consumer card. An 80GB datacenter card (A100 80GB, H100 80GB) clears it with room to spare through vLLM, which is also the reference serving stack the model card documents. If you specifically want a local GUI-automation agent on a 24GB card, watch for a community GGUF quant; the underlying architecture already supports one, since it's identical to Qwen 3.6 27B's, which has quantized cleanly since its own launch.

Explore

Browse all guides →Browse all models →Browse all GPUs →

Frequently asked questions

What are the VRAM requirements for UI-Mate 27B?
UI-Mate 27B requires approximately 19.0 GB of VRAM at Q4_K_M quantization, 32.8 GB at Q8, and 61.1 GB at FP16. These numbers assume 8k context window; its hybrid attention stack caches far fewer than all layers, so VRAM grows much slower than linearly with context.
How many parameters does UI-Mate 27B have?
UI-Mate 27B has 27 billion parameters.
Can UI-Mate 27B run on a 16 GB GPU?
No. At Q4_K_M, UI-Mate 27B needs 19.0 GB of VRAM, more than 16 GB. You will need a 24 GB GPU like the RTX 4090 or RTX 3090.
Can UI-Mate 27B run on a 24 GB GPU?
Yes. UI-Mate 27B fits in a 24 GB GPU at Q4_K_M, requiring 19.0 GB VRAM. GPUs with 24 GB include the RTX 4090, RTX 3090, and RTX 3090 Ti.
What is the smallest quantization for UI-Mate 27B that fits in 24 GB of VRAM?
At NVFP4, UI-Mate 27B needs 15.7 GB, the highest-quality quantization that fits in 24 GB of VRAM.
What GPU do I need to run UI-Mate 27B locally?
A 24 GB GPU is the minimum. At Q4_K_M, UI-Mate 27B needs 19.0 GB VRAM. Good options: RTX 4090 (24 GB), RTX 3090 (24 GB).
Can I run UI-Mate 27B with llama.cpp or Ollama?
Not yet. Tencent published only BF16 safetensors weights at launch, and no community GGUF requantization had appeared within the first few days. Once one does, it should quantize the same way Qwen 3.6 27B does, since the two share an identical 64-layer hybrid stack, but until then vLLM against the full BF16 checkpoint is the documented way to serve it.
How is UI-Mate 27B different from Qwen 3.6 27B?
Architecturally, nothing: both use the same 64-layer hybrid stack (16 Gated Attention layers, 48 Gated DeltaNet layers) and the same 27B parameter count, so their weights size and KV-cache size at any quant or context length are identical. UI-Mate 27B is a fine-tune of that checkpoint for GUI automation: it takes screenshots and a task instruction as input and outputs structured mouse/keyboard actions, trained with supervised fine-tuning plus reinforcement learning in real GUI environments, rather than being trained or evaluated as a general chat or coding model.
What is OSWorkerBench?
It's Tencent's own benchmark introduced alongside UI-Mate 27B: 100 long-horizon office tasks scored on both strict success (fully completed) and progress (partial credit for correct steps). It isn't yet a third-party or independently hosted leaderboard, so treat the numbers as vendor-reported until other groups reproduce them.