A model looks at a screenshot of a restaurant's booking page, decides the reservation button sits at pixel (612, 388), clicks it, fills the form, and pauses to ask whether you actually want to confirm the table for four. Nothing surprising there — except this is running on the same class of laptop you're reading this on, with no cloud round-trip, and the model steering it has 7 billion parameters.

That model is Microsoft's Fara-7B, and the number worth staring at isn't its 73.5% success rate on the WebVoyager benchmark. It's the parameter count. Computer-use agents have, until now, meant either a frontier-scale hosted model or a research demo that falls over on real sites. Fara-7B lands in a different place: small enough to run on-device, good enough to compete with systems several times its size.

The lesson underneath it is the part I want to argue. The bottleneck for computer-use agents was never model scale. It was data — verified demonstrations of an agent finishing real tasks on real websites. Solve that cheaply and frontier-competitive computer use collapses into a model that fits on your machine.

What "computer use" actually means

A computer-use agent (CUA) drives a graphical interface the way a person does: read the screen, move the pointer, click, type, scroll. The genuinely hard part is grounding — turning "click checkout" into an exact coordinate on one specific rendered page that no one has seen before.

There are two schools. One feeds the model an accessibility tree or a parsed DOM, or runs a second detection model to tag every clickable element first (the "Set-of-Mark" approach GPT-4o uses in these evaluations). The other reads raw pixels and predicts the coordinate directly. Fara-7B is firmly the second kind. Its only inputs are the current screenshot, your instruction, and its own history of actions — no accessibility tree, no DOM dump, no auxiliary parser. It sees what you see and clicks where you would click.

That's not a stylistic choice. Accessibility trees are frequently incomplete or wrong, and a separate parsing model is both added latency and a second thing that can fail. One model, pixels in, action out, is a simpler and more honest contract with the page.

The actual trick is data, not size

Fara-7B is built on Qwen2.5-VL-7B with a 128k-token context, trained by plain supervised finetuning — no reinforcement learning. So where does the skill come from? A synthetic-data pipeline called FaraGen, built on Microsoft's Magentic-One multi-agent framework, with three stages:

Task proposal — generate plausible tasks from live URLs across categories like shopping, travel, and restaurants.
Task solving — a multi-agent system actually completes each task on the real site, recording the full trajectory.
Verification — three independent verifier agents check that the trajectory genuinely succeeded before it's kept.

The output: 145,603 verified trajectories totaling 1,010,797 steps across 70,117 domains — produced at roughly $1 per verified trajectory. That last figure is the whole game. Human-recorded computer-use demonstrations are scarce and expensive; FaraGen manufactures them, filters them hard, and does it at commodity cost. The model is what falls out of the pipeline, not the other way around.

The numbers

Head to head, per-task success rate:

Benchmark	Fara-7B	GPT-4o (SoM)	OpenAI computer-use	UI-TARS-1.5-7B
WebVoyager	73.5	65.1	70.9	66.4
Online-Mind2Web	34.1	34.6	42.9	31.3
DeepShop	26.2	16.0	24.7	11.6
WebTailBench	38.4	30.0	25.7	19.5

WebTailBench is Microsoft's own new benchmark, aimed at tasks the existing sets underweight — restaurant reservations, job applications, real estate search, comparison shopping, multi-site compositional flows. Be appropriately skeptical of a self-authored benchmark, but note Fara-7B also tops the independent ones against a hosted computer-use model and a same-size rival. A separate Browserbase run with human annotators scored it 62% on WebVoyager — below the 73.5 self-report, which is the ordinary gap between lab conditions and the open web.

Efficiency is a path-length property

The number I keep returning to isn't a success rate. Fara-7B finishes tasks in about 16 steps on average, versus roughly 41 for the same-size UI-TARS-1.5-7B, at comparable token pricing. Each step is a full screenshot → reason → act loop. More than halving the step count is what makes local execution feel practical: fewer inference passes, less latency, less cost, and fewer opportunities to wander into the wrong part of a page. Efficiency here isn't about cost per token — it's about how many moves the agent needs to reach the goal.

Point an agent at your logged-in sessions and an errant "buy" click becomes a real liability. Fara-7B builds in a Critical Points mechanism: it stops before any action that commits a transaction or hands over personal data and asks the user to confirm. On WebTailBench-Refusals — 111 adversarial red-teaming tasks — it refuses 82% of the time.

An 18% failure rate under adversarial prompting is not something you aim at your bank account. But consent is wired into the action loop rather than bolted on afterward, and every step is logged and auditable.

Why "local and open" changes the calculus

Fara-7B ships under an MIT license, on Hugging Face and Microsoft Foundry, with a quantized build for Copilot+ PCs reachable from the AI Toolkit in VSCode. Conceptually, each step the model produces is a short reasoning trace plus a grounded action:

{
  "reasoning": "The reservation form is open; the confirm button is bottom-right.",
  "action": { "type": "click", "x": 612, "y": 388 },
  "critical_point": true
}

Because inference is local, the screenshots and your authenticated sessions never leave the machine — so the agent can operate on state you'd never post to a hosted API — and latency is a local call rather than a network hop. An MIT-licensed 7B is also something you can finetune on trajectories from your own domain.

The takeaway

If you're deciding whether to build on a computer-use agent, stop indexing on model size and start indexing on trajectory data. Fara-7B's real lesson isn't "7B is enough" — it's that a cheap, ruthlessly verified data pipeline is the actual asset. The move you can copy: stand up a propose-solve-verify loop on the sites your users actually touch, keep only the verified successes, and finetune from there. The weights are MIT. The moat is your verified trajectories.