When you look at what a Chief of Staff actually does all day, very little of it involves writing essays from scratch ;)
Most of the job is making decisions.
They look at a piece of work, check a result, choose a worker, and decide whether to continue or pivot.
We use large language models for everything. If an agent needs to decide whether a draft is ready for review, we ask a massive conversational model to think about it.
The model generates a polite preamble, thinks through the logic one token at a time, and eventually outputs a yes or no.
Every fork in your agent's logic becomes another slow, expensive generation call before any useful work actually happens!
This is where the architecture is shifting.
A new model called Jev, built by TypeSafe, separates thinking from deciding.
It acts as a System One model:
you provide the current state and predefined questions, and it returns typed multiple-choice answers with probabilities.
It cannot generate prose or write code. It is simply an ultrafast decision router.
By splitting the workload, developers are dropping latency and costs to near zero.
Let the large language model research, plan, and write. Let Jev route, score, approve, or escalate.
Here is how builders are using this new stack in the wild.
1. Controlling a browser at hyper-speed
One of the most complex tasks for an AI agent is navigating the web. A browser's available actions change after every single click. If you use a standard LLM to decide what to do next, the agent will pause for several seconds after every page load, analyzing the DOM and generating a response.
An open-source project called Browser Use recently swapped their decision engine to Jev. Instead of asking a chatbot what to do, they build a fresh list of observed controls on the page and let Jev choose from that list. If an input field needs filling, a small, cheap LLM generates the text, but Jev handles the actual navigation decisions.
The result is a browser agent that moves at human speed. In a recent demo, the agent navigated a travel site and found flights in seven seconds. The total inference cost was less than half a cent. By removing the token-generation bottleneck, the agent stops waiting on itself.
2. Instant context compaction for long chats
If you use agents for complex coding tasks, you know how quickly the context window fills up. A coding assistant might run twenty tool calls, read five files, and encounter three errors. Very quickly, your session hits a million tokens. Every subsequent prompt becomes slow and expensive.
Traditionally, developers have tried to fix this by asking an LLM to summarize the chat history. But summarization is just more generation, which is slow and often loses critical details.
Developers Tamara and Alex Volkov found a better approach. Instead of summarizing, they use Jev as a plugin to review the chat history. Jev scores every single tool call in the session based on its relevance to the current goal. It instantly identifies the dead ends, the failed searches, and the irrelevant file reads, and simply drops them.
Because Jev is a classification model, it can review hundreds of tool calls in about one second. It can seamlessly take a bloated, million-token session and compress it down to a clean, highly relevant fraction of the size without losing the actual code.
3. Routing tasks between different models
Not every request requires the most expensive frontier model on the market. If a user asks for a quick spelling correction, you do not need an advanced reasoning model. If they ask for a complex architectural breakdown, a smaller, cheaper model will fail.
Frameworks like LangChain are starting to use Jev as an intelligent dispatcher at the very front of the application. You connect several different models to your system and describe what each one is best at. When a user submits a prompt, it does not go directly to a generative model.
Instead, the prompt hits Jev. Jev evaluates the complexity and intent of the request, then selects the appropriate destination from a multiple-choice list. Simple tasks are routed to a cheap, fast model. Complex tasks are routed to the expensive reasoning models. This single decision layer drastically reduces aggregate API costs while maintaining high quality for the tasks that actually need it.
4. Classifying a thousand research papers for pennies
When you are dealing with massive datasets, traditional LLMs break down. If you want to sort through a thousand academic papers to find the ones relevant to your specific niche, you are looking at hours of processing time and a noticeable API bill.
Developer Hassan built a pipeline that completely bypasses this problem. First, he used a highly efficient model like DeepSeek Flash to generate a quick summary of each paper. Then, he passed the title, the summary, and a list of 24 possible topics to Jev.
Because Jev only has to return a category choice and a confidence score, the speed is unmatched. Hassan classified 1,018 AI research papers in a matter of seconds. The median end-to-end latency per paper was 256 milliseconds. The entire run cost eight cents.
You can apply this exact pipeline to legal documents, real estate listings, or customer feedback logs. You save the selected category to a database and only forward the strongest matches to your expensive writing agents.
5. Triaging an overflowing inbox in seconds
Email management is the classic automation use case, but generative AI usually overcomplicates it. If you ask an LLM to manage your inbox, it will try to draft replies for everything, including newsletters and calendar invites.
Developer Riley Brown demonstrated a much cleaner approach. He used Jev strictly for triaging. He passed each incoming email to the model as the state, and provided a strict list of choices: reply, research, wait, or review.
Jev read the state and selected a destination. If an email required a response, it was routed to an email-drafting agent. If it required more information, it went to a research agent. Newsletters and spam were instantly archived. By treating the inbox as a routing problem rather than a writing problem, he was able to classify 500 emails in seconds for under four cents.
The era of treating a single conversational model as a universal worker is ending.
Most builders will keep spending expensive tokens on every yes, no, and routing decision, wondering why their agents are so slow and costly.
The developers building the next generation of tools are separating thinking from deciding.
They use large language models to research, plan, and write. They use Jev to route, score, approve, and escalate. Finally, they use code to execute the decision.
If you want to build faster, cheaper, and more reliable systems, start by finding the repeated decisions in your workflow.
Move them out of your conversational prompts and into a dedicated decision layer. Your users, and your wallet, will notice the difference.
In case we are meeting for the first time, come over here, it'll be worth the roller coaster of articles that are gonna come up in the next few weeks.
If you're an established writer, here are the brands paying for sponsored articles.