Cua's 706k-Parameter Form Model Beats Hosted Jev on Its Own Task

Cua, the company behind the open-source desktop automation stack, has published a research release called CUA-S1, a family of small “System 1” models for computer use. The first profile, CUA-S1-FORMS, has 706,000 parameters and a 2.8 MB checkpoint. It does not generate tokens. Given structured elements and values pulled from a document, it returns a probability for each of four choices per element: use the value, CHECK, CLICK, or SKIP.

The headline number is the comparison. On Cua’s form task, the specialist scores 99.7% correct across the whole decision set, against 83.6% for hosted Jev. On steps that require an action, it is 100% against 96%. On steps that mean leaving an already-filled field alone, it is 100% against 74%. Cua is explicit that this is not apples to apples: the specialist was trained for this exact task and convention, while hosted Jev was not fine-tuned for it. Read that caveat seriously. It is also the point.

What is actually new

The interesting move is not the accuracy gap. It is the interface.

Most computer-use agents today are general-purpose models in a loop: screenshot in, tokens out, action parsed, repeat. Cua’s founders, Dillon and Francesco, ask a narrower question in their Show HN post. How many computer-use tasks actually need a full general-purpose LLM to think through every step? Some tasks need planning, path exploration, failure recovery. Others are local calls: this value goes in this box, this element should be ignored.

Their answer is a model that scores a fixed set of candidate actions instead of generating a response. That changes what you can do with the output. A probability over four known choices is checkable, testable, and cheap to route. A token stream is none of those things without a parser in front of it.

The latency figures make the case concrete. Cua measured 7–9 ms to score a form locally, against 260–280 ms per call to hosted Jev including network latency. The team flags that these measure different things and are not end-to-end completion times. Fair. But a 30x gap in the primitive is not a rounding error when your agent is making dozens of decisions per form.

Training cost is the other number worth sitting with. The first iteration took under 30 minutes on synthetic data. Cua open-sourced the synthetic data generation, training, evaluation, and Driver integration under libs/cua-s1, MIT-licensed, with weights hosted separately on Hugging Face.

The System 1 framing, and where it strains

Cua borrows the System 1 / System 2 language from Daniel Kahneman by way of Typesafe’s Jev and its System One Model framing. The GitHub page is careful about this in a way the HN post is not: “System 1” is an engineering analogy for fast, bounded decisions, “not a strict classification of model architectures or a replacement for a general-purpose agent’s planning and reasoning.”

That hedge matters, and Cua should hold to it. The cognitive-science analogy is doing marketing work that the architecture does not support. A 706k-parameter scorer is not “intuitive.” It is a small classifier with a well-defined action space. The reason it wins is not that it thinks fast. It is that the task was scoped tightly enough that a small model could be trained to saturation on synthetic data.

That is a less romantic claim, and a more useful one. The win comes from the decision set being narrow and stable, not from the model being small. Cua says as much: the space they are targeting is “between a brittle script and a general agent loop.” Form fields vary enough that scripts get unwieldy. The set of available decisions stays narrow.

What it does not do

CUA-S1-FORMS does not predict new values for text fields. It does not look at screenshots. It operates on structured elements and values extracted from a document, which means something upstream still has to do the extraction. Cua’s own stack supplies that: Cua Driver handles execution with explicit action boundaries, and the broader repo ships Lume for local macOS VMs on Apple Silicon and Cua Bench for evaluating agents and exporting trajectories for training.

So the honest read is that this is one component, not a product. The current release is forms only. Cua says a general agent encountering something novel and handing well-understood decisions to specialists is “a direction we are looking into.”

The win comes from the decision set being narrow and stable, not from the model being small.

Why this matters for builders

The computer-use agent conversation has been dominated by scale: bigger models, more screenshots, longer context, more tokens per step. Cua’s release is a counterexample with numbers attached. It suggests that a meaningful fraction of agent decisions are classification problems wearing an agent costume, and that those decisions can be pulled out of the expensive loop entirely.

That has three practical consequences.

First, cost and latency stop being a function of the general model for the scoped subset. If 7–9 ms local scoring replaces 260–280 ms hosted calls for the bulk of form decisions, the economics of running an agent at volume change. Cua has not published end-to-end completion times, so treat the primitive gap as directional until someone measures the full loop.

Second, verifiability improves. A probability over four named choices can be logged, asserted on, and regression-tested. Cua’s evaluation is itself a small artifact you can rerun, because the synthetic data generation and eval code are in the repo.

Third, the routing problem becomes the interesting one. If specialists handle bounded decisions and a general model handles the novel ones, someone has to decide which is which at runtime. Cua’s architecture puts that ordering in application code: the model scores elements together, your code orders the actions, Cua Driver executes them one at a time. That is a deliberate choice to keep the model out of the control flow, and it means the failure mode when routing goes wrong is an application bug, not a model hallucination.

What to watch

The comparison against hosted Jev is a scoped-specialization experiment, and Cua says so. The open question is whether the pattern generalizes past forms. Forms are unusually friendly: the element set is structured, the action vocabulary is four items, and synthetic data is easy to generate at volume. A specialist for, say, navigating an unfamiliar settings menu has a much larger action space and a much harder labeling problem.

Cua’s ask at the end of the HN post is pointed. They want to hear from people building computer-use agents who have hit a recurring decision that is too variable to script but too narrow to justify another LLM call. That is the right question, and the answer will determine whether CUA-S1 is a one-off demo or the start of an architecture.

The weights are on Hugging Face. The training code is MIT. The reproduction cost is under 30 minutes. That is a low enough bar that the next few months should produce an answer.