← Darsh Shah / WritingField notes · September 19, 2026
Notes on Jev and browser automation
I'd been hearing good things about Jev for browser work. I wanted to try it, and I wanted to understand what people meant when they said it was fast.
I started by comparing ways of controlling a browser. Then I narrowed the question: how much of the wait comes from choosing the next action?
I used Codex to put together a test with Jev and GPT-6 Astra. Same browser controls, a few real websites, and a recording of each attempt with the timings beside it.
What I tested
There were four tasks: find a chapter in Python's documentation, open Wikipedia in Spanish, find the newest Hacker News stories, and search Amazon for a basic notebook under $10.
The Amazon task went further: choose a notebook, add one to the cart, check the quantity, then try to reach checkout. I wanted something with a few more steps than following a link.
For these runs, Playwright controlled the browser for both models. The harness, meaning the code around the model, read the page, supplied possible actions, carried out the chosen action, and checked the result.
The model had a limited job: choose from those actions. It wasn't looking at screenshots or figuring out an entire shopping trip on its own. That makes the task easier, and it matters when reading the results.
Watch the runs
Choose an example, switch between Jev and Astra, and press play. The times beside the model names cover the active workflow. Open Details and timings for the breakdown, repeat attempts, and source data.
The recordings run at their original speed. The log beside each recording comes from that run's timestamps, so you can follow what happened during the pauses.
What happened
Both models completed all six attempts across the three navigation tasks. Each made eight decisions. Jev's median decision time was 351 ms; Astra's was 4,270 ms, or about 4.27 seconds.
On Amazon, Jev took 6.48 seconds for the active workflow. Astra took 30.19 seconds. Each made five decisions.
Both got one notebook into the cart and verified it. Both then hit Amazon's sign-in screen. So this was a search-to-cart test with a checkout attempt; neither reached the actual checkout page or placed an order.
The under-$10 limit applied to the item price. Shipping and tax weren't included.
Jev was quicker in these runs. That's encouraging for a workflow where the software can give the model a clear set of choices. I'd be careful about extending that result to browser tasks in general.
Where the comparison gets messy
The browser controls were the same, but the model interfaces differed. Jev used the TypeSafe API directly, reusing the same HTTP client. Astra ran through a fresh Codex process for each decision, at low reasoning effort.
For Jev, the decision timer covered the request through a validated response. For Astra, it covered Codex's reported turn interval. Process startup was measured separately, though it still counted toward the total workflow time.
That means these numbers include the effects of the two integrations. They don't isolate the time spent generating an answer inside each model. Using the same browser doesn't remove that difference.
The sample is small, too. Each navigation task ran twice per model. Amazon had one recorded attempt per model, with Jev going first. A slow page load or a different set of search results could affect another run.
I also wanted timings in microseconds. The viewer supports that, but the extra digits don't make the measurement that precise. The videos are 25 fps; they're useful for seeing the sequence, not checking a microsecond-scale difference.
What I'd test next
The next comparison I'd want is more runs through more closely matched model interfaces. I'd also make the tasks less guided: a missing button, an unexpected page, or a choice the code hadn't already narrowed down.
This experiment helped me see where the waiting happened in a small, guided workflow. I'm still curious how much of Jev's speed would carry over when the model has more of the job to figure out.
Measurement notes
- Every attempt used a fresh guest browser context, the same Chrome binary, and the same Playwright controls.
- Each integration had one unscored warmup. Model order was randomized within each navigation task and repetition. Amazon ran Jev, then Astra.
- Code checked destination URLs and rendered text independently of the model. On Amazon, it also checked product price and cart quantity.
- Active workflow time excludes the initial website load and the recording's opening and closing pauses. It includes the full model integration and work between calls.
- The recordings capture the browser page only. The side log was added afterward from the same run's events; desktop activity isn't part of the capture.
- Timings use a monotonic clock. All 14 recorded attempts and their source data are available in the viewer. Earlier Amazon implementation trial summaries remain in its JSON report.