Navigator n2: frontier computer use at a fraction of the cost

Today, we’re introducing Navigator n2.

n2 is a 27B frontier-level computer-use model that advances the cost-accuracy Pareto frontier.

Unlike Navigator n1 and n1.5, which specialize in browser use, n2 is a general-purpose computer-use model that can operate full desktop environments across Linux, macOS, and Windows.

n2 reliably interleaves and drives desktop apps, browsers, CLIs, and even writes short snippets of code -- doing whatever it takes to get tasks done efficiently.

And at $0.5 / M ($0.05 / M if cached) input and $4 / M output token pricing on our API, n2 brings these state-of-the-art capabilities to a new cost class, making it a compelling option for building powerful computer-use agentic experiences and knowledge workflows at scale.

Table of contents

• n2 is frontier-level across computer-use benchmarks
• Computer-native computer use
• Training n2
• Get started with n2
• Detailed benchmark table

n2 is frontier-level across computer-use benchmarks

Navigator n2 demonstrates strong performance across a diverse suite of computer-use benchmarks:

• OSWorld 2.0: 65.2%. Long-horizon, complex real-world computer-use workflows.
• OSWorld-Verified: 85.3%. Open-ended tasks across real desktop and web applications.
• MyPCBench: 82.6%. Personalized computer use across a user’s apps, accounts, and digital history.
• MacAgentBench: 83.1%. Real-world macOS tasks spanning 25 applications and both GUI and CLI interaction.
• WeaveBench: 70.3%. Tasks requiring agents to combine GUI interaction with CLI and code execution.

Computer-native computer use

Humans use computers through interfaces designed for humans. Computer-use models don’t have to.

Navigator n2 is trained to intelligently interleave the full range of interfaces on a computer: GUIs, CLIs, tools, and code. It can click through an application when visual interaction is needed, use the shell and command line for system operations, call tools to retrieve structured data, and write code when that is more efficient.

Access to all interfaces is important for both efficiency and performance. A GUI-only agent is unnecessarily constrained. Tasks that take one shell scripting step can otherwise turn into many GUI steps: for example, renaming 100 photos from IMG_1337.jpg to paris-trip-001.jpg is one for loop in the shell instead of 100 rounds of right-click → rename → type → enter via a GUI. Similarly, computer use cannot be reduced to programmatic interfaces alone. Many real-world tasks ultimately require interacting with native applications, live websites, and visual states that cannot be fully accessed through code or APIs.

But access alone is not enough. On complex, long-horizon tasks, models also need to decide which one to use at each step and when to switch. OSWorld 2.0 [1] and WeaveBench [2] analyses show that when tasks require both GUI and programmatic interactions, today’s frontier models can still struggle: either being persistent on a suboptimal interface, or bouncing between them without making clear progress. Navigator n2 is trained to choose the right interface at the right time, and to interleave them to make steady progress on the task.

We think this is where computer use should be headed: not forcing models to use computers exactly the way humans do, but enabling them to intelligently use everything a computer can do.

Training n2

Data generation for computer use is itself a computer-use task.

We use computer-use agents (CUA) throughout the training data loop. During task creation, CUA rollouts help with exploration: they interact with native applications and determine what is actually feasible in these environments. This grounds new tasks in actual application logic, instead of just knowledge-based assumptions or instruction manuals.

For every task, we also generate corresponding verifiers. A verifier is the test that decides whether the task was actually done. It inspects the end state of the environment, not the agent’s self-report of what it did. Some verifiers are programmatic: query the database, diff the file, check that the calendar invite exists. Others are LLM-based rubrics, for tasks where success involves softer logic rather than a set of assertions.

We then stress-test candidate tasks and verifiers with CUA rollouts to surface false positives (where agent behavior was wrong but the verifier deems it correct), false negatives (correct agent behavior, incorrect verification), reward hacks (correct outcome, but achieved through unintended agent behavior), and other edge cases. Each failure becomes a new test case, and we jointly refine the tasks, verifiers, and even the environments in some cases where the mocked application has bugs or reward-hackable surfaces.

After training (more on this below), we redo this process and analyze rollouts from the new model to identify recurring failure modes and capability gaps. These failures then feed into the next round of task generation. As the model improves, rollouts surface new gaps in environments that need to be co-refined.

This creates a recursive loop: better computer-use models help create and refine better training data, and better training data in turn produces better computer-use models.

Over the past two months, we’ve generated more than 10,000 tasks across hundreds of applications. These tasks span a broad range of domains across personal and professional: from productivity, communication, and business services to engineering, infrastructure, data analysis, creative production, and specialized scientific workflows.

We train n2 with a combination of supervised fine-tuning (SFT) and reinforcement learning (RL). SFT gives the model broad exposure to applications, workflows, and the different ways of interacting with a computer, while RL pushes it to solve increasingly difficult tasks. As training progresses, we continuously refresh the RL set: tasks that become reliably solvable are moved into the SFT stage, while RL shifts toward harder tasks and newly surfaced failure modes. Across both stages, we focus on long-horizon planning and execution, dynamic interface selection, and self-context compaction, enabling the model to comfortably handle complex real-world tasks requiring hundreds of steps.

Alongside this training pipeline, we are exploring new ways to make long-horizon on-policy learning efficient. In our experiments, on-policy self-distillation (OPSD) showed promise, reaching peak performance 4x faster in wall-clock time compared to group-rollout-based RL, and was particularly efficient at learning from tasks with zero success under the current policy. As a pleasant side-effect, it accelerates our recursive improvement flywheel by allowing the data frontier to advance well ahead of the model’s current capabilities.

Get started with n2

Navigator n2 is available today through the Yutori API.

It’s priced at $0.5/M ($0.05/M if cached) input and $4/M output tokens.

• n2 API docs
• Try n2 on the Yutori playground
• Example CUA implementation

Detailed benchmark table

Keep reading

View all

May 06, 2026

Introducing Navigator n1.5

Jan 30, 2026

Introducing Navigator n1

Nov 19, 2025

Introducing Navigator