A browser agent that completes flight searches in about 7 seconds; a game controller that operates Mario by reading game states without looking at screenshots; and AI integrated into drone simulations that determines whether to go around or ascend past obstacles ahead.

These projects share a common point: the AI responsible for determining the next step is called Jev.

It has a rather counterintuitive characteristic: it does not generate chat replies.

You can't make it write an article like ChatGPT does. But you can give it a scenario, a few questions, and it will quickly return choices, scores, and probabilities.

This strikes me as interesting: we tend to evaluate AI based on "how deep it can chat, how well it can write," but in the many moments that require intelligence during software operation, the real problem is often just a small question: what should happen next?

1. How to understand Jev? Equipping software with a judgment function that understands semantics

First, let's look at a daily scenario.

A user sends a message: "I've been charged twice, the customer service hasn't replied in three days, if this can't be solved I'll cancel my account."

If a chat model handles this, it can write a comforting reply to the user. However, before replying, the customer service system has a few decisions to make: which team should handle this message? How urgent is it? Is the user requesting a refund?

This is where Jev fits in. Developers pass the message to it, then define the questions and the range of answers:

The official terms for these three categories of questions are Choice, Score, and Noul. They can be included in the same call, judging around the same material separately. The input does not need to be organized as neatly as a database; natural language and JSON can both be used; the output is the values that the code can directly use.

If you've written code, you can think of it as a kind of "semantic if."

Traditional rules are good at judging "is the amount greater than 100," but "is this customer about to lose patience" is tough to write completely with a few keywords. Jev aims to fill the gap in judgments that are quickly understandable to people yet hard to exhaustively list rules for.

TypeSafe refers to this type of model as System One, borrowing the concept of "System One" from "Thinking, Fast and Slow," emphasizing quick, focused judgments. This is the product positioning and metaphor, and does not equate to the model truly possessing the intuitive system of the human brain. Currently, Jev accepts text inputs and cannot directly see images or hear audio.

You might ask: Large models can also output JSON, what's new about this?

The truly noteworthy aspect is that it has created a specific category of model service for "making judgments for programs." According to TypeSafe's introduction, Jev uses a reinforcement learning approach focused on calibrated decision making, RLCD, as well as a parallel output mechanism; it does not need to first generate a natural language response and then let the program find the answer within it.

The official response time is between 70—500 milliseconds, and the input cost is $0.042 per million tokens, while output is free. These are vendor-supplied data, and actual speed is also influenced by input length, network, and deployment location. As for the advertised advantage of dozens or hundreds of times, there are specific tasks and comparison conditions, which should not be directly understood as all AI applications speeding up by that much.

A conforming answer does not mean that the judgment reflects the facts.

When the options are limited to "Billing, Technical, Account," the model will not return an undefined department out of thin air, but it could still assign billing issues to the technical team.

2. What tricks can it perform? These cases can spark your imagination

1. Seven-second flight search: reducing waits for the browser's "brain"

The jev-ultrafast from Browser Use demonstrates a very intuitive application: giving the browser a natural language goal to search for flights from Zurich to London on Google Flights.

The program organizes the actionable elements on the page, while Jev is responsible for choosing actions and targets. When inputting city names or other text, another model generates the content. Thus, there are different entities responsible for “which button to select” and “what text to input.”

In the small-scale tests published by the project, the median time to complete tasks after optimization was about 7.1 seconds.

An agent that has to perform a series of steps can significantly improve the whole experience by saving a bit of wait in each step. What the user ultimately feels is that the software finally keeps pace with their rhythm.

2. Playing Mario without looking at the screen: first translating the world into information usable by the model

The approach of typesafe-mario is even more interesting.

It does not send game screenshots to Jev, but extracts information from emulator telemetry and RAM: how Mario moves, the trajectory of jumps, where the enemies and terrain are, and organizes that into compact JSON.

Jev selects one of the legal actions like "move right," "jump," or "run right and jump," the emulator executes several frames, and then sends the new state back. It is an experimental controller and should not be claimed to possess stable completion capabilities merely based on warehouse demonstrations.

The cleverness of this example lies in the fact that: AI does not necessarily have to participate in games in the way humans see screens.

If the system already knows the character's position and the distance to enemies, providing that information directly to the model often saves more effort than having it recognize anew from pixels. There’s also something to learn here about how developers can organize complex scenes into a determinable question.

3. Serving as an advisor for drones: when blocked, ascend

The jev-drone carries this line of thinking into the MuJoCo drone simulation.

The visual processing code first converts camera information into a concise scene description. Jev then assesses whether to maintain the path, look for openings to the left, navigate around to the right, ascend, or brake, at a frequency of about 2.5 times per second.

The author reports that in one segment of an obstructed path, simpler rules favoring the wider side would be blocked by beams; after integrating Jev, the system could choose to ascend and complete the route.

What’s particularly noteworthy is its division of labor: the underlying flight control runs at 500Hz, the safety layer operates at 50Hz, and Jev only provides tactical suggestions, while the code retains veto power.

The model may suggest "fly up," but the program must still check for space above and climbing conditions. This case occurs in a simulation environment but clearly shows how to integrate semantic judgment into a real-time system.

4. Selecting buy or sell for each block: embedding decisions into high-frequency loops

Jarrod Watts’ jev-trader reads the MON-USDC order book on Monad, selecting buy or sell directions around a rhythm of approximately 300 milliseconds per block, then processes limit orders through code.

What’s valuable here is the engineering structure: reading the market, judging direction, managing orders, updating state, all chained into a continuously running pipeline. Quick loops do not constitute evidence of profitable strategy.

Furthermore, those interested in observing it should note a small detail: the project defaults to using a mock heuristic model. You must set MODEL=jev and provide the corresponding API Key to actually call Jev; you can run a dry-run without providing a private key to read the real order book and simulate execution.

5. Putting a filter on your own information flow

Compared to gaming and trading, I find Your Signal closer to the daily lives of ordinary people.

This is a Chrome extension. You set your interests and filtering preferences, and Jev assesses the text of posts visible in the X timeline: relevant or not? Does it have substantial content? Is it promotional or an interactive bait? The extension highlights, dims, collapses, or hides content according to your settings, and these display changes can be undone.

It requires your own Jev API Key, and the text is sent to a remote API for processing; it does not run offline. The Your Signal project

This direction easily leads to further imagination: resource collections, RSS readers, work message lists, all have extensive “is this worth my attention” judgments. Inexpensive semantic judgments expand the experimental space for personalized filters.

3. What interesting open-source projects are there? Choose based on your tinkering preferences

After watching the demonstration, if you want to get hands-on, I would divide these projects into a few routes. Most of them open up application code, but still call Jev services during operation; don't interpret "project open source" as "Jev model weights open source."

My suggestion for getting started is: first choose a small task where you can judge right from wrong. For example, label a batch of emails manually, and then compare the model’s results. Seeing firsthand where it makes mistakes is more helpful in understanding it than merely focusing on the speed in demonstrations.

4. What insights does Jev offer for AI development? Intelligence will increasingly be embedded within software

What interests me most about Jev is that it makes a type of product format more concrete: AI can be a small part called upon at any time.

The following points are judgments I've made from these projects, which require broader actual usage to verify.

First, the division of labor in AI systems will become more detailed.

Within a task, planning, generating text, selecting tools, checking risks, and executing actions require different capabilities. The browser case has already laid out this division: some parts are responsible for writing, while others are responsible for selection, and the program executes. What developers need to do is connect these into a workflow that is suitable in terms of speed, cost, and success rate.

This also means that when we evaluate agents, we cannot only ask which is the strongest model they are using. Whether the right method is used in each part also affects the final experience.

Second, after judgments become cheap enough, some functionalities that were not worth doing begin to become worthwhile.

Categorizing ten emails is certainly useful, but if every piece of information, every candidate result, and every tool call can be judged again at a very low cost, the design space for products expands.

A personal information flow filter is one example. Users do not need to actively open chat windows; AI is already judging in the background which content deserves more attention. My expectation is that similar capabilities will gradually enter search, reading, customer service, and automation tools, becoming functionalities that users may not see but can feel.

Third, how models express uncertainty will affect how much work software dares to delegate to them.

"Selected A" offers one execution path; "Both A and B are possible" reminds the program that the next step may need to supplement information or escalate processing.

In my view, truly valuable automation can handle familiar situations while navigating towards the appropriate next step in times of uncertainty.

Finally, the engineering design around models remains very critical.

Breaking down a complex task into a series of sufficiently clear small judgments is the common engineering effort behind these demonstrations.

Therefore, I will continue to pay attention to Jev, as well as projects that grow in this direction. They provide a very concrete vision: in the future, when we open software, AI might have already completed routing, filtering, and the next step selection in the background, leaving us with a simpler interface.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。