Why AI browser agents still feel slow
If you have tried an AI browser agent, you probably know the feeling. You describe a task in plain language, the agent opens a page, and then you wait. It clicks a field. You wait. It types a value. You wait again. A job that would take you twenty seconds by hand stretches into a minute or more, and somewhere along the way you start to wonder whether it would have been faster to just do it yourself.
The reason is not that the agent is clumsy. It is that almost every step it takes goes through a large language model. Before each click, the agent has to look at the page, describe what it sees, ask the model what to do next, and wait for the answer to come back. Then it acts, looks at the page again, and repeats the whole cycle. The browser itself is fast. The waiting happens in the round trip to the model, and it happens over and over, once for every move.
That makes the time each LLM call takes the real speed limit of browser use. You can make the browser faster, the network faster, the agent's code cleaner, and the task will still be dominated by the moments spent waiting for a model to think. A model that writes an essay or reasons through a hard problem is doing exactly what it was built for. A model that is asked, a few dozen times in a row, "which of these buttons should I press?" is being used as a very expensive and very patient switch.
For everyday work, this is the difference between a tool you use and a demo you admire. Filling in a form, checking a status in an admin dashboard, changing one setting buried three menus deep: these are exactly the chores people want to hand off, and they are exactly the chores where waiting on every single click makes the hand-off pointless.
The missing piece engineers were waiting for
Many engineers working on browser agents arrived at the same conclusion. Making the language model faster helps, but it does not change the shape of the problem. As long as every step needs an LLM call, the agent is bound by how quickly those calls return. What was really needed was something different: a way to complete browser tasks without calling an LLM at every step.
It helps to look closely at what each step actually asks for. Most of the time, the agent is not writing anything new. It is looking at a page with a known set of options — these links, these buttons, these input fields — and picking one. That is a decision, not a piece of writing. The answer is already on the screen; the only question is which one.
A model built to generate long, open-ended text is a powerful but roundabout tool for that kind of question. What browser agents were missing was a model built for the question itself: something that could look at the current situation, choose from the options that actually exist, and answer quickly and in a form software can use directly. A handful of engineers had been waiting for exactly that kind of tool to appear.
September 15, 2026: Jev arrives
On September 15, 2026, TypeSafe AI released Jev, which the company describes as its first "System One" model. In TypeSafe's words, it belongs to a new class of frontier models built to make fast, structured decisions that software can use directly. Instead of producing text, it takes the current state as input and returns a typed decision. Jev is currently available in early access.
For browser agents, that is precisely the missing piece. The question "which of these elements should I act on, and how?" no longer has to be phrased as a request for prose and then parsed back into an action. It can be asked as the decision it really is, and answered as one.
That is why we believe Jev has the potential to improve browser use dramatically. If the step that used to dominate every action — waiting for a language model to talk its way to a choice — can be replaced by a fast, direct decision, then the speed limit that has held browser agents back starts to move. Tasks that felt like watching someone else think could start to feel like watching someone who already knows what to do.
We want to be careful with the word potential, though. A new kind of model does not, on its own, make an agent that works.
Why general-purpose sites are still hard
Making something like Jev work on one carefully chosen website is one thing. Making it work across the open web — on any site a person might actually use — is still hard, and it is where most of the real work lies.
Every website is built differently. Two pages that look alike to a person can be put together in completely different ways underneath. A button on one site may be a link on another, a menu may only appear after you hover over something, and a search box may quietly turn into a different element the moment you click it.
Websites also keep changing. Designs are refreshed, pages load in stages, content appears a moment after the page claims to be ready, and pop-ups and banners slide in on top of the thing you were about to click. An agent that sees the page a fraction of a second too early, or acts on a button that is about to be covered, can make the wrong decision even when the decision itself was sound.
Some moments simply need a person. Logging in, confirming a payment, or approving something on a phone are not obstacles to be clicked through; they are points where the right move is to hand control back, clearly and at the right time.
And the job is rarely finished just because the clicking stopped. Often the person wants something back: a number on a dashboard, a confirmation that an order went through, a value they asked to look up. Knowing when a task is truly done, and returning the result to the person who asked, is part of the task.
None of this is solved by a faster decision alone. A fast decision based on the wrong view of the page is still the wrong decision. Turning a promising model into an agent you can trust on everyday websites takes a great deal of careful engineering around it.
What we're building with Computron
That engineering is what we are doing with Computron. Our goal is simple to state: make it possible for an AI to carry out browser tasks quickly and reliably on the websites people actually use, not just on the ones that happen to be easy.
Computron runs in your everyday Chrome, with your tabs and the logins you already have, so the agent works where your work already lives. We treat speed as the thing we are optimizing, but never at the cost of getting the task right: an agent that finishes fast and finishes wrong has not saved anyone any time. When the agent reaches a point where only a person can continue, it should say so plainly and tell you what to do next, rather than spinning quietly in place.
Jev gives us a way to take the waiting out of each decision. The rest of our work is making those decisions land on the right thing, on real pages, again and again. Computron is still in development, and we are testing it against real websites every day.
From the browser to the whole computer
Why does this matter beyond saving a few seconds here and there? Because so much of what people do on a computer is not the work they care about. It is the work around the work: copying a value from one page into another, clicking through the same settings screens, checking the same dashboard every morning, filling in the same kind of form for the hundredth time.
We want people to be able to hand all of that to AI — every operation they perform in a browser today, and in the future, every operation they perform on a computer. When an AI can do those tasks quickly and correctly, the hand-off finally makes sense. You describe what you want, you get on with something else, and the result is there when you come back.
The time that frees up is the point. Less time repeating clicks means more time for the things only people can do: thinking up new ideas, making things, solving problems nobody has solved before. That is the future we are building toward. A browser agent fast enough to trust is the first step.