Jev não é um concorrente do Claude. Veja para que ele serve

Ver no idioma original →

Autoria: Leon van Zyl · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Jev Is Not a Claude Killer. Here’s What It’s For · Canal: Leon van Zyl · 16:10 · Assistir no YouTube

Tópicos: Agentes de IA, Engenharia de software com IA, Modelos de IA

Resumo

Leon van Zyl explica que Jev não é um substituto para Claude ou outros modelos de fronteira: é um modelo rápido e barato, voltado a decisões simples de classificação. No exemplo, Jev analisa issues do GitHub, atribui categorias e escolhe qual agente deve cuidar de cada tarefa, retornando também uma pontuação de confiança. O vídeo mostra como configurar essa integração com GitHub Actions e TypeSafe AI, além de apresentar o uso de OpenRouter como alternativa de acesso. Por fim, o autor demonstra como os rótulos podem encaminhar issues para fluxos de trabalho automatizados de uma software factory.

Pontos-chave

• Jev é apresentado como um modelo voltado a decisões rápidas e classificação, não como um chatbot ou substituto de modelos com capacidade de raciocínio.
• As três formas de resposta descritas são choice, score e null.
• Jev pode classificar issues como bug, documentação ou melhoria e recomendar o agente responsável.
• As respostas têm uma estrutura previsível e incluem uma pontuação de confiança, que pode ser usada para encaminhar casos incertos à revisão humana.
• O autor compara os custos de Jev com os de outros modelos para tarefas de classificação em grande escala.
• A demonstração integra Jev a um repo do GitHub por meio de GitHub Actions.
• Os rótulos atribuídos às issues podem direcionar o trabalho para diferentes fluxos de uma software factory.
• OpenRouter é apresentado como uma forma de acessar Jev sem entrar na lista de espera da TypeSafe AI.

Capítulos

Início	Capítulo	Resumo
00:00	Demonstração: classificação de issues no GitHub	O vídeo apresenta um projeto em que Jev classifica uma issue e escolhe o agente adequado para trabalhar nela.
02:07	O que Jev faz e o que não faz	O autor diferencia modelos de decisões rápidas de modelos com raciocínio e explica as opções choice, score e null.
04:13	Formato de resposta, confiança e custos	A demonstração detalha a estrutura previsível das respostas, a pontuação de confiança e os custos de classificação.
06:50	Acesso ao Jev e configuração inicial	Após um anúncio, o vídeo mostra como acessar Jev pela TypeSafe AI ou pelo OpenRouter e criar uma chave de API.
10:09	Integração com GitHub e roteamento de agentes	O autor configura rótulos, instala a skill oficial e pede que uma GitHub Action classifique issues e escolha agentes.
14:00	Teste da integração e software factory	Uma nova issue confirma a classificação e o roteamento, e o vídeo mostra como os rótulos podem acionar uma software factory.

Citações

Jev não é um concorrente do Claude. — 00:00

Modelos de sistema um são feitos para tomar decisões muito rápidas e responder da forma mais barata e rápida possível. — 02:38

Você sempre receberá a mesma estrutura de volta ao usar Jev. — 05:17

Se você precisa de classificação rápida, Jev dá conta. — 05:48

Conceitos e entidades

• Jev (modelo): Modelo apresentado no vídeo como uma opção rápida e econômica para tarefas simples de classificação e tomada de decisão.
• TypeSafe AI (empresa): Empresa que oferece acesso ao Jev e uma API usada na demonstração.
• Claude (modelo): Modelo citado como exemplo de modelo de fronteira com mais capacidade de raciocínio do que Jev.
• Codex (ferramenta): Agente de programação que, no exemplo, é selecionado para tarefas de trabalho 3D e raciocínio espacial.
• OpenRouter (ferramenta): Serviço apresentado como alternativa para acessar Jev sem entrar na lista de espera da TypeSafe AI.
• GitHub Actions (ferramenta): Recurso usado na demonstração para chamar Jev quando uma nova issue é criada.
• software factory (conceito): Fluxo automatizado que encaminha issues para agentes conforme seus rótulos e tipo de trabalho.
• Leon van Zyl (pessoa): Criador do vídeo que demonstra a integração de Jev com um repo do GitHub.

Tradução completa (pt-BR)

00:00 Jev, da TypeSafe AI, é um modelo incrível, mas também está sendo superestimado neste momento. Vi vídeos demais chamando isso de um matador de Claude, mas não é. Ele não consegue nem escrever uma frase completa. Mas há uma tarefa em que ele é melhor e mais rápido do que qualquer LLM. E, neste vídeo, vou mostrar como usá-lo em um projeto real, não em uma demonstração. Então, vou mostrar o que vamos construir neste vídeo, e você poderá aplicar tudo o que aprendeu aqui para usar Jev em muitos casos de uso diferentes. Este é um dos meus repos do GitHub. É simplesmente uma aplicação web

00:30 com um modelo 3D de Claude. Temos esta mansão assustadora lá atrás, mas não temos uma expressão facial que mostre que Claude está com medo. Então, vamos criar esta nova issue e, em um segundo, veremos esses rótulos mudarem. Temos Agent Codex e Enhancement. O que aconteceu foi que, quando criamos esta issue, todo o conteúdo, como o título e esta descrição, foi enviado para Jev. Em seguida, pedimos a Jev para fazer duas coisas. Primeiro, pedimos a Jev para atribuir uma categoria. Uma issue pode ser uma melhoria,

01:02 documentação ou um bug. E Jev identificou corretamente que esta issue é, na verdade, uma melhoria, o que significa que é um novo recurso. Este repo do GitHub está conectado a uma fábrica de software e, no backend, tenho vários agents na frota, que é composta por agents Codex e agents Claude Code. Dependendo do tipo de trabalho envolvido nesta alteração, devemos atribuir o agent correto. E, para qualquer trabalho em 3D, ou qualquer trabalho que envolva raciocínio espacial, preciso usar Codex com GPT-6 Astra. Por isso, Jev identificou Codex como o agent de programação correto

01:35 Outra coisa útil é que temos este comentário mostrando exatamente o que recebemos de Jev. Quanto à categoria, Jev tinha 100% de certeza de que se tratava de um novo recurso e, no roteamento do agent, tinha 100% de certeza de que esta alteração deveria ser encaminhada para Codex. Também podemos ver outras informações úteis, como todo o contexto que enviamos para Jev e a resposta de Jev. Então, neste vídeo, vou mostrar como configurar tudo isso, e você também vai aprender a usar Jev em muitos tipos diferentes de projetos. Você

02:07 não precisa usá-lo apenas em um repo do GitHub. Você pode aplicá-lo a jogos ou ao que quiser. E você provavelmente viu na introdução que atualmente há uma lista de espera para entrar na Type-Safe, mas vou mostrar como você pode ter acesso ao Jev agora mesmo, sem precisar entrar nessa lista de espera. Mas, primeiro, que diabos é Jev? Vi gente demais comparando-o aos modelos de fronteira, como Claude e OpenAI, mas não poderia ser mais diferente disso. Jev é um modelo de sistema um, enquanto coisas como Claude e OpenAI são modelos de sistema dois. Mas

02:38 talvez você esteja se perguntando qual é a diferença na prática. Bem, modelos de sistema um são, na verdade, super simples. Eles foram criados para tomar decisões muito rapidamente e fornecer respostas da forma mais barata e rápida possível. Isso torna modelos como Jev perfeitos para tarefas de classificação. Já os modelos de sistema dois, como os modelos de fronteira, têm capacidade de raciocínio e muito mais inteligência. Essa distinção é muito importante. Como Jev é extremamente rápido, ele não consegue realizar tarefas complexas. Não consegue raciocinar e é muito ruim em coisas como

03:08 ciência e matemática. Ele também tem uma context window minúscula, de cerca de 32.000 tokens. Jev não é um chatbot. Você não pode interagir com ele da mesma forma que interage com Claude ou OpenAI. Ele só é bom mesmo em três tipos de tarefas: escolha, pontuação ou nulo. Em todas elas, podemos dar a Jev algum contexto sobre, sabe, qual é o problema ou o que queremos que ele faça. Mas também podemos fornecer uma lista de opções para ele escolher. Por exemplo, podemos dar a ele algum contexto sobre um problema, e ele precisa encaminhá-lo para algo como cobrança,

03:40 suporte técnico ou vendas. Ou, como no nosso repo do GitHub, deve classificar uma issue como um novo recurso, um bug ou uma alteração na documentação. Também podemos pedir a Jev para dar uma pontuação a algo. Por exemplo, podemos fornecer uma avaliação de cliente e pedir que ele dê uma pontuação: como é essa avaliação? Calma, frustrada ou muito irritada? E então temos o nulo. É quase como uma decisão booleana. Tipo: a afirmação é verdadeira? E ele responderá sim ou não, com um pequeno índice de confiança. Como você pode ver, nenhuma dessas opções retorna frases completas.

04:13 É uma classificação muito rápida. E, só para entrar um pouco nos detalhes técnicos, é assim que são a solicitação e a resposta reais de Jev. Na solicitação, podemos especificar o modelo, como Jev latest. Podemos fornecer algum contexto, como: o estado atual é algo como “socorro, meus pagamentos estão falhando há 3 dias”. Sabe, este é um comentário típico de um usuário. E então podemos fazer perguntas. Para nulo, poderíamos ter algo como “isto é urgente?”, com o tipo nulo e a instrução “isto transmite

04:45 urgência?”. Então, esta seção aqui diz a Jev para classificar isso como sim ou não. Ou podemos pedir a Jev para selecionar o departamento para o qual esta issue deve ser encaminhada. E, claro, estamos usando aqui o tipo choice, com a instrução “qual equipe deve cuidar disso?”. E tudo o que fazemos é fornecer algumas opções para ele escolher. E, claro, também podemos usar um tipo de pontuação para definir o nível de frustração. E a resposta de Jev será mais ou menos assim. E essa estrutura é determinística. Isso significa que você sempre receberá esta estrutura

05:17 consistente ao usar Jev. Isso significa que, se você usar código para fazer referência a este objeto ou mapeá-lo a partir de algo como N8N, terá a garantia de receber sempre a mesma estrutura. E uma coisa legal para notar sobre a estrutura da saída é que você também recebe de Jev este índice de confiança. É uma pontuação de 0 a 1; 1 significa 100%. Assim, você poderia adicionar uma lógica à sua aplicação para dizer: se o índice de confiança for menor que 0,75, então vamos encaminhar isso para

05:48 revisão humana. Agora, quando você decide entre usar Jev ou Claude para tarefas de classificação, a questão realmente se resume aos custos. Olha, se as decisões que você precisa tomar dependem de a matemática estar correta, de a ciência estar correta ou de exigir esforço de raciocínio, talvez não tenha outra opção a não ser usar algo como Claude. Mas, se você só precisa fazer classificações rápidas, Jev serve perfeitamente. E vou tentar calcular quanto custaria fazer um milhão de classificações com Claude para algo como repos do GitHub. Então, se você tivesse que fazer 1

06:19 milhão de classificações, Jev custaria apenas cerca de US$ 21, enquanto modelos mais baratos, como Sonnet 5, custariam cerca de US$ 1.500. E nem quero mencionar algo como Fable 5.1, a US$ 7.500. Então, para tarefas rápidas de classificação, como as de repos do GitHub, ou se você estiver criando workflows ou redirecionando issues entre departamentos diferentes, Jev é definitivamente a melhor opção. Agora, chega de conversa: como podemos usar Jev de fato? Mas, primeiro, uma breve

06:50 mensagem do patrocinador de hoje, Decodr. Quando você pede a um agent de IA para buscar algo em um site, há uma boa chance de ele voltar de mãos vazias. Sites reais simplesmente não entregam dados a algo que não seja um navegador de verdade, e agents de IA como Claude não são navegadores reais. Ou, como neste exemplo, os dados têm restrição geográfica. Se o agent fizesse uma solicitação da Alemanha, este site não retornaria nenhuma informação útil. Decodr oferece uma API de scraping da web com um servidor MCP à frente. Isso significa que você pode integrá-la a qualquer coisa que fale

07:21 MCP. Decodr fornece IPs rotativos, renderização de JavaScript e novas tentativas. Você informa um site — pode até especificar a localização geográfica —, seu agent usa o servidor MCP deles e recebe de volta Markdown limpo ou JSON estruturado. O plano gratuito da API de scraping da web oferece 2.000 créditos e é válido por um ano inteiro. E não é necessário cartão de crédito. Vou deixar um link na descrição do vídeo. E, se você usar o código Leon van Sale, terá 10% de desconto no seu primeiro plano pago. Obrigado à Coda por patrocinar este vídeo. Agora, vamos

07:55 de volta a isso. Para ter acesso ao Jev, você pode acessar TypeSauce.ai e entrar na sua conta. No momento da gravação, é preciso entrar em uma lista de espera. Eles realmente removeram a lista de espera por um curto período, mas parece que ela voltou. Então, para pular a lista de espera, você pode acessar o Open Router e criar uma conta por lá. O Open Router dá acesso à versão mais recente do Jev. Neste tutorial, vou usar o próprio TypeSauce. Mas, se quiser acompanhar usando o Open Router, sempre que eu mencionar TypeSauce ou a API do TypeSauce

08:29 para o agent de programação, você pode simplesmente mencionar o Jev na API do Open Router. Então, no painel do TypeSauce AI, há algumas coisas que precisamos ter em mente. Quando acessamos o playground, podemos ver exatamente como o Jev funciona. E, como mencionei antes, basicamente há três opções diferentes: null, score ou choice. Vamos clicar em um destes exemplos. Olha só, aí está aquela estrutura que você viu antes. E também podemos combinar várias perguntas diferentes. Então, não precisa ser só null: também pode haver pontuação ou choice. Tudo isso pode ser combinado em uma única

09:03 solicitação. Agora, poderíamos simplesmente substituir esses valores por valores reais. Mas, se executarmos isso, também receberemos uma resposta e teremos uma ideia de como essas respostas vão ser. E, quando mudamos para a visualização JSON, ela nos mostra a estrutura técnica que podemos esperar receber sempre que enviarmos essa solicitação. Essa estrutura é garantida. Para usar o Jev, precisamos criar uma chave de API. Então, o que temos que fazer é acessar API keys. Depois, vamos criar uma nova chave. Vou chamá-la de tutorial. E agora

09:37 temos nossa chave de API. Então, basta copiá-la e guardá-la em um lugar seguro. Use a sua própria chave, por favor. Vou excluir esta depois da gravação. Como este é um serviço pago, precisamos adicionar créditos à nossa conta. Quando me cadastrei, recebi US$ 5 em créditos gratuitos. Então, imagino que isso se aplique a todo mundo, e eu nem cheguei a usar nenhum deles. Essas solicitações são muito baratas. Mas, agora, tudo de que precisamos é de um repo do GitHub para conectar ao Jev. Você pode usar o meu código, se quiser, ou um dos seus

10:09 repos existentes, ou simplesmente enviar um novo repo fictício para o GitHub. Tanto faz. Então, basta acessar Code e copiar este comando aqui. Depois, podemos abrir nosso agent de programação. Vou usar o Claude Code. Vou selecionar Opus 5.5 e o nível alto de esforço de raciocínio. Clone este repo para a raiz do projeto. E vou colar a URL do GitHub. Certo, agora que copiamos todos os arquivos, vamos criar um novo repo no GitHub. Vou dizer:

10:39 “Pode criar um novo repo privado no GitHub para este projeto.” Legal. Nosso projeto está no GitHub. E o que queremos fazer agora é poder atribuir rótulos específicos sempre que criarmos uma nova issue. Isso é bem divertido. Fica a seu critério; você pode deixar isso tão complexo quanto quiser. Acho que, para esta demonstração, vou manter tudo bem simples. Já temos vários rótulos padrão, como bug, documentação e melhorias. Também podemos pedir ao nosso agent para adicionar rótulos personalizados. Por exemplo, digamos:

11:11 “Adicione estes rótulos ao repo do GitHub.” E digamos: “Claude usando Fable”. Digamos: “Codex usando Astra”. E talvez “Claude usando Haiku” para tarefas bem simples. Agora, quando atualizo este repo e acesso os rótulos, vemos os novos rótulos aqui. Certo, quando criarmos uma nova issue, queremos que o Jev a classifique como bug, documentação ou melhoria, e também decida a qual agent atribuir

11:46 o trabalho. Na verdade, se você estiver um pouco confuso sobre o que estamos fazendo, encontrei um diagrama bem legal na página da Vercel. Ele explica praticamente o workflow que estamos construindo agora. Esta é a fábrica de software que a Vercel está usando. E é muito parecida com o que estamos construindo. Uma pessoa cria uma issue e, em seguida, há uma etapa de identificação do tipo, em que chamam um LLM para identificar se a issue é um bug, um recurso ou documentação. Nesta etapa, também poderíamos fazer outras coisas, como atribuir

12:18 o tipo de agent que queremos usar no nosso enxame de agents. E o motivo de atribuirmos esses rótulos é que, quando a fábrica de software identifica a issue para processá-la, ela a encaminha pelo fluxo correto. Ela vai olhar os rótulos e dizer: “Certo, se for um bug, quero que um agent reproduza o erro, corrija-o, teste-o e depois crie um pull request.” Ou, se for um recurso novo, analise o recurso, veja se está alinhado com a visão do app, implemente-o, revise-o e faça o merge. Para alterações na documentação, é bem simples. Podemos usar um modelo bem barato

12:52 como o Haiku para fazer a alteração na documentação e depois fazer o merge. É uma issue de baixo risco. Outra coisa que gosto de fazer é instalar a skill Type Safe Agent. Esta é a skill oficial da Type Safe AI e vai ensinar seu agent a usar o Jev e as APIs deles. Também vou deixar o link para este repo do GitHub na comunidade gratuita. Então, basta copiar esta URL, voltar para o seu agent e pedir: instale esta skill na pasta do projeto. Legal, agora esta skill vai ensinar nosso agent a usar o Jev.

13:25 Então, adivinhe só? Agora, basta dizer o seguinte: Sempre que adicionarmos uma nova issue a este repo do GitHub, o Jev deve ser chamado por meio de uma GitHub action para fazer o seguinte. Um: rotular a issue como melhoria, bug ou alteração na documentação. Dois: atribuir um rótulo de agent, como Claude Fable, Codex Astra ou Claude Haiku. Para os agents, tarefas avançadas de programação devem ser atribuídas ao Fable. Qualquer coisa que exija raciocínio espacial deve usar o Astra, como animações 3D e geração de imagens, e o Haiku será usado para alterações na documentação. Adicione um

14:00 comentário mostrando a entrada e a resposta do Jev, além da pontuação de confiança de cada categoria. Depois, podemos simplesmente fornecer a chave de API do Type Safe. E é isso. Vou enviar esta mensagem. Certo, estou pedindo ao Claude para enviar todas essas alterações ao GitHub. Vamos testar. Vamos criar uma nova issue. Vou dizer: “Adicione uma nova emoção: assustado”. Vamos criá-la. Legal, recebemos a resposta do Jev. Ele classificou como melhoria e, para o agent, vamos usar Codex Astra. Também vemos este novo comentário.

14:32 Ela foi rotulada como melhoria com uma pontuação de confiança de 1, o que significa 100%. Para o agent, ele selecionou Astra com uma pontuação de confiança de 0,62. Então, talvez a descrição estivesse um pouco ambígua. Podemos decidir exatamente como queremos lidar com isso. De qualquer forma, Astra ou Fable dariam conta dessa alteração perfeitamente. E aqui podemos ver a entrada enviada ao Jev e também a resposta do Jev. E, se você olhar os tokens, foram usados menos de 800 tokens, o que não é nada. Agora,

15:05 se quiser ir um passo além, você pode conectar este repo a uma fábrica de software de verdade. Deixe-me mostrar como ela é em outro repo. Este é um repo de um jogo RTS, e criei esta issue dizendo, sabe, “melhore o visual”. Essa alteração foi atribuída ao Claude e classificada como melhoria, e adicionei um rótulo chamado ready. O rótulo ready acabou de mudar para factory running, o que significa que um dos agents do meu enxame de agents está trabalhando ativamente nesta alteração. E, assim que essa

15:35 quando o agent concluir, ele criará um pull request que eu poderei revisar e mesclar de volta neste projeto. Então, se você quiser aprender a construir uma fábrica de software, vou deixar um link para ela na descrição deste vídeo. Se quiser aprender a usar agents de programação de forma eficaz e criar coisas realmente legais, como fábricas de software, talvez queira considerar entrar para a comunidade da minha escola, Agenty Labs. Isso dará acesso à minha masterclass de programação da Agenty, que contém horas de vídeos mostrando como usar agents de programação de forma eficaz e criar projetos reais. Também temos sessões ao vivo para tomar um café, nas quais você pode me perguntar qualquer coisa, e também temos sessões semanais de aprofundamento. Na verdade,

16:10 nesta próxima quinta-feira, faremos um aprofundamento sobre JFAI. Então, talvez você não queira perder essa sessão. Vou deixar um link para a Agenty Labs na descrição deste vídeo. Muito obrigado por assistir, e até a próxima. Tchau, tchau.

Transcrição original

[00:00] Jeff from TypeSafe AI is an incredible model, but it’s also being overhyped right now. I’ve seen too many videos calling this a Claude killer, and it’s not. It can’t even write a full sentence. But, there is one job it does better and faster than any LLM. And in this video, I’ll show you how to use it in a real project, not a demo. So, let me show you what we’ll build in this video, and you can apply everything you’ve learned here to apply Jeff to so many different use cases. This is one of my GitHub repos. This is simply a web

[00:30] application with a 3D model of Claude. We’ve got this spooky mansion sitting back here, but we don’t have a facial expression showing that Claude is scared. So, let’s create this new issue, and within a second, we’ll see these labels change. We’ve got Agent Codex and Enhancement. So, what happened is when we created this issue, all of the contents, like the title and this description, was sent to Jeff. We then asked Jeff to do two things. First, we asked Jeff to assign a category. An issue can either be an enhancement,

[01:02] documentation, or a bug. And Jeff correctly identified that this issue is actually an enhancement, which means it’s a new feature. This GitHub repo is hooked up to a software factory, and in the back end, I’ve got multiple agents in the fleet that consists out of Codex agents and Claude code agents. Depending on the type of work in this change, we should assign the correct agent. And for any 3D work, or any work that involves spatial reasoning, I’ll have to use Codex with GPT-6 Astra. That’s why Jeff identified Codex as the correct coding

[01:35] agent. What’s also useful is we’ve got this comment showing exactly what we got back from Jeff. And for the category, Jeff was 100% sure this was a new feature, and for the agent routing, it was 100% sure this change should be passed to Codex. We can see some other useful information as well, like all the context that we sent over to Jeff, as well as Jave’s response. So, in this video, I am going to show you how you can set all of this up, and this will teach you how to use Jave across many different types of projects as well. You

[02:07] do not have to use it within a GitHub repo only. You can apply it to games or whatever you want. And you probably saw in the intro that there’s currently a waiting list to join Type-Safe, but I will show you how you can get access to Jave right now without having to join this wait list. But first, what the heck is Jave? I’ve seen too many people compare this to the frontier models like Claude and Open AI, but it couldn’t be further from the truth. Jave is a system one model, whereas things like Claude and Open AI are system two models. But

[02:38] you might be wondering, what is the actual difference? Well, system one models are actually super simple. They’re built to make really quick decisions and give you the responses cheaply and quickly as possible. This makes models like Jave perfect for classification work. Whereas system two models like the frontier models have reasoning and a lot more intelligence. This distinction is really important. Because Jave is so blazingly fast, it can’t do complex work. It can’t reason, and it’s really bad at things like

[03:08] science and math. It’s also got a tiny context window of about 32,000 tokens. Jave is not a chatbot. You can’t interact with it the same way you can with Claude or Open AI. It’s really only good at three types of tasks. Choice, score, or null. For all of these, we can give Jave some kind of context about, you know, what the problem is or what we want it to do. But then we can either give it a list of choices to select from. For example, we could give it some context about a problem, and it needs to route it to something like billing,

[03:40] technical, or sales. Or like with our GitHub repo, it should classify an issue as being a new feature, a bug, or a documentation change. We can also ask Jave to score something. So, we could give it a customer review and then ask it to give it a score of what’s this review? Calm, frustrated, or very angry. And then we’ve got null. This is almost like a boolean kind of decision. Like, is the statement true? And it will say either yes or no with a little bit of a confidence score. As you can see, none of these return full-blown sentences.

[04:13] It’s really quick, rapid classification. And just to get a little bit technical for a second, this is what the actual request and response looks like from Jeff. In the request, we can specify the model like Jeff latest. We can give it some kind of context like this current state is something like help, my payouts have been failing for 3 days. You know, this is a typical comment from a user. And then we can ask it questions. So, for null, we could have something like is this urgent with a type of null with an instruction, does this convey

[04:45] urgency? So, this section here will tell Jeff to kind of score this as a yes or no. Or we can get Jeff to select the department that this issue should be routed to. And of course, we’re using type choice here with instruction, which team should handle this? And all we’re doing is we’re giving it a couple of choices to select from. And of course, we can use a scoring type as well to set the frustration level. And the response from Jeff will look something like this. And this structure is deterministic. This means that you will always get this

[05:17] consistent structure back when using Jeff. This means if you’re using code to reference this object or you’re mapping to it from something like N8N, you are always guaranteed that you will receive the same structure back. And one cool thing to note about the output structure is that you do get this confidence score back from Jeff as well. This is a score from 0 to 1, 1 meaning 100%. So, you could add some logic in your application to say, if the confidence score is less than 0.75, then let’s actually just pass it to

[05:48] human review instead. Now, when you decide between using Jef or Claude to do classification work, it really does come down to costs. Look, if the decisions you need to make rely on, you know, the math being accurate or the science being accurate or needing reasoning effort, you might have no choice but to use something like Claude. But, if you just do quick classification work, Jef is perfectly fine. And I’ll just try to map out what a million classifications with Claude cost you for something like GitHub repos. So, if you had to do 1

[06:19] million classifications, Jef would only cost you like $21, where cheaper models like, you know, Sonnet 5 would cost you about $1,500. And I don’t even want to mention something like Fable 5.1 at $7,500. So, for quick classification work like with GitHub repos or if you are building workflows or redirecting issues between different departments, Jef is definitely the way to go. Now, enough said, how can we actually use Jef? But, first, a quick

[06:50] word from today’s sponsor, Decodr. When you ask an AI agent to pull something off a website, there’s a decent chance it will come back with nothing. Real websites simply won’t hand data over to something that’s not a real browser, and AI agents like Claude isn’t one. Or like in this example, this data is actually geo-restricted. If the agent had to do a request from Germany, this website won’t return any useful information. Decodr has a web scraping API with an MCP server in front of it. This means you can drop it into anything that speaks

[07:21] MCP. Decodr provides rotating IPs, JavaScript rendering, and retries. You give it a website, you can even specify the geo-location, your agent will use their MCP server, and your agent will get back clean markdown or structured JSON. The web scraping API free plan gives you 2,000 credits and is valid for a full year. And no credit card is required. I’ll leave a link in the description of the video. And if you use code Leon van Sale, you’ll get 10% off your first paid plan. Thanks to Coda for sponsoring this video. Now, let’s get

[07:55] back into it. In order to get access to Jef, you can go to TypeSauce.ai and log in to your account. Now, at the time of recording, you do have to join a waitlist. They actually removed the waitlist for a short period of time, but it seems to be back again. So, in order to skip the waitlist, what you can do is actually go to Open Router and just sign up for an account over there. Open Router does give you access to the latest version of Jef. For this tutorial, I will be using TypeSauce itself. But if you do want to follow along with Open Router, whenever I mention TypeSauce or the TypeSauce API

[08:29] to the coding agent, you can just mention Jef within the Open Router API. So, from the TypeSauce AI dashboard, there’s a couple of things we have to keep in mind. When we go to playground, we can actually see exactly how Jef works. And as I mentioned earlier, you basically have three different options: null, score, or choice. Let’s click on one of these examples. And look at that, there’s that structure that you saw earlier. And we can also combine multiple different questions. So, it doesn’t just have to be null, it can also be scoring, it can also be choice. These can all be combined into a single

[09:03] request. Now, we could just swap out these values for, you know, actual values. But if we run this, we get a response back as well, and we get an idea of what these responses are going to look like. And when we switch over to the JSON view, this will give us that technical structure that we can expect back every time we send this request. This structure is guaranteed. In order to use Jef, we will need to create an API key. So, what we have to do is go to API keys. Then, let’s create a new key. I’ll just call this tutorial. And now

[09:37] we’ve got our API key. So, just copy this key and store it in a safe place. Please use your own key. I am going to delete this one after this recording. Now, because this is a paid service, we do have to add some credits onto our account. When I signed up, I actually got $5 of free credits. So, I assume that applies to everyone, and I actually haven’t even used any of it. These requests are so cheap. But, so all we need now is a GitHub repo to attach Jeff to. Now, you’re more than welcome to use my code, or you can use one of your

[10:09] existing repos, or just push a new dummy repo to GitHub. It doesn’t matter. So, all you have to do is go to code, then copy this command over here. Then, we can open up our coding agent. I’ll just use Claude code. I’ll set this to Opus 5.5 and on high reasoning effort. Please clone this repo to the root of the project. And I’ll just paste in that GitHub URL. All right, now that we’ve copied all the files over, let’s create a new GitHub repo. So, I’ll just say,

[10:39] “Go ahead and create a new private GitHub repo for this project.” Cool. So, our project is down GitHub. And what we want to do now is, whenever we create a new issue, we want the ability to assign very specific labels. Now, this is really fun. This is up to you. You can make it as complex as you want. So, I think I’m just going to keep it really simple for this demo. We already have a bunch of default labels like bug, documentation, and enhancements. We can also ask our agent to add custom labels as well. For instance, let’s say,

[11:11] “Please add these labels to the GitHub repo.” And let’s say, “Claude running Fable.” Let’s say, “Codex running Astra.” And maybe “Claude running Haiku.” for very simple work. Now, when I refresh this repo and I go to labels, we can see the new labels over here. All right, what we want Jase to do when we create a new issue is classify this issue as being either a bug, documentation, or an enhancement, and it should also decide which agent to assign

[11:46] this work to. In fact, if I’m confusing you a little bit on what we’re actually doing, I found this really cool diagram on Vercel’s page. This explains pretty much the workflow that we’re building now. This is the software factory that Vercel is actually using. And this is very similar to what we’re building. So, a human will create an issue, then there’s this identify type step where they call an LLM to identify the issue as being either a bug, a feature, or documentation. We could, in this step, also do additional things like assign

[12:18] which type of agent we want to use in our agent swarm. And the reason we’re assigning these labels is when the software factory picks up that issue to actually process it, it’s going to route the issue down the correct flow. So, it’s going to look at the labels and say, “Okay, if I’m a bug, then I want an agent to actually reproduce the error, fix it, test it, and then create a pull request.” Or if it’s a new feature, analyze the feature, see if it’s aligned with the vision of the app, implement the feature, review it, and merge it. For documentation changes, it’s really simple. We can use a really cheap model

[12:52] like Haiku to make the documentation change and then merge it. It’s a low-risk issue. Now, what I also like to do is to install the Type Safe agent skill. And this is the official skill from Type Safe AI, and this will teach your agent how to use Jase and their APIs. I’ll link to this GitHub repo in the free community as well. So, all you have to do is copy this URL, then let’s go back to your agent, and please install this skill in the project folder. And cool, this skill will now tell our agent how to actually use Jase.

[13:25] So, guess what? All we have to do now is say the following. Whenever we add a new issue to this GitHub repo, Jave needs to be called via a GitHub action to do the following. One, label the issue as being an enhancement, bug, or documentation change. Two, assign an agent label like Claude Fable, Codex, Astra, or Claude Haiku. For the agents, advanced coding tasks should be assigned to Fable. Anything requiring spatial reasoning should use Astra like 3D animations, image generation, and Haiku will be used for any documentation changes. Add a

[14:00] comment showing Jave’s input and response and the confidence score for each category. And then we can just pass it the type safe API key. And that’s it. I’m just going to send this message. All right, so I’m just asking Claude to push all of these changes to GitHub. Let’s give this a spin. Let’s go and create a new issue. I’ll just say add a new emotion and scared. Let’s create this. And cool, we got the response back from Jave. It assigned this as an enhancement and for the agent we’ll use Codex Astra. We also see this new comment by the way.

[14:32] It was labeled as an enhancement with a confidence score of one, which means 100%. For the agent it selected Astra with a confidence score of 0.62. So, maybe the description was a little bit ambiguous. So, we could really decide how we want to deal with this. But either way, Astra or Fable would have been perfectly fine at doing this change. And here we can see the input that was passed to Jave and we can also see Jave’s response. And if you have a look at the tokens, this burnt like less than 800 tokens, which is nothing. Now,

[15:05] if you want to take this a step further, you can hook this repo up to an actual software factory. Let me show you what it looks like on another repo. So, this is a repo for an RTS game and I created this issue just saying, you know, improve the visual all This change was assigned to Claude and it’s classified as an enhancement and I’ve set this label called ready. The ready label just turned into factory running and this means that one of the agents in my agent swarm is now actively working on this change. And once this

[15:35] agent completes, it will create a pull request which I could review and merge back into this project. So, if you want to learn how to build a software factory, I’ll link to it in the description of this video. If you want to learn how to use coding agents effectively and build really cool stuff like software factories, then you might want to consider joining my school community, Agenty Labs. This will give you access to my Agenty coding masterclass, which contains hours of video showing you how to effectively use coding agents and build real projects. We also have live coffee sessions where you can ask me anything and we have weekly deep dive sessions as well. As a

[16:10] matter of fact, this coming Thursday, we are doing a deep dive on JFAI. So, you might not want to miss that session. I’ll leave a link to Agenty Labs in the description of this video. Thank you so much for watching and I’ll see you in the next one. Bye-bye.