Jev AI: 193x Faster Model — Full Breakdown & Transcript

[00:07] see people building some amazing crazy things with Jeff. Yes, Jeff by type safe. Some developers are using it to control game characters. Others are experimenting with AI agents and applications [music]

[00:20] that need to respond in real time. And when J founders shared a demonstration of its model, it reportedly attracted millions of impressions. But what really caught everyone's attention were two numbers. 193.6 times faster and 444.6

[00:38] times cheaper. Those are some pretty extraordinary claims for an AI model. And naturally, people started comparing it with models like JPT, Claude, and [music] Gemini. But here's the interesting part. Jeb doesn't actually

[00:52] work like Jad GPT. [music] So what exactly is Jeb? Why suddenly everyone is talking about it and does it really deserve all this hype? That's exactly what we are going to break down in this video. So in this video we'll

[01:05] understand what exactly Jeb is and who created it, why [music] it's called a system one model, how Jeb is different from GPT, Claude and Gemini. Then we'll look why Jeb claims to be significantly faster and cheaper. how Jeb works using

[01:21] state and questions how to use Jeb through its playground and finally we will look where you should and you shouldn't use Jeb session be with me till the very end so without any further ado let's get into the magic of Jeb so

[01:36] let's start by understanding what exactly is Jeb before understanding how Jeb works let's quickly look at why it was created so Jeb was introduced by an AI company called Typesafe Founded by Dieago El Media, the founder

[01:52] of OpenAI researcher and the idea behind it was very simple. Today, AI models can write code, generate images, answer questions, and even help us solve complicated problems. But here's something interesting. Not every

[02:08] application needs AI to generate an entire response. Sometimes all it needs a simple decision making. So let me explain you with an example. Imagine you

[02:20] run an online shopping website and customers are sending you hundreds of messages every day. Some are asking for refunds, some have delivery issues and others are facing payment problems. Now you need to identify what each message

[02:35] is about and send it to the right department. Right? You could use GPT to read every message, understand it, and generate an explanation out of it. But do you really need a detailed explanation every single time? Not

[02:51] really. You just need to know whether the message is about refund, delivery, or payment. And that's exactly the kind of task Jev is designed for. It reads the information, evaluates the available options and returns the structured

[03:06] decision. Okay, let me explain you with an real life example. For example, if a customer writes, "I ordered my phone 5 days ago, but it still hasn't arrived."

[03:19] Jeb could classify that message under delivery very simply. Your application could then use that decision to send a request to the delivery support team. Simple, right? That's what makes Jev different. Instead of focusing on

[03:33] generating lengthy responses, Jev is designed to make fast structured judgments that applications can directly use and typic describes this approach as use and typic describes this approach as a system one model. So what exactly does

[03:48] that mean? So this concept comes from psychologist Daniel Kenman's book thinking fast and slow. In this book, he describes two types of human thinking. describes two types of human thinking. System one and system two. System one is

[04:03] fast and intuitive. For example, when you see someone smiling, you can usually [clears throat] analyzing every detail. Or imagine you're crossing a road and suddenly notice a vehicle approaching. You

[04:17] immediately recognize the danger. You don't sit down and evaluate, calculate everything before reacting. That's the idea behind system one thinking. Now system two thinking it is little bit different. It's slower and more

[04:32] different. It's slower and more analytical. For example, if I ask you to multiply 14 by 78. Let's suppose you probably need a few seconds to work out the answer, right? You have to think through the problem step by step. Now,

[04:48] Typesafe uses this distinction to explain what Jeff is designed to do. Instead of generating detailed explanations or solving open-end problems, Jeff focuses on making quick decisions, judgments. And this brings us

[05:02] to another important question. If Jeff is mainly making decisions, couldn't we already do that using GPT or Claude? You must be thinking this, right? Let me clarify this to you. See, you can ask GPT to read a customer message, identify

[05:19] whether the customer is frustrated, and return the answer in JSON format. Claude and Gemini can do something similar. So, making decisions or generating structured output isn't something only Jeff can do. The real difference is what

[05:34] Jeff can do. The real difference is what Jeff is optimized for. Models like GPT and CLA are general purpose language models. They can write emails, explain concepts, generate code, analyze documents, and hold conversations. And

[05:49] when they generate a response, they generally produce it one token at a time. Think of it this way. If you ask an LLM to return a structured JSON object, it still typically generates that output sequentially.

[06:05] First one token, then the next, then the next, and so on. Now, Jeb approaches this differently. Instead of generating an open-ended sequence of text, it

[06:17] designed to return typed decisions. And when you ask it to multiple independent questions, those judgments can be evaluated in parallel. So imagine you

[06:29] want to know three things about a customer message. Is the customer frustrated? Which department should handle the request? And third, how urgent the issue is. A traditional LLM can answer all three questions, but Jeb

[06:44] is specifically optimized for producing this kind of structured decision. That's one of the reasons it can be significantly faster for certain significantly faster for certain workloads. But how much faster? Well,

[06:58] that's where those viral numbers comes in. You have probably seen some impressive claims about Jev online. Types safe has reported that Jev can be

[07:10] Types safe has reported that Jev can be 193.6 time faster and 444.6 times cheaper in its benchmark comparisons. And those numbers comparisons. And those numbers definitely sound exciting. But there's

[07:23] something important we need to understand. Faster at what? because Jev in a general purpose language model aren't necessarily doing the same kind of work. So those numbers don't mean Jeff is 193 times better than J GPT at

[07:38] everything. They describe reported performance improvements under particular benchmark conditions. So actual speed and cost savings will depend upon the task, the model being compared and how the applications are

[07:54] built. And here's another important thing. Even if the model is extremely fast, that doesn't automatically mean it's making the correct decision. Accuracy matters, too. So, the real advantage of Jeb isn't simply that it

[08:09] can return an answer quickly. It's that it offers a specialized way for developers to get structured judgment without relying on a general purpose text generation workflow for every small decision. Now that we understand what

[08:25] makes Jeb different, let's see how it actually works. See the interesting thing about Jab is that you don't need to have a long conversation with it. Every jab request has two main parts. State and questions. So state is the

[08:42] information we evaluate and questions are what to decide. This is being put in into Jev and then Jeb type the answers bases on probability, choice and score as you can see on my screen. Don't worry, let's understand this with an

[08:57] example. First of all, let's look at state. So state is simply the information you want Jeff to analyze. It could be plain text, a JSON object or an

[09:09] array containing related information. For example, imagine a customer sends this message. I've contacted your supporting three times and I am still waiting for my refund. That message begins the state for Jeff. I repeat, and

[09:25] that's where questions comes in. Questions define what you want Jeff to decide. For example, does this customer sound frustrated or which department should handle this message? Now, Jeff supports three main types of questions:

[09:41] noun, choice, and score. Do not worry we'll understand all these type of questions one by one. In nutshell nless is the true probability like from zero and one. Choices which option to be chosen from the given category and score

[09:57] is where on the scale like position along the defined levels. Don't worry we'll explain this and understand this in much more detail. First of all null a probability. So understanding these will make playground demonstration that

[10:13] actual demo of us very easy trust me. First of all noun. So the first question type is called as null. As we have discussed this is used when you want to

[10:25] discussed this is used when you want to evaluate a yes or a no statement. No worries. Let's understand with an example. Let's suppose the question is is this customer frustrated? Instead of returning a long explanation, Jev

[10:39] returns a probability between 0ero and one. Let's say it returns 0.5. That means Jev estimates a 95% probability that the answer is yes. If it comes to

[10:53] near to zero, then it means the answer is strong no. If near to 0.5 then it means uncertain and one because our probability cames out to be closer to probability cames out to be closer to one then it means it is a strong yes but

[11:07] one then it means it is a strong yes but remember that's the model's estimate. It doesn't automatically guarantee that the judgment is correct. It is just an estimate. Now let's understand the second type of question that is choice.

[11:21] So this is useful when you want Jeff to select from a list of predefined options. No worries. Let's understand this with an example. Why this customer contacting support and the available options are for refund, delivery,

[11:37] payment or any other? Jeb evaluates the customer message and selects the most appropriate category. It can also return the probability for these available questions and options. So that is choice. Now the third type of question

[11:53] is score. So this is used when you want jab to evaluate something on an ordered scale. No worries. Here's the example. How frustrated is this customer? And we

[12:05] define three levels. Calm, dissatisfied, extremely angry. Jeb evaluates the message against these levels and produces a score. And here's the interesting part. You can ask Jeff multiple questions about the same state

[12:20] in the single request. You don't necessarily have to send the same customer message three different times. Okay. Okay. Okay. Don't worry if some of these terms sound very technical. They are much easier to understand when you

[12:35] will actually see the model working. Actually, let's stop this and directly jump into the demo. We have covered a lot of about the theory like the basic theory about Jeff. I think it will make more sense when we will practically look

[12:50] into all these state questions and how the three types of questions are independently handled by Jeff. So without any further ado let's get into without any further ado let's get into our J playground to look at the demo.

[13:03] Now after looking at the practical demonstration of Jav, it sounds pretty useful, right? It's crazy, useful, and very beneficial. But there's one limitation that's worth understanding. Let's return to our customer support

[13:17] example again. Imagine you have created a system that classifies customer a system that classifies customer messages into four categories: billing, delivery, technical support, and general support. Everything works fine until one

[13:32] day the customer sends the message. My laptop charger is parking and there's a smoke coming out of it. Now think about it for a second. This isn't just an ordinary support issue. It's potentially a safety emergency. But our application

[13:49] hasn't included a safety related category. So now what happens if Jeb is restricted to those four options? It has to select from the choices available. It might choose technical support because that's the closest match, right? But

[14:07] that doesn't necessarily means it's the right response. The customer may need immediate safety instructions and escalations. And this highlights something really important. A model can return a perfectly valid structured

[14:22] answer and still make the wrong decisions. That's why developers need to think carefully about the choices they provide. They may need options such as unknown human review or safety escalations. So while Jeff can make

[14:38] decisions quickly, it doesn't automatically understand every possible situation outside the structure you have given to it. Now another interesting question. What happens when the problem is too complicated for Jeff to solve

[14:53] is too complicated for Jeff to solve alone? Well, there's where traditional alone? Well, there's where traditional language models can come in. Yes, JV and language models can come in. Yes, JV and LLM can work together. So far, we have

[15:05] been comparing Jeb with models like GPT and clot. But what if we didn't have the choose between them? What if we could use both of them? Imagine a company receives thousands of customer support request every day. Most of those

[15:21] requests are straightforward. Customers want refunds, delivery updates, and or help with payments. Jeff could handle the initial classification and prioritization. But occasionally, a message comes that much more

[15:36] complicated. Let me explain you with an example. My account has been logged. There's an unknown charge on my card and I think someone has accessed my profile. Now, this isn't necessarily something you want to handle with one simple

[15:51] classification. The issue might involve security, fraud, and account recovery. So, instead of forcing the request into one category, your application could associate for further analysis. So, a general purpose language model could

[16:06] help you to interpret the situation, identify additional questions or suggest the next steps. And if the issue is sensitive, a human reviewer could make the final decision. So you end up with a system where different components handle

[16:22] different responsibilities. Jeb handles fast structured judgments. General purpose LLMs handles tasks that require more flexible interpretation. Third, application code controls what actions can actually be executed. And fourth one

[16:38] is the human review situation where mistakes could have serious This is one of the ways Jeff could fit into larger AI powered systems and it also explains why Jeff doesn't

[16:50] necessarily have to replace models like GPT or clot. It could work alongside and Jeb is just one example of how quickly AI technology is evolving. We are moving

[17:04] beyond applications that simply generate answers to what system that can make decisions, use tools and automate complex workflows. And if you want to go beyond hearing about these technologies and actually learn how to build AI

[17:18] applications, you can explore the advanced executive program in applied generative AI by IIT offered through simply learn. The program covers generative AI, agentic AI, LLMs, rags,

[17:30] and multi- aent systems with hands-on experience using tools and frameworks such as Langchain, Langraph, and Crew AI. You'll also work on real world AI projects and learn how AI applications can be built and deployed. So, if you're

[17:47] looking to develop practical AI skills, you'll find the program details in the description and in the pin comments. It's worth checking out. Go and build your career with simply learn. Now coming back to Jeb, we have seen how it

[18:01] can fit into larger AI systems, but that doesn't mean it's the right tool for every situation. So let's understand where Jeb makes sense and where you might be better of using the traditional LN. So if you will go to the official

[18:17] website of J by type safe here you can see the document section and here you can see the example use cases that the categories involve AI automation software realtime applications AI map reduce over big data universal

[18:34] verification or the harness engineering. So these are the uh like practical use cases of jet. So in this documentation you can also see it's good at routing classification

[18:48] reference relevance and filtering workflow getting semantic verification workflow getting semantic verification agent next action selection and and and end. We'll also see what is Jeff not good for. So it is not good for

[19:03] open-ended text generation like the models that used to like write articles code or other created text. It is not good at exact counting like calculations and identities in code. It is not good at date and time comparisons, multiple

[19:20] layers of indirection and it is also not suitable for large states full of irrelevant context like retrieving and filtering first. It is not Jev's work.

[19:32] filtering first. It is not Jev's work. So this is where Jeff fits and the so I official documentation of any of the software then you will have a complete idea before actually using it in your real life. So go to the official website

[19:49] of Jev and here you can see everything what is Jev it's like tutorial in 30 seconds in nutshell you'll get everything in detail. So in nutshell you will find out everything you need to know about Jeb. So let's start with the

[20:04] know about Jeb. So let's start with the demo of Jeb application. For this you just need to go onto the TypeScript official website. Here [snorts] click on this first website and here you will see introducing Jev intelligence beyond

[20:19] chat. So it is as we have discussed that it is being recently implemented and bought for us by type safe. You can see its interface and here it is 193.6x

[20:33] its interface and here it is 193.6x faster and triple 4.6x cheaper. So just go through this read this it will be really amazing for you to understand its actual features. So from here you can see the document the official document

[20:48] see the document the official document of type safe AI that uh explains us the basics of je. So before starting with the actual demo, I highly recommend you to go to this document and just have a look. Already we have covered these

[21:02] look. Already we have covered these points in our PPT. But then also if there are any doubts you can directly reach out to this uh documentation and it is an official documentation given to us by type safe. So without wasting any

[21:17] further time, let's start with the actual demonstration of Jeff. So here it is verifying our account verification is successful and it's the homepage of Jev.

[21:30] So here on the left hand side you can see uh some of the icons like homepage playground which is one of the most important features of Jeff where we will actually writing and giving the context to Jeff and ask questions based upon the

[21:46] uh content we have given. So playground is one of the most important thing where we will actually be implementing our Jav application and you'll see it in the further uh and you will see this in our further tutorial. Then we have usage

[22:00] that where we can actually use our Jeff. Then we have API keys that are very important if we want to integrate our Jeff with any other application we want Jeff with any other application we want like it works as an bridge between two

[22:14] application Jeff and any other software application and then as we have discussed we have the official documentation. So without any further ado let's get started with playground.

[22:26] So this is how the interface of our J playground will look like. Here there are two types of input section you can see on the screen. First we have state and second we have questions. So state is just a place where we can paste our

[22:40] content like from that content the reference of the content from which we want to ask the questions. So this kind of a content could be a plain text. So that it could be like it could be a rum, a support ticket, a social media post or

[22:55] something much simpler like a customer message. So like this if you want to test we can paste any kind of information that we want Jeb to actually evaluate and below this you can see we have a questions panel. So it is there

[23:11] we tell Jeb what we actually want to know about that specific piece of content. So here you can see as we have discussed in our theory section that there are three types of questions null that works on yes or no basis. Then we

[23:25] have score where we want to evaluate the question on the basis of the score matrix. And then we have choice where we can ask multiplechoice questions. So these are the three available primitives we have null, score and choice. It is

[23:43] pretty simple, right? Just state and the questions we want to ask. That's simple questions we want to ask. That's simple to the point. So now before moving into any real life example let's run something very simple just to have a

[23:57] grasp of it like how it actually works. So here I'm giving a example where it says the customer said this product is absolutely amazing I love it and I will definitely buy it again. So first of all we'll give it as a null like yes or no

[24:14] we'll give it as a null like yes or no kind of a situation where we will ask is this customer satisfied. This is the parameter we have given we we are asking here that is why it will return yes or no. Then the type you can see it is null

[24:30] and then we have instructions. So instructions is like is this customer happy with their purchase and true we can give yes he [snorts] is not happy

[24:42] and from this add question button we can add multiple questions at once. So this was a null type of a question. If we want to implement all the three types of questions in the one uh state only then

[24:56] we can uh click on add question. But as of now I'm just running this to show you something. If you'll run no you will see our organization is out of funds that our organization is out of funds that means type space this means Jeff is not

[25:11] free to use although we waited for the wait list we got the chance to get into wait list we got the chance to get into and login into type safe to use Jeff but it is not opensource software by types safe AI but here's a catch you need not

[25:28] worry because I have figured out an open-source software ware which will actually work like Jeb, you can take the advantage of Jeff features in that opensource software. If you want to add the funds and want to continue in this

[25:42] console only you can definitely go ahead. I'll show you like right now you can see on our screens our balance is absolutely zero because I want to show you how freely we can use the feature of type safe. So from here you can like uh

[25:56] fill the required details add the payment method billing address and then you'll be able to add your particular credits but let's not get into this and wait and watch and I'll show you absolutely free way. So there is a

[26:11] website called jplayground you can directly type jplayground.com and this interface will be visible to you that will exactly work like the j provided by type safe. So just like we saw there we have input that is state and question.

[26:27] We have three types of question that is boolean which is noun choice and score. Here we can run the Jeb and I'll show you how freely we can access Jeb. There are no limitations on credits, no limitations on the count of questions

[26:42] and the count of input variables you really want to test with Jeb. We also have an example loaded here. So but I will explain you with our example only. Uh the example you remember we used there in our type safe actual website.

[26:58] I'll pick it this again. Question I want to ask is a yes or no question and I'll ask is the customer happy with the purchase and the Jeb will return yes or purchase and the Jeb will return yes or no. Uh like probability of yes or no.

[27:13] And now when we will run this I repeat now let's run this. So the decision came out to be yes which is 98% of probability and no is just 2% because it

[27:26] was clearly visible. The customer said the product is absolutely amazing. I love it and will definitely buy again. So the statement itself shows that uh So the statement itself shows that uh yes the customer is happy. But within

[27:39] 1,556 milliseconds the j has given us the absolute probability. No ifs, no buts, direct decision. So now you got the idea

[27:51] how Jeb actually works. So let's understand it with the real life examples. So first of the examples we'll be taking a rumé of any of the candidates and we'll see whether that candidate is the right fit for the role

[28:04] candidate is the right fit for the role or not. So like uh I have taken the réumé of a girl called as Surirana. I have just pasted that rumé in the text format who is a Python developer. Let's go through the resume first, right? Then

[28:18] profile summary, work experience in Python, then key skills like Python, JavaScript, SQL, Git, Jupyter notebook, education is also good. She has done BTE, academic projects and so on. So we have got the basic idea of our content

[28:33] achievements also. Now we will be asking all the three questions at once for this kind of a or this piece of content we actually want to evaluate. So uh like right now we are using single question but for the same type of uh content we

[28:50] can use multiple questions at once and I'll show you how. So the as usual the first will be a null question their answer will be yes and no. So I have given the question is that does this candidate has the hands-off experience

[29:05] candidate has the hands-off experience in Python development. So as of now as we have seen the answer should be yes. So this was the first parameter. Second will be our score. We will uh like put it on the score whether like what is the

[29:21] probability of or how much fit that particular candidate is for this role. And for this we'll be using order scale. You can see the Rubik's cube. No 0 1 2 3 4. That means like it it works in a alpha. It will work only in the

[29:36] ascending order like zero with the least priority and four with the highest. How priority and four with the highest. How much fit this candidate is for Python much fit this candidate is for Python development role score we have given.

[29:49] And then the third question will be the choice. Choice that whether the company should give the candidate a chance or let her go like simply reject it or accept the uh candidates's resumeum. So can we select this candidate or simply

[30:05] reject the candidate? And there are predefined four choices for this question that execute or ask user investigate or directly block. And according to the content provided by us above in the state section, Jeb will

[30:20] above in the state section, Jeb will evaluate the entire resume at once and then we'll question all the so here what Jeb will do I'll explain you how it actually works in the background. So we have given the state let it means the

[30:33] piece of information we want the Jeff to evaluate. Then the three questions. Now Jeb will evaluate the entire resume at once and then question then try to answer all these three questions at once. Let's see how like three or five

[30:48] questions we have added. We can add more questions if we want to add but as of now primarily we have three types of a question. When we'll be clicking on run Jeff here you can see three answers in one call. That is multiple decisions

[31:02] taken by Jeff at once. So first it is saying yes it means the candidate is right fit for the Python development role and which we have seen in the resumeum itself that it has a valuable experience skills and the minimum

[31:18] requirement that is being asked from a Python developer. Then how much fit the candidate is the ratings is being given by or we can say the probability is 2.68 by or we can say the probability is 2.68 68 out of four which is somehow comes

[31:31] under the category of high which is 69%. So directly giving answer it gives us a So directly giving answer it gives us a percentage. So yes we can consider it as a high level and or we can say high high fit for the Python development role. And

[31:48] then the third question is can we select this candidate or reject and the answer has came out to be entry that you can go ahead with this candidate with 50% of the probability that is pretty simple just asking questions giving the choices

[32:05] the appropriate choices and Jeb will execute it in milliseconds here you can execute it in milliseconds here you can say the model is type save je and 997 millconds it took to answer all our three questions

[32:21] to answer all our three questions precise to the point. Okay, I believe that things might not be clear as much as of now. To make it more clear and to explain its functionality in more depth, let's go to our second example and that

[32:35] is support ticketing example. So this is another place where a lot of time get wasted before the actual problem even reaches to the right person. So to solve this dependency we are using Jeb here. Someone has to read the message figure

[32:50] out how serious it is decide what the customer wants and then route it to the correct department and this take hell lot of time and that can be slow when hundreds of tickets are coming in at once. So for this we are going to use a

[33:06] support ticket PDF and I'll show you how easily Jeff can figure out all of this at once. So now I have taken one of the support ticket which is being given by support ticket which is being given by Alex and the idea is refund request it

[33:21] is for the damaged product he has received. So we have the required information that I received my wireless headphones yesterday but the product appears to be damaged and the left speaker isn't working. So I still have

[33:34] the original packaging but I need the like refund for my and the complete like refund for my and the complete refund. Okay. So now evaluate this. Now let's evaluate the support ticket with all the three questions we have. So now

[33:49] in our question we'll ask whether the like Alex has asked for the full refund or not. Whether Alex asked for the full refund. So according to the text provided it should evaluate. Now coming to the second question which will be the

[34:03] score. How severe is this case to be solved like the urgency level of the ticket to be resolved. Uh so it will give us the score which will be like lowest to highest, four means critical and zero means no urgency. And then we

[34:16] have the third type of a question which will be a choice question. It means where we can ask that which department should uh like if it is very serious then which department should handle this kind of a request. And here we can give

[34:30] our own four choices like a billing department or technical support department or returns or refund department or it is customer support department. So according to our choice we have given the four choices and out

[34:45] of this it should make the correct decision. So we have given the content to be evaluated all the three questions to be asked. Now let's do the rest part by Jeb. Jeb will take care of other things. Three answers in one call. So

[35:02] whether Ellis asked for a full refund, yes, because it was clearly written in the like support ticket that I want the full refund. Then the second question is how urgent the ticket is based upon the customer tone and it [snorts] has given

[35:16] customer tone and it [snorts] has given it it is the nearest 2.74 probability that is really high because he wants the refund on the very urgent basis. And then the third question is to decide which department should receive it. So

[35:30] according to the choices we provided here it has chosen returns and refund here it has chosen returns and refund department and directly and no chaos no fighting no decision delayed whether which department is responsible for this

[35:44] direct returns and refund department which is a 100% probability. So this is which is a 100% probability. So this is how Jeff can handle the entire customer like support ticketing process in few seconds. In seconds if you want to check

[35:58] you can see it answered all the three questions in just 6 7 9 milliseconds. It is so so fast and it is proven here. Not only the theory but the proven example

[36:10] of its speed and the cost you have seen we can access it for absolutely free. So that kind of a decision can have a real impact in a support workflow. A ticket can come in, get evaluated in under what like 500 milliseconds and then reach the

[36:27] right department without anyone having to read it first or wait for the NLM to generate a paragraph then another system that has to parse it and then it also

[36:39] reduces the chances of a customer being bounced between different teams because the first routing decision missed the part of the problem. Simple, sorted. Give your question to Jeb and Jab will handle it. Wait, it's not over yet. Now,

[36:56] let's put Jeb to the test by giving it one of the hardest and toughest examples of ours where the answer will be either no or either yes, nothing in between.

[37:08] There are some questions that has a gray kind of answer, not a complete yes, not a complete no. Let's test how Jeb works in that kind of a scenario. So now we are going to put Jav on our test on content moderation example cases. So

[37:23] content moderation example cases. So here we have pasted a content moderation case report where the person is claiming that he like people like you are ruining this community by posting such kind of a post on any of the social media. So this

[37:37] could be yes or no because it is based on a subjective basis that the person particular person thinks that you are ruining the community but he or she ruining the community but he or she might not like it's just a post. So I've

[37:49] given the entire context here. Now let's evaluate or let's not waste our time and evaluate or let's not waste our time and let's j evaluate whether he or she is actually ruining the society or not. So this time the result will be less clear

[38:03] as compared to our previous two examples because there the answer was a complete no or complete yes but here it will be less clear and let's see how Jeff works less clear and let's see how Jeff works in that kind of a case. So I have asked

[38:16] a n question in social media post uh partic moderation violation under the platform policy like is this post is seriously violating something then we'll

[38:28] ask a score question the urgency like the probability of the being I repeat the probability of how severe the case is the score the metrics of the seriousness of the case. So we can type as how severe the potential violation is

[38:44] which will be like again 0 1 2 3 4 based on its urgency and criticalness. And then the third question will be a choice question like here we will decide which moderation action should be taken and we'll give the four choices according to

[39:00] our or we can put it on review. We can even give it human review like human involvement or we can say remove or the final will be escalate. So we have given

[39:12] the poll choices according to the context being provided above in the context being provided above in the state field. The let's jab to the rest state field. The let's jab to the rest of the duty. So here it has seen that is

[39:24] social media post content moderation violation in the platform and it is saying no. So now the second question we have seen uh the how severe the potential moderation is. So it has given us the moderate result with 83%. And in

[39:39] the third question to decide what moderation action should be taken it has decided to give as a human review the choice and which is 95% because the chev is not able to figure out whether he really committed crime or

[39:56] he was not because the context provided up is little gray. It can be yes cannot be no. So Jeff has gone to the safest side where the human will jump in and

[40:08] will perform the actual review. So I can say Jeff played really safe here. Thank learning and keep growing with simply learn.