A few years ago, autocomplete finished your line of code. Today, coding agents open a pull request, run the tests, read the failures, and try again until the build is approved. On the surface it looks like one thing grew into a better version of itself: autocomplete got smart enough to become an agent.
But anyone who has built these systems knows the gap between them is enormous, with years of work sitting in between. We are now crossing that same canyon on the web.
Autocomplete and a coding agent both produce code. That shared output hides the fact that they solve different problems. Autocomplete predicts the next token and lives in a world of text, where the only question is what a plausible continuation looks like, and a human decides whether to accept it. A coding agent lives somewhere else, inside a system that pushes back. When the compiler rejects it, or the test suite fails, the agent has to read that resistance and respond to it, over and over, until the system stops objecting.
I think of this as the difference between the first mile and the last mile of a capability. The first mile is imitation: learn from a large pile of examples what good output looks like. It is a hard and useful problem, and autocomplete is a serious achievement. The last mile is where the world can change and actions can have consequences.
The Web Is Now Living Through Exactly This Jump
The first mile of web agents arrived a couple of years ago. By 2023, systems from companies like Exa, Parallel, and Perplexity could read a webpage and answer a question about it. Point them at the internet and they would retrieve, summarize, and synthesize. That reshaped search, but notice what it shares with autocomplete: the page holds still. The agent reads and reports, and nothing it does changes the world on the other side of the screen.
That was sufficient for basic search, but failed on dynamic content like ticket prices or gym class availability. A live website can push back the same way a compiler does. If a layout shifts or a session times out, a step that worked yesterday can fail today.
The last mile is different. Instead of reading a form and telling you what is on it, the agent fills it out and submits it. A capable web agent can string a task across several sites and finish it end to end: search, compare, log in, enter the details, complete a checkout, and come back with a confirmation. And it has to do all of that while things break underneath it, like if the login expires, or the field rejects what you typed. This is the web version of the operations people grind through by hand every day, multi-step tasks a human can click past without thinking and an agent has to learn to survive.
Why the Last Mile Needs a Different Recipe
You cannot learn to act by reading more text about acting. At some point, you have to act. That means putting the agent inside environments, sandboxed or live, where it can take steps and get feedback from what happens.
At Yutori, training our own web-use Navigator model began the way the first mile always does, by imitation. We showed it a large set of real navigation sessions, including the messy and failed ones, so it could build a general picture of how the web behaves, then concentrated it on the clean, successful runs so it learned what good looks like. That produced a strong reader and a serviceable actor, but not enough for the live web.
The behaviors that survive contact with a website came from the next stage, reinforcement learning. We placed the model in environments, some real and some simulated, let it act, and rewarded it on whether the task actually got done rather than whether the attempt looked plausible. That is where it picked up the instincts a human operator takes for granted. It learned to verify its own progress before committing to a click, to plan a task before diving in, and to back out of a dead end and try another route when a site misbehaved. In one case it learned to pause and check a detail mid-task that it would otherwise have blown straight past.
A year back, models trained largely via imitation alone could only do workflows spanning 5-10 navigation steps reliably. Now, models like Yutori’s Navigator n1.5 goes out and performs tasks that are hundreds of steps long, routinely hitting a long tail of hundreds of thousands of websites spread across languages and geographies. What it learned inside a simulated site carried over to the real version, even when it hadn’t been seen by the agent.
The arc of AI bends at the point where the problem shifts from prediction to consequence, and the tools that carried you up the first slope are not the tools that carry you up the next one.
The good news is that we are well into that bend now, in coding and on the web alike. Agents that read are giving way to agents that act, the same way autocomplete gave way to coding agents that ship. The teams that treat that last mile as its own problem, and build for it directly, are the ones who will make it ordinary.
