TUA-1

1. Model Introduction

TUA-1 is an open-weight computer-use model that operates graphical user interfaces from natural-language instructions. At 4.7M trainable parameters it fits in 19 MB and runs on CPU or GPU (about 70 ms per step measured on CPU), while outperforming zero-shot small language models up to 300× its size on the same GUI tasks.

TUA-1 reads the screen as structured UI elements (from the DOM or an accessibility tree) and decides the next action: click an element, type into a field, scroll, or finish. It is built to execute short, explicit instructions quickly and locally. Typical examples are "log in as zara with password k7mq2x", "set Size to large and save" and "stop emailing me". It is meant to serve under a planner, as a fast local executor, rather than to replace one.

Key Features

• Tiny and fast: 4.67M trainable parameters and an 18.7 MB checkpoint. Runs on CPU or GPU; a GPU is optional, since CPU inference already takes ~0.07 s/step. No API calls.
• Pointer-based actions: clicks point at UI elements and typed text is copied character-exact from the instruction, so 19:00, 2026-11-02 and maya.l@mail.com survive intact. Nothing is decoded freely, so every action is well-formed (0% invalid actions in the benchmark).
• Instruction ↔ element grounding: exact-match features plus a learned per-head attention bias link each instruction word to the elements it mentions.
• Pretrained lexical prior: a frozen projection of Needle 2's token embeddings gives the model a sense of synonyms ("delete" ≈ "remove", "dark" ≈ "night"). Hashed character n-grams handle unseen names, emails and passwords.
• Goal inference: the model handles outcome-phrased requests such as "stop emailing me" (it unticks Email updates and presses Save, unprompted).
• Real-browser ready: it ships with a Playwright adapter that turns any live web page into TUA-1's observation format, including native <select> menus and ARIA switches.
• Trained on a laptop: behaviour cloning, DAgger and six supervised post-training rounds, followed by group-relative RL in a real browser, all on a single 12-core CPU.

2. Model Summary

Architecture	Element-pointer Transformer encoder (pre-LN)
Trainable Parameters	4.67M
Frozen Parameters	4.19M (lexical prior: Needle 2 token embeddings, 8192 × 512)
Number of Layers	6
Hidden Dimension	192
Number of Attention Heads	4
FFN Dimension	768
Activation Function	GELU
Attention	Bidirectional self-attention + instruction↔element match bias
Word Representation	Hashed character 2/3/4-grams (8192 buckets) + frozen BPE lexical prior
Input Capacity	40 instruction tokens · 48 UI elements · 8 history actions
Observation Modality	Structured UI (DOM / accessibility tree): role, label, value, state, bounding box
Action Space	click(element) · type(instruction span) · scroll(up/down) · done
Training	BC + DART perturbations + DAgger → 6 SFT rounds → GRPO-style RL in a real browser
Precision	FP32
Checkpoint Size	18.7 MB (safetensors)

3. Evaluation Results

Benchmark	TUA-1	Needle 2	Gemma 3 270M IT	FunctionGemma 270M	Qwen2.5 1.5B Instruct	Qwen2.5 3B Instruct‡
Parameters	4.7M	45M	270M	270M	1.5B	3B
Simulated GUI tasks
GUI-Sim: trained task types (13 types)	92.3	0.0	0.0	0.0	3.8	—
GUI-Sim: held-out task types (8 types)	56.2	0.0	0.0	0.0	0.0	—
GUI-Sim: trained, goals met	92.8	6.4	11.1	5.2	21.3	—
GUI-Sim: held-out, goals met	65.3	0.0	4.9	0.7	5.6	—
GUI-Sim dev subset: success / goals met‡	—	0.0 / 8.7	0.0 / 12.5	0.0 / 12.5	7.7 / 15.1	11.1 / 68.9
Real web pages (headless Chromium)
TUA-Web Dev (17 tasks)	10 / 17	0 / 17	0 / 17	0 / 17	0 / 17	—
TUA-Web Set 2 (12 tasks)	7 / 12	0 / 12	0 / 12	0 / 12	0 / 12	—
TUA-Web Set 3 (11 tasks)	4 / 11	0 / 11	0 / 11	0 / 11	0 / 11	—
TUA-Web Set 4 (8 tasks)	0 / 8	0 / 8	0 / 8	0 / 8	0 / 8	—
TUA-Web Set 5 (8 tasks)	2 / 8	0 / 8	1 / 8	0 / 8	0 / 8	—
TUA-Web total (56 tasks)	23 / 56	0 / 56	1 / 56	0 / 56	0 / 56	5 / 56§
Efficiency (CPU)
Seconds per step	0.07	1.5	7.3	6.4	13.3	27.9
Invalid actions (%)	0.0	3.8	0.6	0.5	0.9	2.9

Additional TUA-1 results (simulator, n = 100–200 per task type)

Benchmark	Score
Goal inference with paraphrases never seen in training	57.5
Trained task types with all content words replaced by unseen words	90.8
Rendered generator pages in a real browser (78 tasks)	91.0

Footnotes

1. Metrics. Task success (%) in closed loop: the model acts alone until it calls done or reaches a 20-step cap. "Goals met" is the fraction of a task's goals satisfied at the end; about 5% of goals start already satisfied. All models get identical tasks and seeds (n = 6 episodes per task type for GUI-Sim).
2. Baselines are zero-shot. Language models see the same screen as numbered text and answer with one tool call: Needle 2 through its own engine, Gemma through its chat template, FunctionGemma through its native function-call format. Each baseline's prompt (plain instruction / rules + 5 worked examples / rules + 11 examples + episode history) was selected on separate development tasks, never on the reported suites. Prompts used: Needle 2 v3, Gemma 3 v3, FunctionGemma v2, Qwen2.5 v2.
3. Harness validation. A scripted expert routed through the exact text and tool-call path the baselines use succeeds 100% of the time. Qwen2.5 3B Instruct, zero-shot through the same prompts, meets 69% of goals on the development tasks.
4. Held-out task types (newsletter signup, rename a list row, room booking, sign-up, todo, shipping form, profile edit, goal inference with held-out paraphrases) never appear in training. Their labels and phrasings were excluded from all training generators.
5. TUA-Web consists of 56 tasks on 23 hand-written HTML/JS apps: login, todo, settings, contact, shop, sign-up, recipe search, toggles, library, booking, checkout, file manager, flights, alarm, preferences, taxi, notes, orders, profile, gym, feedback, money transfer and connections. Success is read from page state. Sets 4 and 5 were written before the training rounds they first evaluated and were never used for development. Sets are small, so differences of 1–2 tasks are within noise.
6. Caveats. GUI-Sim shares the style of TUA-1's training generators, so it favours TUA-1; TUA-Web and the held-out types are the fairer comparison. Needle 2 and FunctionGemma are designed to map a request to a function call, not to operate a screen step by step. Their scores reflect zero-shot use on a task they were not built for, not their quality at their intended use.
7. Baseline weights: Needle 2 (Cactus Compute, 2-bit engine), Gemma 3 270M IT and FunctionGemma 270M (via unsloth mirrors), Qwen2.5 1.5B Instruct. All were run on CPU (Modal containers, 4 vCPU; Qwen 8 vCPU).
8. ‡ Qwen2.5 3B Instruct was evaluated only on the GUI-Sim dev subset: 13 trained task types, one episode each, v2 prompt, with 9 of the 13 task types completing (the rest were cancelled by the cloud runner). It was not run on the full GUI-Sim suites or on TUA-Web, so it is not directly comparable to the other columns. The dev-subset row lists every model's result on that subset where available. These are the same dev runs used for prompt selection (FunctionGemma's v2 run used the earlier 12-step cap; the others used 20). TUA-1 was not run on the subset.
9. § Qwen2.5 3B Instruct's TUA-Web total was measured separately by MaximusAILabs on the same 56 tasks. It is not included in the per-set rows above or in the raw outputs in benchmark/.

4. Deployment

TUA-1 runs anywhere PyTorch runs, on CPU or GPU. Pass device to load_pretrained ("cpu", "cuda", "mps", or any other torch device). A GPU is optional: the reported latency was measured on CPU, and no quantization or inference server is required. Verified on an x86 CPU and on an AMD Radeon GPU (via DirectML), with identical actions.

Requirement
Python	3.10+
Core	torch, numpy, safetensors
Real-browser adapter	playwright (+ playwright install chromium)
Memory	~35 MB for the model (18.7 MB weights + 16.8 MB frozen lexicon), plus whatever your PyTorch runtime uses itself

5. Model Usage

Single step

# git clone https://huggingface.co/MaximusAILabs/TUA-1 && cd TUA-1
from cu.model import load_pretrained

model = load_pretrained(".")          # config.json + model.safetensors; add device="cuda" to run on a GPU

obs = {
    "instruction": "Log in as zara with password k7mq2x",
    "elements": [   # role, label, value, state, normalised bbox (x, y, w, h)
        {"role": "textbox", "text": "Username", "value": "", "checked": False, "focused": False, "expanded": False, "bbox": (0.3, 0.2, 0.4, 0.05)},
        {"role": "textbox", "text": "Password", "value": "", "checked": False, "focused": False, "expanded": False, "bbox": (0.3, 0.3, 0.4, 0.05)},
        {"role": "button",  "text": "Sign in",  "value": "", "checked": False, "focused": False, "expanded": False, "bbox": (0.3, 0.4, 0.1, 0.05)},
    ],
    "history": [],                     # previous actions: [{"type": "click", "text": "Username"}, ...]
    "can_scroll_up": False, "can_scroll_down": False,
}
action = model.act_on(obs)
# {'type': 'click', 'el': i} | {'type': 'type', 'text': '...'} | {'type': 'scroll_down'} | {'type': 'done'}

Element roles: button, textbox, checkbox, link, dropdown, option, tab, text.

Driving a real web page

from playwright.sync_api import sync_playwright
from cu.model import load_pretrained
from cu.web import WebAgent

model = load_pretrained(".")
with sync_playwright() as p:
    page = p.chromium.launch().new_page(viewport={"width": 900, "height": 700})
    page.goto("https://your-app.example/settings")
    trace = WebAgent(model, page).run("Turn off email updates and save", max_steps=20)
    print(trace)

WebAgent extracts visible interactive elements from the DOM each step and executes TUA-1's actions with real clicks, fills and scrolls.

Recommended use

• Use TUA-1 as a low-level executor: a planner (a larger model, or rules) breaks a goal into short, explicit instructions, and TUA-1 carries each one out.
• Gate irreversible actions (payments, deletion, sending) behind confirmation. TUA-1 has no safety or refusal training and will click what it is told to.

Limitations

• No world knowledge or long-horizon planning. It does not know that acct-7781 is an account number and 25.00 an amount.
• Genuinely new phrasings and page structures remain hard. On never-seen web pages it completes roughly a quarter of tasks. Common errors:
  • binding a value to the wrong field
  • stopping after the first part of a multi-part request
  • choosing the wrong list row
• Requires a structured element list. It does not read pixels.
• Trained entirely on procedurally generated data. No human demonstrations.

Full training details: TECHNICAL_REPORT.md. Raw benchmark outputs: benchmark/.

6. License

The model weights and code are released under the Apache License 2.0 (LICENSE).

The frozen lexical prior (cu/assets/needle2_*) is derived from Needle 2 by Cactus Compute, also Apache-2.0. See cu/assets/NOTICE.

7. Citation

@misc{tua1_2026,
  title        = {TUA-1: A 4.7M-Parameter Computer-Use Model},
  author       = {MaximusAILabs},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/MaximusAILabs/TUA-1}}
}

8. Contact Us

Questions, issues and feedback are welcome in the Community tab of this repository.