Automation · 5 min read
Jev and typesafe.ai: A Plain-English Intro to Intent-Based Browser Automation
A plain English look at Jev, typesafe.ai's intent based automation model, and why telling software what you want beats hardcoded clicks.
If you have ever relied on a website form, a booking flow, or an internal tool that automates a repetitive task, you have probably run into the same problem eventually: it breaks the moment something on the page changes. A button shifts a few pixels, a developer renames a CSS class, and suddenly the automation that worked yesterday clicks the wrong thing or clicks nothing at all. That fragility is the main reason browser automation has a reputation for being unreliable. A newer approach, built around describing what you want instead of exactly where to click, is starting to change that.
What intent-based automation actually means
Traditional browser automation works by pointing at exact coordinates or specific code selectors: click the button with a particular id, type into the third input field, wait two seconds, repeat. It works right up until the page changes, and pages change constantly. Redesigns, A/B tests, and routine code cleanups all quietly break scripts that depend on exact structure.
Intent-based automation flips the instruction. Instead of describing where an element sits in the underlying code, you describe what you want in plain words, something like "click the Save Image button" or "fill in the email field." The system figures out which element on the page actually matches that description, right now, as the page currently looks. If the page changes tomorrow, the description still holds even when the underlying code does not.
The agent says what it wants in plain words. The model reads the page and figures out how, so a single click costs one step instead of several.
How Jev works, without the jargon
Jev is typesafe.ai's model built specifically for this job (model id jev-latest, served through api.typesafe.ai/v1/systemone). When an automated agent needs to interact with a webpage, it does not hand a giant dump of the page's raw structure to a language model and hope it picks the right thing. Instead, Jev takes what is called an accessibility snapshot, a structured map of every clickable and readable element on the page, and resolves the plain-English request directly against that map. It picks the matching element and acts.
That matters for two practical reasons. First, the raw snapshot never has to travel back into the calling agent's own memory, which keeps the whole process fast and cheap to run. Second, a single action, like clicking a button or filling a field, happens in one step instead of the usual several: take a snapshot, read through it, decide, then act, then verify. Cutting that down adds up quickly across a real workflow with dozens of interactions.
Built to say it is unsure instead of guessing
The part worth paying attention to is what happens when Jev is not confident. Rather than picking the closest match and hoping for the best, it returns a result marked as not acted, along with its top alternatives, and lets the calling agent decide what to do next. It is also safe by default: it will not take a live action at all unless explicitly told to, running in a dry-run mode otherwise. For anything touching a live website, a real form, or a real publish button, that caution is exactly what you want from an automated system.
Why this matters if you run a business, not a codebase
You may never write a line of automation code yourself, and that is fine. What matters is what this approach means for the tools built on top of it. Booking systems, lead capture forms, chatbots, and internal dashboards all rely on software that interacts with a webpage, and all of them benefit directly from automation that describes intent instead of memorizing brittle coordinates. It is less likely to silently fail after a routine update, and when it does hit something it cannot confidently handle, it says so instead of doing the wrong thing quietly.
| Traditional automation | Intent-based automation |
|---|---|
| Targets exact selectors or coordinates | Targets plain-English descriptions of intent |
| Breaks silently when the page layout changes | Re-resolves the match against the current page |
| A single click can take several steps to read, decide, act, and verify | A single click typically takes one step |
| Usually acts even when unsure | Reports uncertainty instead of guessing |
Where this fits into what we build
At Lipsum, this is the same category of problem we solve for clients every week: custom apps, automated lead workflows, and tools that scrape or move business data without a person babysitting every step. Reliable automation is not a nice-to-have, it is the difference between a tool that saves you hours and one that quietly creates more work fixing what it broke. As we automate content and lead pipelines for clients, this is a direction we are watching closely, and it is already shaping how we think about the tools we build next.
If your business runs on a workflow that keeps breaking, whether that is a booking system, a lead form, or an internal tool nobody wants to touch anymore, we would like to hear about it. Get in touch or see what it costs to get it fixed properly.
Questions people also ask
What is intent-based browser automation?
It is an approach to automating tasks on a webpage where you describe what you want in plain language, and the system resolves that request against the current state of the page, rather than relying on fixed code selectors or coordinates.
What is Jev?
Jev is typesafe.ai's model, with model id jev-latest, built for resolving plain-English requests into specific actions on a webpage. It uses an accessibility snapshot of the page rather than raw code to find the matching element.
Is intent-based automation safe to use on live websites?
Yes, when it is built with safeguards. Jev, for example, runs in a safe dry-run mode by default and only takes live action when explicitly told to, and it reports uncertainty instead of guessing when it cannot confidently match an element.
