Skanda Vaidyanath, founding AI researcher at Yutori, presents Navigator n2 at TwoSetAI Workshop #6 (55 min, hosted by Angelina Yang): how a small team trained a 27B computer-use model that takes first place on four of five computer-use benchmarks, and runs long tasks for roughly $1.46 where frontier models cost $10 to $30.

Why a startup trains its own model

  • Yutori’s products (Scouts, Delegate, local) monitor the open web and book things when they appear — a service that breaks if every action costs frontier money.
  • Most of the web has no API: OpenTable, Zillow, Apartments.com, ticket sites. Tool calls are preferred where they exist, but browser use is the fallback that actually works, with the user’s saved login.
  • A year and a half ago the frontier was not reliable enough — agents got stuck on pages, fumbled date pickers, spiralled on unfamiliar sites.
  • Today the frontier is good but too slow and too expensive to run all day: “the frontier was not good enough and right now the frontier is too slow and expensive.”
  • N1 (pure browser use) → N1.5 → n2, the first full computer-use model. Browser use is a subset of computer use, which also drives PowerPoint, Excel and Blender.

The design principle: three modalities, one task

  • Humans use computers through GUIs — click, type, scroll — because we have no choice. A model has three options: GUI, code, and tool calls.
  • Every frontier model has all three. The hard part is training when to use each and switching mid-task, not access to them.
  • A colleague’s line he quotes: models “can code, they can click, but they can’t choose when to use each.” Frontier models often pick one modality, get stuck, and thrash until the trajectory fails or gets far longer and more expensive than it needed to be.
  • Worked example: turn a scanned annual report into a working spreadsheet — read the scanned table off the screen via GUI, switch to code to convert it into Excel, switch back to GUI to verify the result matches what the user expected.
  • The target is weaving the right modality through each stage of a task so the whole trajectory is accurate, reliable, fast and cheap at once.

The data flywheel: agents in every stage

  • Task creation — coding agents write tasks and verifiers, but not in a silo: they don’t know what a GUI offers, so computer-use agents explore applications (“explore PowerPoint and tell me what I can do with it”) as seeds.
  • Stress testing — roll out many trajectories against each new verifier to hunt false positives, false negatives, reward hacks and benchmark leakage before any training happens.
  • Failure analysis — coding agents cluster the trained model’s trajectories into patterns (good at spreadsheet charts, bad at slide formatting) and that drives what data gets created next round.
  • The loop closes on purpose: better models produce better data, mistake patterns shift, and every stage is redone. In a few weeks this produced more than 10,000 tasks and verifiers across hundreds of applications.

Rejection sampling, then RL

  • Two algorithms with two jobs: rejection sampling (RFT) raises pass@K quickly and cheaply — it gives the model basic skills fast — while RL consolidates them into pass@1 and teaches online error recovery.
  • Error recovery is the point of RL for deployed agents: pages crash, VMs misload, apps vanish, a Mac target turns out to be Windows.
  • Hints when needed: if even the best model cannot finish a task, they add a small system-prompt hint to push it over the line and collect the trajectory — then throw those hinted trajectories away later, because a model that knows a hint exists reasons differently.
  • RFT forgets, RL does not: they keep data from every prior round for RFT, while on-policy RL retains easy skills well enough that those tasks can be filtered out.
  • Train on the middle band — tasks too easy or too hard contribute no gradient signal under GRPO, so both are dropped in favour of the band where reliability and recovery can still improve.
  • Implementation choices he calls free wins: fully asynchronous rollouts and training in parallel (one task can take a human one to two hours, so idle GPUs are pure waste), dynamic sampling of the difficulty band online, and FP16 instead of BF16 to shrink train/inference mismatch.
  • Also deliberate: no reference model, no KL term, no discount factor, no process rewards, no length normalisation. They train on the open-source Miles framework (they used veRL before, and mention TRL).

Data quality beats data volume

  • Every verifier is written by coding agents in large batches, so bugs are expected — so trajectories get audited for false positives before they reach supervised fine-tuning.
  • “It’s better for us to make the data higher quality and lose out on some stuff” than to admit low-quality data into training, especially with verifier bugs that could teach the model to exploit them.
  • If the model has drifted far from its initial state, they discard the dataset and recollect from scratch — a one-time cost that yields a cleaner set.

The result

  • 27B parameters. First place on four of five industry computer-use benchmarks and a close second on OSWorld v2.
  • On the cost-accuracy plot, the nearest model with comparable performance is about 10x more expensive; at the same price n2 is over three times more accurate.
  • API pricing: $0.50 per million input tokens, $4 per million output tokens, $0.05 per million cached input tokens — “frontier level computer use on all the tasks you might care about at a price that a product can carry.”

From the Q&A

  • Open weights: discussed internally, no decision yet — “I don’t know if I have authorization to answer this.”
  • Screenshots or DOM: n2 has both and picks per task, which matters for React apps that trap screenshot-only agents.
  • Trustworthiness: he treats OSWorld-style benchmarks as a proxy for judgment — does the agent choose a reasonable path, or click and type its way down a winding route a human would finish in two steps?
  • Human nudges: on local-machine tasks the model adapts surprisingly well to a user working alongside it — again, error recovery doing the work.
  • Bot defences: computer use is mostly safe because it acts on a VM; browser use on the open web runs into bot detection and captchas. Agentic payment platforms suggest the ecosystem is moving toward agents as buyers.
  • Who pays when an agent buys the wrong thing: a clear instruction makes it the agent’s fault; a personal agent expected to know what you never said is a grey zone — someone in the audience suggested insurance against personal agents.
  • Are landing pages dead? “It does feel like it’s going that way” — he mostly goes through ChatGPT or lets agents act for him now.

“Computer use models help generate better computer data for themselves. As we get better models, we get better data, and you can keep continuing this loop until you saturate your results.”