UI-Mate on Mac: RAM, Speed and Setup for Tencent’s Open Computer-Use Agent

UI-Mate is a GUI agent, not a chatbot. You give it a task in plain language, it looks at a screenshot of your desktop, and it emits structured mouse and keyboard actions — then looks again and re-plans as the interface changes. Tencent published three checkpoints, all Apache 2.0, with weights going public on 14 August and the model cards finalised on 20 August.

What makes it interesting here is the base model. UI-Mate-27B is a fine-tune of Qwen3.6-27B — a model already near the top of the LLMCheck index. Same architecture, same parameter count, same memory behaviour. So the hardware question is one this index can answer precisely, even though nobody has published an Apple Silicon speed figure for it yet.

What Tencent actually shipped

Parameter counts read from the safetensors metadata on each repo. Both models are dense, not mixture-of-experts, with a 262,144-token context window.

Tencent’s reported agent results for the 27B:

All four figures are vendor-reported, from the official model card. They are not independently reproduced here, and they measure GUI control — not general capability.

The RAM math, and why 24 GB is a trap

This is where the interesting answer is. Quantised builds already exist, so the weight sizes below are actual file sizes rather than estimates from a parameter count:

Now apply the rule the rest of this index uses: macOS lets the GPU address roughly 75% of unified memory. That gives a working budget, and the weights have to fit inside it with room left for the KV cache and the runtime.

A 24 GB Mac clears the weights by 0.3 GB. For a text-only 27B that would be marginal but survivable. For this model it isn’t, and the reason is specific: the default agent keeps five screenshots in context, and Tencent’s own serving instructions tell you to admit at least six images because a new screenshot arrives before the oldest is dropped. Image tokens are far heavier than text tokens, so the KV cache here is much larger than the same-sized text model would suggest — and it grows through a long-horizon task rather than staying flat.

Estimated speed on Apple Silicon

No Apple Silicon measurement for UI-Mate exists from any source as of today. The figures below are estimates, produced by applying the LLMCheck bandwidth model to the real 4-bit file sizes above — not measurements, and not vendor claims:

Estimated, not measured — every figure in this table is derived, and none should be quoted as a benchmark result. Generation speed only; it excludes the time spent processing each screenshot, which for an agent workload is a real share of the wall clock.

One caveat worth stating plainly: for a computer-use agent, tokens per second is not the metric you feel. Each step means encoding a fresh screenshot, planning, then emitting a short action. The output is a handful of tokens; the cost is in the image. A model that generates at 26 tok/s can still feel slow per action, and a faster decode rate does not fix that.

Running it on a Mac

Tencent’s documented path is vLLM with tensor parallelism across two GPUs — a datacentre setup, not a Mac one. The harness, though, only needs an OpenAI-compatible endpoint, which is exactly what LM Studio and llama.cpp’s server expose. The pieces line up:

• GGUF builds exist for both sizes, and the 9B has already passed 18,000 downloads — llama.cpp-class runtimes can load it.
• MLX builds exist for the 27B at 2-, 4- and 8-bit, so the conversion path to Apple’s framework works.
• The agent loop itself is a Python client in the UI-Mate repository, pointed at whatever base URL serves the model.

What nobody has published is the part that matters most: how well the vision path holds up under Mac quantisation, and what the per-step latency actually is once screenshot encoding is included. Until someone posts that, treat the setup as viable-on-paper rather than proven.

Why it is not on the leaderboard

UI-Mate is Apache 2.0, Mac-runnable and genuinely capable, and it still does not appear in the index. That is deliberate.

The LLMCheck capability score is built from Arena ELO, MMLU, HumanEval and SWE-Bench. UI-Mate publishes none of them — it reports OSWorld, WindowsAgentArena and OSWorkerBench, which measure something different and are not comparable to a general-capability score. Adding a row would mean inventing a number to fill the column, and a fabricated score is exactly what the August audit removed nineteen entries to prevent. When agent benchmarks are covered properly, it belongs in that ranking rather than this one.

Which Mac

• 16 GB — UI-Mate-9B at Q4_K_M. The 27B is not an option at any quantisation worth running.
• 24 GB — the 2-bit 27B, or the 9B with room to spare. Do not plan around the 4-bit 27B here.
• 32–48 GB — the sweet spot for the 4-bit 27B, with enough headroom for a long multi-app task.
• 64 GB+ — 8-bit becomes possible at 29.5 GB, which is the version most likely to preserve the grounding accuracy the agent depends on.

If you are choosing hardware around this specifically, the memory tier matters far more than the chip generation: an M2 Max with 48 GB is a better home for UI-Mate-27B than an M4 Pro with 24 GB, even though the M4 Pro is the newer machine.