Criando um harness com Jev

Autoria: LangChain · 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: Building a Harness with Jev · Canal: LangChain · 09:09 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Ferramentas de desenvolvimento com IA, Modelos de IA

Resumo

Sydney, gerente de produto da equipe open source da LangChain, apresenta Jev, um modelo System 1 da TypeSafe AI que retorna decisões tipadas com rapidez, em vez de gerar texto como um LLM tradicional. O vídeo explica três tipos de perguntas que Jev pode responder — escolha, pontuação e booleano — e mostra como integrá-lo à LangChain. Entre os usos apresentados estão roteamento de modelos, análise de risco de tool calls e avaliação online de agentes. Jev é apresentado como uma alternativa mais rápida e barata para tarefas especializadas de classificação e decisão.

Pontos-chave

Jev é um modelo System 1 que avalia um estado e perguntas e retorna respostas tipadas e probabilidades.
Em tarefas de classificação, Jev pode ser de 20 a 200 vezes mais rápido e de 40 a 400 vezes mais barato que um LLM, segundo a apresentação.
Jev não é um substituto direto para LLMs: é voltado a tarefas especializadas de decisão.
O modelo pode responder perguntas de escolha, pontuação e booleanas.
É possível enviar várias perguntas sobre um mesmo estado para serem respondidas em paralelo.
A integração LangChain TypeSafe permite invocar Jev usando um estado e perguntas, com uma chave de API da TypeSafe.
Jev pode ajudar a escolher entre modelos rápidos e baratos ou modelos mais poderosos, conforme a complexidade da tarefa.
O vídeo também apresenta o uso de Jev para bloquear tool calls arriscadas e avaliar respostas de agentes com rubricas.

Capítulos

Início	Capítulo	Resumo
00:00	O loop de agentes e a estruturação de saídas	A apresentadora revisa o loop de agentes e explica como tool calling e saídas estruturadas ajudam a usar LLMs em aplicações baseadas em código.
01:34	O que é Jev	Jev é apresentado como um modelo System 1 que retorna decisões tipadas rapidamente, com comparação de velocidade e custo em tarefas de classificação.
04:15	Tipos de perguntas e integração com LangChain	O vídeo demonstra perguntas de escolha, pontuação e booleanas e apresenta a integração LangChain TypeSafe para usar Jev.
06:00	Casos de uso e avaliação de agentes	Jev é aplicado a model routing, análise de risco de tool calls e online evals, antes de a apresentadora indicar como começar a usá-lo.

Citações

Jev não recebe texto e gera texto como os LLMs tradicionais. — 02:04

Jev não é um substituto direto para um LLM. — 02:35

Jev é muito eficiente quando precisa responder a muitas perguntas de uma vez. — 05:22

É hora de criar algo legal com Jev. — 08:39

Conceitos e entidades

Jev (modelo): Modelo System 1 da TypeSafe AI que retorna decisões tipadas e probabilidades para tarefas especializadas.
TypeSafe AI (empresa): Startup que desenvolveu Jev e oferece acesso ao modelo por meio de uma API.
LangChain (empresa): Empresa cuja integração com TypeSafe permite usar Jev em aplicações.
Sydney (pessoa): Gerente de produto da equipe open source da LangChain e apresentadora do vídeo.
System 1 (conceito): Categoria de modelos descrita como voltada a decisões estruturadas rápidas que podem ser usadas diretamente por software.
model routing (conceito): Seleção de um modelo rápido ou mais poderoso conforme a complexidade de uma pergunta ou tarefa.
Auto mode (ferramenta): Middleware da LangChain que pode usar Jev para identificar e bloquear tool calls arriscadas durante a execução.
online evals (conceito): Avaliações de traces de agentes em que um modelo pontua as respostas com base em critérios definidos.
TypeSafe classifier (ferramenta): Integração da LangChain TypeSafe usada para invocar Jev com um estado e perguntas.

Tradução completa (pt-BR)

00:00 Oi, pessoal, meu nome é Sydney. Sou gerente de produto da equipe de open source da LangChain. Hoje estou muito animada para mostrar como vocês podem criar um harness com Jev, esse novo modelo que acabou de ser lançado pela TypeSafe AI. Antes de vermos o que é Jev e por que ele é tão empolgante, quero recapitular rapidamente o loop central de agent com o qual todos já estamos acostumados. Uma solicitação chega. Nós a enviamos para um LLM. E ele consegue agir usando ferramentas. Então, chama uma ferramenta, recebe alguns resultados e os processa,

00:32 e então pode continuar nesse loop de tool calling ou decidir que terminou uma determinada tarefa e retornar um resultado. Esse loop é muito poderoso, mas os LLMs são um pouco imprevisíveis, certo? Eles recebem texto e produzem texto. Por isso, quando os LLMs surgiram, decidimos que precisávamos de maneiras de impor um pouco mais de estrutura a eles, para que pudessem funcionar bem em aplicações orientadas por código, que dependem inerentemente de tipos estruturados, e não apenas de texto bruto.

01:02 Foi aí que entraram o tool calling e as saídas estruturadas. No tool calling, o modelo pode enviar uma solicitação estruturada. Neste caso, uma solicitação para obter um pedido com um ID específico; então, a ferramenta retorna um resultado com dados estruturados. O outro recurso primitivo que adicionamos são as saídas estruturadas. A ideia é que você possa vincular um tipo de saída ao modelo, para que ele produza um resultado final que siga um determinado esquema JSON, em vez de apenas texto bruto. E esses dois recursos primitivos facilitaram muito o aproveitamento desse loop realmente poderoso

01:34 em aplicações baseadas em código. Certo, agora vamos à parte empolgante: o que é Jev? Há muito burburinho agora no Twitter sobre esse novo modelo. Por que todo mundo está falando dele? Jev é o que chamamos de modelo System 1, criado por essa nova startup que acabou de surgir, chamada TypeSafe AI. De acordo com a documentação deles, modelos System 1 são uma classe de modelos de IA desenvolvidos para tomar decisões estruturadas rapidamente, que o software pode usar diretamente. Um modelo System 1 avalia um estado e perguntas

02:04 e retorna respostas tipadas e probabilidades. Aqui no slide, vocês podem ver um exemplo de estado, perguntas e respostas tipadas. O interessante é que Jev, na verdade, não recebe texto e gera texto, como fazem os LLMs tradicionais com os quais estamos acostumados. Parte do motivo de Jev estar tão popular agora é que ele pode ser de 20 a 200 vezes mais rápido e de 40 a 400 vezes mais barato em tarefas de classificação, em comparação com um LLM.

02:35 Jev não é, portanto, um substituto direto de um LLM, mas pode executar tarefas especializadas que atualmente pedimos aos LLMs para fazer, só que muito mais rápido e por muito menos. Se você está curioso para saber de onde vem essa expressão System 1, ela vem do livro do psicólogo Daniel Kahneman, Thinking Fast and Slow. Nesse livro, ele descreve duas formas de a mente pensar: rápida e barata, a intuição do System 1, em contraste com lenta e cara, o raciocínio do System 2. E a TypeSafe AI pegou emprestada essa ideia para seu novo modelo chamado Jev, chamando-o de modelo System

03:09 1. Ele é rápido e barato, retornando decisões tipadas quase instantaneamente em vez de gerar texto, em contraste deliberado com os LLMs padrão, que se comportam mais como o System 2: mais lentos e caros, mas seguindo mais esse raciocínio passo a passo para problemas abertos. Certo, vou mostrar uma demonstração rápida de como um LLM responde a uma pergunta em comparação com Jev. A pergunta é: há PII neste texto? Um LLM produz este resultado em texto,

03:43 e a saída estruturada também leva cerca de cinco segundos. Jev responde quase instantaneamente: a probabilidade de haver PII é de 98%. Então, dá para ver nessa demonstração que Jev é muito útil para tarefas simples de classificação. Há muitas tarefas de classificação ou de tomada de decisão que atualmente pedimos aos agents para fazer com LLMs, mas que poderiam ser mais eficientes em termos de velocidade e custo. Certo, vamos falar um pouco mais sobre os tipos de perguntas que Jev pode ajudar a responder.

04:15 Há três tipos de perguntas, e vamos analisá-los usando este exemplo. O estado diz: “Olá, estou tentando conectar minha conta do Stripe há três dias, mas continua falhando. Estou perdendo vendas. Por favor, me ajudem o quanto antes.” O tipo um é uma escolha: múltipla escolha, selecionar uma opção. Por exemplo, qual equipe deve cuidar disso? A pontuação de billing é 0,84, com confiança de 0,596. O segundo tipo de pergunta é uma pontuação, em uma escala: quão frustrado o cliente

04:48 parece estar, de calmo a frustrado e a muito irritado? A pontuação aqui é 1,035. Então, o cliente parece frustrado, mas não muito irritado. O terceiro tipo de pergunta é booleana. A resposta é do tipo booleano: sim ou não. A mensagem transmite urgência ou sensibilidade ao tempo? A resposta é 0,999. Isso está em uma escala de 0 a 1. Portanto, neste caso, a probabilidade de urgência é certamente alta. Outra coisa a observar: você pode enviar um único estado com muitas perguntas para Jev responder em paralelo. Então Jev

05:22 é muito eficiente quando recebe muitas perguntas de uma vez. Isso contrasta novamente com os LLMs, que fazem mais raciocínio sequencial em vez de processamento paralelo. Certo, como você pode usar Jev na LangChain? Acabamos de lançar uma integração entre LangChain e TypeSafe. Com essa integração, você pode importar este classificador da TypeSafe. Primeiro, será necessário obter uma chave de API da TypeSafe; depois, você pode usar o classificador para chamar Jev com um estado e perguntas. A resposta contém as respostas para cada pergunta enviada.

06:00 Vamos ver alguns casos de uso especialmente bons para Jev. O primeiro é o roteamento de modelos. Se você tem um agent que realiza tanto tarefas simples quanto complexas, provavelmente não vai querer usar o modelo mais poderoso para tudo o que ele faz. Um exemplo que temos explorado recentemente na LangChain é que queremos que nossos agents internos de programação alternem entre modelos rápidos e baratos e modelos mais caros e poderosos, dependendo da complexidade de uma pergunta ou tarefa de programação.

06:32 Por isso, Jev é ótimo para essa etapa de roteamento de modelos. Você pode avaliar um determinado prompt de acordo com critérios específicos para ajudar a decidir se deve usar um modelo rápido ou um mais poderoso. E Jev decide quase instantaneamente. Outro caso interessante é o que chamamos de modo automático. Na LangChain, já oferecemos isso como um middleware de modo automático pronto para uso. A ideia é pedir a Jev que analise se determinadas chamadas de ferramentas são arriscadas e, então, bloqueá-las durante a execução. A título de exemplo, recentemente desativei o modo automático

07:04 no meu agent de programação, porque a etapa de classificação que determinava se uma chamada de ferramenta era arriscada era lenta demais para que o agent de programação parecesse produtivo. Mas agora voltei a ativá-lo, porque Jev consegue tomar essas decisões muito rapidamente. Um exemplo rápido: se fosse emitida uma chamada de ferramenta para apagar um banco de dados ou arquivos importantes, Jev certamente a classificaria como arriscada e bloquearia essa chamada. Certo, o terceiro caso interessante, talvez aquele que mais me empolgue, é usar Jev como avaliador em evals online.

07:36 A ideia é que, muitas vezes, você quer que algum modelo ajude a identificar se o seu agent fez um bom trabalho em determinada tarefa. Mas, ao executar evals em grande escala, não é muito razoável ter supervisão humana para cada trace; por outro lado, muitas vezes você precisa de algo além de avaliadores baseados apenas em estilo de código para decidir se o agent está fazendo um bom trabalho. Jev é muito bom nisso. Você fornece a entrada de uma determinada avaliação: a pergunta inicial e, em seguida, a resposta do agent.

08:07 Você também fornece uma rubrica, ou seja, critérios de avaliação, como: a resposta está correta? Corresponde à referência? Está fundamentada? Há uma fonte citada? Então Jev pode pontuar a resposta de acordo com esses diferentes critérios da rubrica. Isso é uma evolução das evals online com LLM as a judge, que atualmente são certamente muito úteis, mas também muito caras. Acabamos de escrever um artigo de blog sobre como usar Jev como avaliador, com resultados bem interessantes mostrando que Jev, surpresa, surpresa, é muito mais barato e rápido,

08:39 mas também, curiosamente, muito mais confiável e consistente nos evals do que a alternativa com LLM. Certo, vou deixar vocês com isso. Está na hora de criar algo legal com Jev. Para começar, você pode executar uv pip install langchain-typesafe. Você pode ler a publicação complementar do nosso blog no link aqui. É fácil obter uma chave de API em typesafe.ai. Marque a gente no X, em @LangChainAI. Adoraríamos ver no que vocês estão trabalhando. Obrigado, pessoal.

09:09 [Silêncio]

Transcrição original

[00:00] Hey folks, my name is Sydney. I’m the product manager for the open source team at LangChain. And today I’m super excited to share with you how you can build a harness with Jev, this new model that just came out from TypeSafe AI. So before we dive into what Jev is, why it’s so exciting, I want to do a quick recap of the core agent loop that we’re all used to. So a request comes in. We send that to an LLM. And it’s able to take action by using tools. So it will call a tool, get some results back, process those,

[00:32] and then it can continue in this tool calling loop, or it can decide that it’s done with a given task and return a result. This loop is super powerful, but LLMs are a little bit unpredictable, right? They get text in and then produce text out. And so when LLMs first came out, we decided that we needed ways to impose a little bit more structure on them so that they could work well in code-driven applications that inherently depend on structured types, not just the raw text.

[01:02] So enter tool calling and structured outputs. Again, tool calling, a model can send a structured request. In this case, a get order request with a given ID, and then the tool returns a result with structured data. The other primitive we added, again, is structured outputs. The idea here is that you can bind an output type to your model, and so it produces a final result that adheres to a given JSON schema rather than just raw text. And so these two primitives made it a lot easier to take advantage of this really powerful loop

[01:34] in code-based applications. Okay, so now to the exciting piece, what is Jev? There’s so much buzz right now on Twitter about this new model, why is everyone talking about it? So Jev is what we call a System 1 model from this new startup that just emerged called TypeSafe AI. So according to their docs, System 1 models are a class of AI models built to make fast structured decisions that software can use directly. A System 1 model evaluates a state and questions

[02:04] and returns typed answers and probabilities. You can see an example of state and questions and then typed answers here on the slide. The interesting thing here is that Jev actually doesn’t take text in and then generate text out like the traditional LLMs that we’re used to. Part of the reason why Jev is so popular right now is it can be 20 to 200 times faster and 40 to 400 times cheaper on classification style tasks compared to an LLM.

[02:35] So Jev is not a drop-in substitute for an LLM, but it can do specialized tasks that we currently ask LLMs to do much faster and much cheaper. In case you’re curious where this System 1 phrase is coming from, it actually comes from psychologist Daniel Kahneman’s book, Thinking Fast and Slow. And in this book, he described two ways that minds think. Fast and cheap, System 1 intuition, versus slow and expensive, System 2 reasoning. And so TypeSafe AI borrowed this sentiment for its new model called Jev, calling it a System

[03:09] 1 model. That’s fast and cheap, returning almost instant typed decisions instead of generating text, which is in deliberate contrast to standard LLMs, which behave more like System 2, slower and pricier, but adhering to more of this step-by-step reasoning over open-ended problems. All right, I’m going to show a quick demo here on how an LLM answers a question versus how Jev answers. So the question is, is there PII in this text? And so an LLM produces this text result,

[03:43] and then also structured output takes about five seconds. Jev almost immediately, chance that there’s PII is 98%. And so you can see kind of from this demo for simple classification style tasks, Jev is super useful. And there are a lot of classification or kind of decision style tasks that we currently ask agents to do with LLMs that could be more optimal in terms of speed and cost. All right, so let’s talk a little bit more about the types of questions that Jev can help answer.

[04:15] There’s three types of questions, and we’ll look at them through the lens of this example. So the state says, “Hi, I’ve been trying to connect my Stripe account for three days, and it keeps failing. I’m losing sales. Please help ASAP.” So question type one is a choice. Multiple choice, pick one option. So for example, which team should handle this? The score shows 0.84 for billing with a confidence of 0.596. The second question type is a score. So somewhere on a scale, you know, how frustrated the customer

[04:48] appears from calm to frustrated to very angry. And the score here is 1.035. So the customer seems frustrated but not very angry. And then the third question type is a boolean. So this is a boolean type answer, a yes or no. So the message conveys urgency or time sensitivity returns 0.999. This is on a scale of 0 to 1. So certainly a high urgency probability for this case. One other thing to note, you can actually send a single state with many questions that Jev answers in parallel. So Jev

[05:22] is actually very efficient with many questions at a time. This is again in contrast to LLMs, which do more sequential reasoning rather than parallel processing. All right, so how can you use Jev in LangChain? We just released a LangChain TypeSafe integration. So from LangChain TypeSafe, you can import this TypeSafe classifier. First, you’ll need to acquire a TypeSafe API key, and then you can use this classifier to invoke Jev with a state and questions. And then the response has answers to each question that you send it.

[06:00] Let’s walk through just a couple of use cases that are super great for Jev. The first is model routing. So if you have an agent that does both simple and complex work, you probably don’t want to use the most powerful model for everything that the agent does. An example of this that we’ve been exploring at LangChain recently is that we actually want our internal coding agents to switch between fast and cheap models and more expensive and powerful models depending on the complexity of a given question or coding task.

[06:32] And so Jev is great for this model routing step. You can assess a given prompt against given criteria to help decide whether or not you should use a fast or more powerful model. And Jev decides almost instantaneously. Another interesting case is what we call auto mode. So from LangChain, we already offer this as a pre-built auto mode middleware. And the idea here is that you can ask Jev to analyze whether or not given tool calls are risky, and then you can block those at runtime. Anecdotally, I actually turned off auto mode

[07:04] in my coding agent recently, because the classification step of whether a given tool call was risky was too slow for my coding agent to feel productive. But it’s back on now that Jev can make these decisions so quickly. So a quick example here is like if a tool call was issued that would delete a database or delete important files, Jev would certainly classify that as risky and then block that tool call. All right, the third interesting case here, maybe the one I’m most excited about is using Jev as a judge for online evals.

[07:36] So the idea with this is that you often want some sort of model to help you identify whether or not your agent has done a good job with a given task. But when you’re running evals at scale, it’s not super reasonable to have human oversight over every single trace, but you often need more than just kind of code style evaluators to decide whether or not your agent is doing a good job. And Jev is really great at this. So you have your input for a given eval, so the initial question and then the answer from the agent.

[08:07] And then you also have a rubric that you provide. So grading criteria, like, is this answer correct? Does it match the reference? Is it grounded? Was there a cited source? And then Jev can score the given answer along these different rubric criteria. This is kind of an evolution of LLM-as-a-judge online evals, which are currently certainly very useful, but also very expensive. We just wrote a blog on how to use Jev as a judge, and it has some really interesting results about Jev being, surprise surprise, much cheaper and much faster,

[08:39] but also interestingly, much more reliable and consistent across evals than the LLM alternative. All right, so I’ll leave you with this. It’s time to go build something cool with Jev. You can get started with uv pip install langchain-typesafe. You can read our accompanying blog post at the link here. Easily get an API key from typesafe.ai, tag us at @LangChainAI on X. We’d love to see what you’re working on. Thanks, folks.

[09:09] [ Silence ]