16:54Mark Kashef · Tutorial
GPT-6 Astra's Computer Use Is Ridiculously Good
Five ways Mark Kashef points Codex's computer use at apps that have no API, from flight searches to phone settings.
September 5thThe argument in one line.
Jev is a constrained-answer classifier, not a generative model: you predefine the allowed answers to a question and it returns one of them with a confidence score, which makes it cheaper and more deterministic than an LLM for bounded decisions like routing, fact-checking, and judging.
Read if. Skip if.
READ IF YOU ARE…
- You build or manage AI agent workflows and want a cheaper, more reliable way to make yes/no or multiple-choice decisions than a full LLM call.
- You run high-volume classification tasks (support routing, contract review, fact-checking) and are paying full LLM pricing for the same fixed choice every time.
- You're building a router that sends requests to different model families and want the routing decision itself to be transparent and auditable.
SKIP IF…
- You need a model to generate new writing, code, or open-ended explanations. Jev only picks from answers you already define.
- You're not running enough repeated, bounded decisions to make an added API integration worth the setup time.
The full version, fast.
Jev, built by TypeSafe, is a decision model rather than a generative one: you feed it facts, a question, and a fixed set of allowed answers (yes/no, multiple choice, or a score), and it returns one of those answers plus a confidence level. Because the output is a label instead of generated text, you only pay for input tokens, and the response is deterministic instead of varying between runs like a standard LLM. The video walks through ten uses, including fact-checking claims at scale, routing support tickets and AI requests, contract review, healthcare triage, and financial alert sorting, then closes with pricing (about $0.0042 per 10,000 input tokens) and a free public 'Ask Jev' playground to try it.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:00
01 · What is Jev?
Jev takes facts, a question, and a predefined set of allowed answers, and returns one of them with a confidence score, unlike a standard LLM which regenerates a slightly different answer every run.
01:00 – 02:00
02 · Classifiers explained
Jev works like a classic machine-learning classifier (the cat-vs-dog example), except it's generalized: you supply the question and the choices instead of retraining it for each new task.
02:00 – 03:00
03 · When would you use Jev?
Three question shapes cover most uses: does X meet a requirement, which option should I choose, and what should happen next, each with a fixed, inspectable answer set.
03:00 – 04:00
04 · Checking an LLM's work
Using a second LLM as a judge to catch a first model's mistakes doesn't guarantee accuracy, since judges often share the same blind spots and compound errors and cost instead of fixing them.
04:00 – 05:00
05 · How Jev compares with an LLM
A standard LLM call bills for input and output tokens and regenerates from scratch every time; Jev only bills for input tokens because its output is a predefined label.
05:00 – 06:00
06 · The API and hotel fine-print example
The Jev request is just facts, a question, and allowed answers; demoed against a hotel cancellation policy to determine whether 'free cancellation' actually means a cash refund.
06:00 – 08:00
07 · Practical Jev use cases (fact-checking, support, legal)
Ten use cases begin: fact-checking claims at scale, routing customer support tickets without a model inventing a nonexistent category, and flagging low-confidence contract reviews for human review.
08:00 – 09:00
08 · Routing requests to the right AI
A classifier can act as a model router, sending each incoming request to the right model family, addressing the failure mode where routers quietly downgrade requests to cheaper models.
09:00 – 10:00
09 · Reasoning steps, agents, and browser use
Swapping a bounded classifier call in for a full reasoning step or a browser-agent's screen analysis cuts the time and tokens spent re-deciding the same thing.
10:00 – 11:00
10 · More use cases and pricing
Healthcare triage and finance alert sorting round out the use cases; pricing is about $0.0042 per 10,000 input tokens, scaling linearly with volume.
11:00 – 12:00
11 · When to use Jev vs. an LLM
Use a full LLM for generation (writing, code, explanation); use a classifier for a bounded decision with predefined outcomes, or pair the two so the LLM creates and the classifier checks.
12:00 – 12:51
12 · Try the Ask Jev playground
The public Ask Jev playground shows the constraint live: an open-ended question returns 'not enough information,' while a bounded yes/no question returns a labeled answer with a confidence percentage.
Lines worth screenshotting.
- A classifier like Jev only returns one of the answers you define in advance, so its output is deterministic where a standard LLM's is not.
- Because Jev's output is a label, not generated text, you pay for input tokens only, never output tokens.
- Stacking more LLM judges to catch a first model's errors doesn't guarantee truth, because the judges tend to share the same blind spots.
- Roughly once per 100 to 1,000 requests, an LLM given a fixed set of categories will still invent a category that was never an option.
- A confidence score below 90-95% is a practical trigger for routing a decision to a human reviewer instead of trusting the model outright.
- At $0.0042 per 10,000 input tokens, 100,000 classifier calls of that size cost about $42 total.
- Swapping a bounded classifier call in for a full reasoning step can save the 10-20 minutes an LLM sometimes spends looping to reach the same conclusion.
- A browser-automation agent that re-analyzes the whole screen before every click can be sped up by asking a classifier one bounded question, like whether a specific button is present.
- GPT-5's launch controversy, where decent requests were allegedly routed to cheaper models to cut costs, is the exact failure mode a transparent classifier router is built to avoid.
- A classifier can't write new content or explain anything. Its only job is to pick between options you already gave it.
A classifier beats an LLM for any bounded decision.
WHAT TO LEARN
Most of what people ask an LLM to do isn't generation at all, it's picking between known options, and a constrained-answer classifier does that job cheaper and more consistently.
01What is Jev?
- Jev isn't a generative model, it's a decision model: you give it information and a question, and it picks from answers you define in advance, called the solution space.
- Where a standard LLM produces slightly different wording every time on the same prompt, a classifier's output is deterministic because it can only return one of the predefined answers.
02Classifiers explained
- Jev works like a classifier, a machine-learning approach used for over a decade for tasks like sorting images into predefined categories.
- Unlike older classifiers trained on one narrow task, a generalized classifier takes the question and the possible answers as input and classifies based on those two things alone.
03When would you use Jev?
- Three question shapes cover most uses: does X meet a requirement, which option should I pick, and what should happen next, each framed as a fixed set of choices.
- Because the answer set is fixed, you can see exactly which option was picked and how confident the model was, which a free-form LLM answer doesn't give you.
04Checking an LLM's work
- Stacking a second or third LLM as a judge to catch a first model's mistakes doesn't guarantee accuracy. The judges often share the same blind spots, so errors can compound instead of cancel out.
- Adding more LLM judges also multiplies latency and token cost for a task a simple classifier could resolve outright.
05How Jev compares with an LLM
- A standard LLM call bills for both input and output tokens; a classifier only bills for input, because the output is just a label picked from options you already gave it.
- The three formats a classifier like this accepts are binary yes/no, multiple choice, and a numeric score against a rubric.
06The API and hotel fine-print example
- A real contract or policy clause can be fed in with a specific yes/no question, such as whether 'free cancellation' actually means a cash refund, and get a definitive, sourced answer instead of a vague summary.
- The API request is just three parts: the facts, the question, and the allowed answers; the response returns a typed result plus a confidence score.
07Practical Jev use cases (fact-checking, support, legal)
- Fact-checking at scale works by asking one fixed question, such as whether evidence supports a claim, across thousands of documents instead of paying an LLM to judge each one individually.
- Support-ticket routing with a classifier avoids a real LLM failure mode, where roughly one in a hundred or a thousand requests gets routed to a category that was never a valid option to begin with.
- In regulated domains like legal contract review, a low confidence score (below 90-95%) is the trigger for adding a human reviewer, rather than trusting the model's answer blindly.
08Routing requests to the right AI
- A classifier can act as a model router, checking each incoming request against fixed categories and sending it to the right underlying model family instead of a general-purpose LLM guessing.
- The GPT-5 routing controversy, where decent requests were allegedly sent to cheaper, weaker models to save on cost, is the failure mode a transparent classifier router is meant to avoid.
09Reasoning steps, agents, and browser use
- Swapping a narrow yes/no or multiple-choice decision in for a full reasoning step cuts out the minutes an LLM can spend looping over the same request to reach the same conclusion.
- Browser-automation agents normally re-screenshot and re-analyze the whole page for every click. Asking a classifier a bounded question, like whether a specific button is present, narrows the search and cuts latency and token spend.
10More use cases and pricing
- In healthcare, a classifier can flag which patient conversations need clinician attention, giving a shortlist for review rather than replacing the clinician's judgment.
- In finance, incoming alerts can be auto-sorted into ignore, review, or watch-list buckets instead of running every alert through a full LLM call.
- Pricing scales linearly with input tokens only, at roughly $0.0042 per 10,000 input tokens, so 100,000 requests of that size run about $42.
11When to use Jev vs. an LLM
- The dividing line is simple: use a full LLM when you need new generation (writing, code, explanation); use a classifier when you're making a bounded decision with predefined outcomes.
- The two approaches aren't exclusive. A common pattern is to let an LLM generate the work and a classifier check it, since the classifier is cheaper and can't drift outside its answer set.
Terms worth knowing.
- Classifier
- A machine-learning model that assigns a label to an input from a fixed, predefined set of categories, rather than generating new text.
- Solution space
- The complete set of allowed answers you define upfront for a question, such as yes/no or a short list of choices, which the model's response is constrained to.
- Confidence score
- A number returned alongside a classifier's answer showing how sure the model is, though it isn't a formal statistical confidence interval or a guarantee of accuracy.
- LLM-as-judge
- The practice of using a second language model to check a first model's output for errors or hallucinations, instead of a fixed classifier.
- Model router
- A system that inspects an incoming request and decides which underlying AI model should handle it, based on the type or difficulty of the task.
Things they pointed at.
Lines you could clip.
00:52
“With something like Jev you create what's called the solution space, where you tell it what are the possible answers it can pick from.”
03:47
“If for whatever reason judge number one hallucinates, then you add another judge, you can start to compound the exact same error and cost not only time, but tons of tokens in the process.”
10:43
“For one request of 10,000 input tokens, because you only pay for input, not input and output like a language model, you will pay around 0.0042.”
09:55
“What typically happens with the language model is it takes a screenshot and then it does the equivalent of boiling the ocean every single time to see where is the downloads button.”
12:10
“Do human beings breathe oxygen? And we're in the yes or no format. It should be above, there we go, 97% sure that the answer is yes.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphor
So a company that seemingly came out of nowhere dropped a brand new model that's gone absolutely viral on X. Now I put the word model in air quotes just because it's not the same type of model that you and I are used to. It's not a model that's designed to help you generate things as much as help you decide on different paths.
So in this video, I'm going to quickly and simply explain what it is, how it works, and much more importantly, what practical use cases you can apply it to. Let's get to it.
All right, so the big picture is this. You give Jev a series of information. From that information, you pose a question.
And from that question, you basically designate what are the possible answers they can choose. And if you were using a standard language model and you sent over the exact same prompt, let's say it's a task -based prompt, and you sent it 10 times, you'd get 10 very similar responses, but almost none of them would be the exact same.
There would be a slight difference or nuance in the token selected for that output response. But with something like... jeff you create what's called the solution space or the answer space where you tell it What are the possible answers it can pick from?
And not only will it always abide by that, but it will also spit out a confidence level, which is something we don't have with LLMs. Now, the company hasn't revealed their exact architecture for how Jev works, but for all intents and purposes, it looks very similar to something called a classifier. And a classifier isn't a brand new piece of tech, and it's been around for more than 10 years.
Back in the day, when I spent years making machine learning models, we used to use things like classifiers all the time, especially with things like image recognition. So if you take the very basic example of trying to analyze and creating a model to detect the difference between a cat and a dog, you'd feed hundreds of thousands of images of a cat, same as a dog, train a model, and then you'd eventually have a multi -classification model where you could feed an image and it would tell you, is it a cat, dog, or something completely different that it wasn't trained on?
Now, the one nuance here is that unlike the old way of doing things where you had to be very targeted in what you're trying to classify, this model is generalized. So you give it the question, the possible answers for it to pick from, and it has good enough training that it can classify based on only those two variables.
They might hear all this and still ask the question, why should I care? And when would I actually use this? Let's take three possible scenarios.
Scenario one, you ask, does X meet my requirements? And let's say you have one to five as a possible set of requirements, maybe a rubric of sorts. The number two could be, which option should I choose?
A, B, or C. And the last one could be, what should happen next? Decision A, B, C, or D.
Because you're defining, like we said, the solution space, you're telling it all you can pick from are these scenarios. You can transparently see which one it picked and how close it was. You could ask that very question to a normal language model, even ones on high reasoning like ASTRAs and FABEL.
If you ran that 10, 20, 100 times, you might see nuances in the answer every single time it's run. Both of these models are imperfect, but at least with something like JEV, you can define exactly what it can respond with, and you can see how confident it responds to that question every single time.
Now, another situation where this might be helpful is in checking the work of an existing LLM, especially in more commercial cases where you're running hundreds, thousands of prompts, maybe analyzing contracts, creating proposals, looking at intelligence, running cost estimates. If you think of a lot of commercial cases where you have hundreds of different runs happening, where you want to double check.
that every single time when the language model responds, it doesn't have some hallucinated answer or an answer outside of yes, no, or some form of classification in the business. Let's say it's a contract review and you're trying to see, should this be in review? Is it ready for a final QA?
Or is this ready to send to a client? Those are three different targets. So if you're paranoid about quality control and you want to check that answer, you might employ a judge where it's pretty much a glorified prompt with a user prompt that says, go and check the answer from X.
and make sure it fits into one of the core criteria. Now this could work, but theoretically, if you have judge number one, and for whatever reason, judge number one hallucinates, then you add another judge, you can start to compound the exact same error and cost not only time, but tons of tokens in the process. So having something like Jev can help you remove these LMs as a judge because you're just using them to check for something that a basic model could do so on its own without any form of real intelligence.
So with Jev, things are very simple. All you do is you give it all the facts, then you give it the question with the options it can pick from, and then it gives you the result in a very short amount of time. So if you compare this against a language model, a language model will take that question with additional knowledge that you give it.
and then generate it every single time from scratch. Now, the normal language model, you're paying for input tokens and output tokens. With Jev, you're only paying for input tokens because the output is pretty much predefined.
It will classify the answer based on all of its understanding from the context you provide it. Now, the three types of questions you can ask it is either a binary yes or no. a multiple choice question or some form of score where you could give it some variation of a rubric.
It comes with a skill actually out of the box that you can go and copy paste as you wish right here. And you don't have to do this yourself by hand. You can feed the documentation of TypeSafe to any language model of choice.
It will figure out how to use this AI. If you're non -technical, don't let this page intimidate you. What it's basically saying here is we have a questions object.
And in this questions object, we're just defining the type of question. and the question posed. And on the right hand side, you get a response with the type of question once again, and then the confidence interval of the response it came up with.
If you change it from binary to multiple choice, all that will change is we're adding more criteria. and we're getting more confidence intervals. And then if we move on to score, it looks very similar where you have similar criteria, and then the response maps that criteria along with the probabilities for those scores.
And before we rapid fire into a series of use cases other people have using Jev for, let's take a practical example. Let's say you were booking a hotel, and in that hotel description, you had a series of claims, and one of them could be free cancellation within 24 hours. But you wanted to double check.
Does free cancellation mean I get my money back? Or does that mean hotel credit or credit on the booking platform of Origin? You could take this entire description, run it through Jev, and get something deterministic that tells you, number one, it does not meet your requirement for money back.
And it tells you free cancellation until 24 hours before arrival. Refunds are issued as hotel credit valid for 12 months. So it could quickly go through a series of documents.
hundreds of documents, imagine papers at scale. And instead of spending all the time and tokens, even with cheaper models to go through them, especially if you're looking for a answer to a specific question and answer them almost instantaneously. Now the same idea fits a bunch of other jobs.
Hopefully these next 10 use cases can get the creative juices flowing as how you can use this too. The first use case could be fact checking. And let's say you want to fact check a study that says coffee causes longer life.
And you want to go through all the evidence and see does that evidence support that claim? You could tell it either it does or the claim needs a rewrite.
If you can imagine this at scale, you could ask one fundamental question and just rip through thousands of papers for a fraction of the time and cost it would take to feed that to even something as fast as Gemini Flash. Now, taking a case in the real world, let's say you have a customer support team and you have an AI that takes a transcript of a conversation and it knows how to properly route the right request to the right department without a language model.
just purely based on which of the three departments should it route it to. Many times language models, even if you give it very concrete answers, once every hundred or thousand requests, it will randomly come up with a category that wasn't an option to begin with. Now for domains like the legal space, when it comes to contract review, many companies are using language models where they can actually use a very basic classifier just like this.
Because the key question that pops up in these domains is how can I trust that the AI is not hallucinating? At least with something like this. If the confidence is, let's say, lower than 90 to 95%, this might warrant a human loop where you're not just having a full review on everything that the LLM was supposed to automate to begin with.
Now, let's say you have 100 emails in a thread and you're looking just for one specific detail to see. how it changed, and when it changed too. You can quickly tell it, did the launch of my product move from Thursday, Friday, or Saturday and get that exact same response with no additional feedback that's no longer needed.
An interesting use case for this is actually combining Jev with existing language models where it can act as a router where depending on the request, it could pick the perfect model for the job much better than a language model. If you remember back when GPT -5 came out last summer, the biggest flaw with that model was it kept routing.
pretty decent requests to the lowest models. And there was a whole scandal around whether or not OpenAI was purposely sending them over just to pay less for the same request. With something like this, you can build your own smart router where depending on the request, it could send it to the Codex family, the Cloud family, or to even an open source model family.
Now getting deeper into some more creative use cases, I've seen some folks use existing models and replace tool calls to reasoning steps, which typically take the most time and tokens. and replace that step with something like a Jev call. So you can quickly point out exactly whether or not the work of the LLM was right and keep going from there without spending 10, 15, 20 minutes waiting for the same language model to loop over the same requests, same answers to try to get the exact same place.
Similar to the model example, let's say you had different agents running on different language models. This could also route the right request to the right sub -agents or agents you've already prepared. for whatever task you're working on.
A very popular use case and one that really shows the value of Jev is something like browser use, where a lot of people on X are flexing how quick they've made their own computer use. Because what typically happens with the language model is it takes a screenshot and then it does the equivalent of every single time to see where is the downloads button.
But with Jev, you could ask it on the screen right now, tell me, is there a downloads button? Yes or no. Or go and pick the downloads button right away.
So you can really narrow the focus of where the agent's going to click. This can bring down the speed, latency, and all the tokens involved. You can imagine an application in spaces that really depend on specificity and accuracy.
In high -risk and high -stakes domains like healthcare, a clinician could use Jev to quickly classify whether something in the conversation that they've had warrants attention. They'll still have to be in the loop to evaluate what they found, but at least they'll quickly get a shortlist on what patients and what case files require their time.
Now, the last case could land in the finance domain where there's always a flood of brand new alerts. Instead of needlessly spending tons of money going through every single request through a language model, Jeff could go through and classify it with one of three labels. Either it should ignore it, review it, or it should be put on your watch list.
So it becomes a new way of organizing and refining the information so you can focus on the part that matters. Now in terms of cost, for one request of 10 ,000 input tokens, because you only pay for input, not input and output like a language model, you will pay around 0 .0042. If you make this 1 ,000 requests, you'll be up to 42 cents.
If you make 10 ,000 requests, $4 .20. If you do 100 ,000, $42, and so on.
So you can quickly see that unlike something like Astra, where you send one request, even on low, it will , especially at scale. So if you're looking to use this right away, what I would do is look through a decision that you make very often, and ideally a decision that has predefined possible scenarios, categories, or answers.
If you need a full explanation or generation of something, language models are still the way to go, especially with the cheaper ones coming out and open source really catching up to the closed source. But if it's something where you want to optimize for specificity, you want the transparency to see how confident is the response.
But for cases where you're looking to optimize or minimize cost, using something like Jev could really help, especially if you wrap it around an existing LLM response. In case you don't have access to Jev yet, I'm going to make this website available to you. First come, first serve.
I only have $7 of credits. So if you go here and say something like, what color is the sky? It likely won't give you the best response.
So if we send this over, it's going to say not enough information. I'm not actually giving it a solution space. But if I ask it a binary question, do human beings breathe oxygen?
And we're in the yes or no format. It should be above, there we go, 97 % sure that the answer is yes. Take a look at the speed, the request structure.
So you can tinker with it so that by the time you have access, you can hit the ground running. And that's pretty much it. So hope this gives you a good TLDR of what this model is, how it works, and how you can apply it to your day to day work.
I'm going to make the last website I showed you and this one along with another guide that you can feed to your language model to help it use the API if you already have access down in the second link in description below. And for the rest of you, if you found this helpful, I'd super appreciate a like and a comment on the video really helps the video and the channel.
I'll see you on the next.
The Hook
The bait, then the rug-pull.
A tweet about a 'new type of foundation model' is the cold open, but the real subject is narrower and more useful than that framing suggests: a tool that doesn't generate anything, it just decides. Mark Kashef spends the next twelve minutes making the case that most of what people ask an LLM to do isn't generation at all, it's picking between options, and that a cheaper, deterministic classifier can do that job better.
Named ideas worth stealing.
00:52concept
The Solution Space
You define upfront exactly which answers Jev is allowed to return, and every response is constrained to that set with a confidence score attached.
Steal forany workflow where you need a model's answer to always be one of a known set of outcomes
03:47concept
The Multi-Judge Trap
Adding a second or third LLM judge to catch a first model's hallucination doesn't guarantee truth, since the judges tend to share the same blind spots and can compound the original error while adding latency and cost.
Steal forany QA pipeline currently using LLM-as-judge chains
04:50list
Jev's Three Question Types
- Binary yes/no
- Multiple choice
- Score against a rubric
Every Jev question is framed as one of these three fixed formats, which is what makes the output classifiable instead of generative.
Steal forstructuring any decision you want an AI to make consistently
10:43model
Input-Only Pricing
Because a classifier's output is a predefined label rather than generated text, you pay only for input tokens: about $0.0042 per 10,000 input tokens, or roughly $42 per 100,000 requests of that size.
Steal forestimating cost on any high-volume classification task
How they asked for the click.
VERBAL ASK
12:24link
“I'm going to make the last website I showed you and this one along with another guide that you can feed to your language model to help it use the API if you already have access, down in the second link in description below.”
Soft CTA folded into the outro pointing to the free Jev Starter Kit and Ask Jev playground, followed by a standard like-and-comment ask, rather than a hard sell.
MENTIONED ON CAMERA
Visual structure at a glance.
