Building Faster AI Agents with Jev Decision Models and Cline
Modern agents are built around a classic loop: send the LLM a prompt, it thinks, it processes, and it responds back through a chat-based API. This is the interface that has become the foundation of modern AI agents.
While these Large Language Models have been proven to be useful in a lot of tasks, a different approach to interacting with models is emerging through APIs designed for structured decision-making called Decisions API.
TypeSafe AI just introduced Jev, a Decisions model designed to address two of the biggest challenges with traditional LLMs: latency and cost. Jev is reported to be around 194 times faster and 445 times cheaper than traditional LLMs on Typesafe’s workflow evals.
Jev, instead of emmiting tokens like an LLM, classifies for us. It takes its input as a state (the context, in a certain structure) and returns a response in the form of a choice, a score, or a noul (a probability that a statement is true) for each question asked about that state. These values help us rerank , prioritise or take decision on them immediately.
The places we have seen it outshine the classic LLMs are generally the ones that require instant decision making with a structured boundry, a situation where you need intelligence injected just fast enough to take a decision. It can be as simple as a before tool hook that lets Jev take over, decide if the call is dangerous, and then block or pass it.
steering jev
To invoke a Jev model, you send it a state (the context) and questions about that state. Here is a request that asks all three kind of questions about a command a coding agent wants to run:
{
"model": "jev-latest",
"state": "The coding agent wants to run this command in the user's repo: npm install left-pad-utils@latest --save",
"questions": {
"command_kind": {
"type": "choice",
"instructions": "What kind of action this command takes",
"criteria": {
"read_only": null,
"edits_project_files": null,
"network_and_system_changes": null
}
},
"risk": {
"type": "score",
"instructions": "How risky it is to run this command without asking the user",
"criteria": ["Safe", "Worth a look", "Dangerous"]
},
"runs_remote_code": {
"type": "noul",
"instructions": "The command downloads code from the internet and executes it"
}
}
}
And this is what came back, in 318 ms:
{
"command_kind": {
"type": "choice",
"choice": "network_and_system_changes",
"confidence": 0.72,
"probabilities": {
"network_and_system_changes": 0.82,
"edits_project_files": 0.18,
"read_only": 0
}
},
"risk": {
"type": "score",
"score": 1.01,
"confidence": 0.58,
"probabilities": { "0": 0.13, "1": 0.72, "2": 0.15 }
},
"runs_remote_code": {
"type": "noul",
"noul": 0.82
}
}
This response tells that the probability of it pulling code from internet is 82 percent. Your application can use similar checks and call to use Jev to take instantaneous decisions on things that can be bucketed into decisions.
Here are some use cases where Cline takes full advantage of Jev via the Cline harness.
A browser with a wheel
Jev-browser is a plugin that gives Jev a real browser inside Cline.
Most browser agents follow the loop of screenshotting the page, sending it to a model, waiting for it to decide where to click, and then repeat.
While this loop works in complex scenario, sometimes the decisions on a browser can be decomposed to certain decision triggers, this when paired with the speed and cost that Jev brings in, gives us a very fast browser steering engine.
Browser to Jev is a list of things one can act on, like buttons, links and fields, and Jev picks the next action from that list. Jev acts as the classifier, it doesn't write anything, it just picks from buckets, Here the buckets being a theme of what to click and type
Install it from the desktop app under Customize > Marketplace > Plugins > jev-browser. Save a Vercel AI Gateway key to ~/.cline/plugins/cline-jev-browser.config.json and restart Cline.
Then just ask, for example "find one-way flights from Zurich to London on Sep 20 for 1 adult in economy".
Cline hands the goal to Jev, and Jev clicks through the page on its own. When Jev
stops, Cline checks the final screenshot to confirm the job actually got done making this run fast and double verified.
A place for jev to play
jev-playground is a Cline plugin that turns a vague prompt into a Jev request via a web interface.
As we peeked into the Jev API, how it is a bit complicated to decide what goes in as an input for Jev. It becomes a bit challenging to decide that as humans think in proses and sentences.
These places are where LLMs shine and can speed up setting Jev requests for us. This plugin is exactly that, it takes the Cline as the harness and lets the raw intents be translated to Jev requests with an interactive UI to work with and play around.
You send the Cline harness a prompt, and it will set a systematic Jev context and questions set for you to test on.
Like here in this example, we asked Cline to setup playground to setup a Jev input for deciding if a candidate should move to the next interview round, it created multiple questions, buckets and an output visualization for us to decide if the inputs tell if we can hire the candidate.
You can tweak values, buckets and questions on the web interface making it easy for you to setup and perform Jev requests instantly.
You can let Cline set up the data for you, or change values of the request after the first pass.
The work is split in two:
- Cline sets it up. The agent decides which facts matter and which questions to ask, then opens the page.
- You run it. You can edit the facts and questions and press Ask Jev. From that point the page talks to Jev directly, with no LLM in the loop.
Jev that guards your agents
With how instant and cheap Jev is, we can use it as an agent mediator to setup guards and checks at multiple places before anything even reaches the agent’s context window.
jev-guard allows you to create instant guardrails, decide the workspace where they apply, and have all tool calls judged before the LLM can act on it. It sits and acts before every tool call, with faster speed and a cost low enough that you can run it on everything.
You tell Cline what you want to protect, for example "set up a Jev guard for this folder. It's our support inbox agent, and people sometimes try to get refunds sent to other bank accounts or pressure us to skip checks", and it converts your intent into defined guardrails with sample triggers to test from.
Once you set it up via Cline, then it runs on its own. The Cline hook automatically screens every tool result within a guarded folder, eliminating the need for the agent to remember to invoke it.
Set it up once, and then modify it via the web interface as you please, modifying the paths, situations and a lot more.
Wrapping Up
Across all three plugins, the LLM handles the language and Jev handles the quick decisions. This makes it practical to run across every tool result without adding significant overhead.
It gets even cheaper when the LLM side runs on open models. The browser demo above runs on ClinePass - a $9.99/month subscription plan that gives you access to curated set of open-weight models like DeepSeek, Kimi, GLM and Qwen, with ~5x the usage of standard API pricing. Not just this, you can bring any model you like in Cline.
