Confidence before a call
When a model produces an outcome, the result is not always precise. Jev gives us a way to put structured text in and get a yes or no decision out, along with a confidence score. That addresses a practical problem with using large language models as classifiers.
The useful part is the combination of speed, cost, and a predictable result. Sending text to a model for a decision can take a few seconds. The structure is not always correct either. Models have improved over the past year, but Jev stays consistent. Its error rate is very low, and it returns the decision we need from structured text.
From text to decision
Jev is typesafe, and the site includes details about how it runs. It was created by an ex OpenAI engineer. The pricing is also important for this use case. We need a classifier that can make a decision quickly without adding much cost to every request.
That matters when a model is preparing an argument for another system. The model can generate something that looks reasonable while still containing the wrong fields or values. A separate validation step gives us a decision before that argument becomes a tool call.
One entry point for PatchOps
At Solved Systems, we are using Jev with PatchOps. PatchOps is an MCP server for oil and gas. It allows a model to create arguments that are sent through about three hundred and fifty APIs wrapped into connectors. The result is a single entry point for making calls and pulling back data.
The flow is straightforward. An LLM or the surrounding infrastructure creates an argument. PatchOps finds the matching API, makes the request, and returns structured data. The argument validation step sits before that request. We send the generated arguments to a classifier so they can be checked before they create unnecessary tool calls or reduce accuracy.
This is especially useful when the model needs to make a write call. A write call needs to be correct because a bad argument could lead to a destructive call. Validating the argument before the request gives us another control point in the process.
Luna classifier baseline
Before using Jev, we were doing this with Luna. Luna added cost, although the input was about five hundred tokens. We would judge and rank the generated response, which became part of the classifier system.
The Luna flow takes generated text, parses it, processes one token at a time, and produces structured output. That process took about twelve hundred milliseconds, or about one point two seconds. It worked as a way to classify the response, including whether it was a poisoned response or a real argument, but the latency added to tool calls.
The measured latency for the Luna validator was about 1.1 seconds to 1.2 seconds. That is a meaningful amount of time when validation sits in front of a tool call, especially when the system needs to make repeated requests.
Jev validates arguments
With Jev, we can put the generated argument into the validator and receive the real argument after validation. Jev checks whether the arguments are valid and can also provide injection protection. In the flow, Luna can classify whether a response is poisoned or a real argument, while Jev handles the argument validation quickly.
The same process takes 240 milliseconds. A simulated test runs the query and returns an output response with poisoned set to true or false, along with a confidence score. The result appears in 240 milliseconds, so we can see both the decision and the speed of the validation step.
The measured figures show 2.60 milliseconds for the scanner and 2.30 milliseconds for the validator. Those numbers are much lower than the 1.1 second to 1.2 second range for the Luna validator. That difference gives us a faster way to check arguments before they reach the API request.
Testing speed and cost
We have been testing Jev since it was released on Vercel AI gateway. Scores have gone up quite a bit, and cost is going down. The technology is still newly released, but we found a useful place for it in PatchOps.
The immediate use case is argument validation before tool calls, with extra attention on write calls. Jev gives us a fast validation response, a poisoned true or false result, and a confidence score. It also keeps the validation step inexpensive enough to use as part of the request flow.
We are looking for other places to use it. If your company needs technology explored or something developed, reach out in the comments or visit the Solved Systems website and fill out the contact form. Solved Systems can discuss technical solutions to business problems.