O que é o Laya e por que ele decide sem gerar texto?

Fala aí, beleza? Tem um modelo novo que não escreve UMA palavra sequer e mesmo assim toma decisão

O nome dele é Laya, e é uma família de modelos de decisão open source publicada pela Convai Innovations sob licença Apache 2.0, lançada em 18 de setembro de 2026

A ideia central é simples de falar e estranha de digerir: em vez de pedir pro modelo escrever "esse ticket é urgente", tu manda o estado do programa junto com um dicionário de perguntas tipadas, e ele devolve uma distribuição de probabilidade tipada em um único forward pass

Sem token a token, sem parser de JSON torto, sem rezar pro modelo respeitar o formato 😀

Por que o Laya não gera texto (e o que ele faz no lugar)

Um LLM comum é autorregressivo: ele escolhe o próximo token, depois o próximo, depois o próximo, até fechar a resposta

Se você conhece aquele efeito de digitação na tela do ChatGPT, é literalmente isso acontecendo: cada pedacinho da resposta é uma passagem pelo modelo

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Pra escrever, isso é ótimo

Pra decidir, é desperdício puro: tu paga o custo de gerar linguagem só pra extrair uma classificação no fim

O Laya corta esse caminho

Ele usa encoder bidirecional (o modelo enxerga a entrada inteira de uma vez, não da esquerda pra direita) e faz pontuação não autorregressiva

A entrada é o estado do programa: pode ser texto solto, um e-mail, um ticket de suporte ou um documento JSON

Junto vai o dicionário de perguntas tipadas, e todas as perguntas desse dicionário são resolvidas em uma única passagem

A saída não é string

É distribuição de probabilidade tipada, já no formato que o teu código espera receber

E o número que o projeto reporta em GPU Tesla T4, sem amarrar a um checkpoint específico: cerca de 33 ms pra uma pergunta, e 7,2 ms por pergunta quando tu manda em lote

Por checkpoint a mediana muda um pouco: 32,8 ms no multilíngue e cerca de 39,5 ms no checkpoint em inglês, os dois medidos na mesma T4

As três primitivas: choice, score e noul

O Laya trabalha com três tipos de pergunta, e entender esses três é entender o modelo inteiro

choice: escolhe uma opção entre as que você definiu

Tu dá as opções, ele devolve qual delas encaixa no estado, com distribuição e confiança

É a primitiva de roteamento: "esse ticket vai pra billing, suporte técnico ou cancelamento?"

score: posiciona o estado numa rubrica ordinal

Aqui a resposta não é categoria solta, é nível: 0, 1, 2 e por aí vai

Serve pra severidade, prioridade, nível de risco, qualquer coisa que tenha ordem embutida

noul: pergunta booleana com probabilidade honesta

A noul devolve o P(true) calibrado, e o P(false) é simplesmente 1 menos o P(true)

É o "sim ou não" com número junto: não é só "é spam", é "é spam com tal probabilidade"

E se liga num detalhe que diz muito sobre o modelo

No checkpoint ajustado, a acurácia por tipo de pergunta fica assim: noul 0,857, choice 0,733 e score 0,723

Ou seja: o booleano é onde ele brilha mais, e quanto mais aberta a pergunta, mais ele sofre

Faz sentido, né? Pergunta binária tem menos jeito de errar

Arquitetura e treino: ModernBERT, cabeça de decisão e RLCD

A arquitetura junta duas peças

A primeira é o backbone ModernBERT-large, 395M de parâmetros só nele, bidirecional, com fine-tune completo (não é encoder congelado com uma camadinha em cima)

A segunda é uma cabeça de decisão de 2 camadas transformer, essa treinada do zero

Somando as duas peças, o checkpoint laya fecha em 421M: aquele 395M é do backbone sozinho, não do modelo inteiro

Mas a parte mais interessante é o treino

O Laya é treinado com RLCD: aprendizado por reforço contra regras de pontuação estritamente próprias

E o que significa isso? Regra de pontuação estritamente própria é um jeito de premiar previsão probabilística onde a única estratégia que maximiza a recompensa é reportar a probabilidade que você realmente acredita

Chutar confiança lá em cima só pra parecer seguro te machuca na conta

É um desenho de treino que empurra o modelo pra honestidade numérica, não pra confiança performática

Pelo menos é essa a intenção do desenho

Os três checkpoints do Laya e o que muda entre eles

A família tem três checkpoints abertos, com backbones e janelas diferentes

Repara na inversão: o checkpoint menor, multilíngue, tem o dobro de janela de contexto E é mais rápido

Pra quem escreve em português, esse é o caminho óbvio de qualquer forma

E contexto aqui é só o tamanho da entrada que cabe na passagem, não é aquela conversa de janela gigante de LLM que o teste da agulha no palheiro tenta medir

O terceiro, o laya-typed-decisions, é o caso à parte: ele foi ajustado no split de treino do benchmark typed-decisions, e é dele que saem os números bonitos de acurácia

Laya x Jev: latência e acurácia lado a lado

A comparação que o próprio model card faz é com o Jev, da TypeSafe AI

O Jev é um modelo System One também treinado com RLCD, mas proprietário e hospedado, acessível por API HTTP, e estava em early access com waitlist em 15 de setembro de 2026

Repara que os dois números do lado do Laya saem de checkpoints diferentes: a latência é do multilíngue e a acurácia é do checkpoint ajustado no benchmark

A diferença de latência é de cerca de 7,8x, e o projeto atribui isso diretamente à pontuação não autorregressiva

O benchmark typed-decisions tem 2.000 decisões, e tem um detalhe saboroso ali: o teto de auto concordância do teacher é 0,735

Ou seja, o checkpoint ajustado com 0,766 fica acima do modelo que gerou os rótulos concordando consigo mesmo

Massa? Muito

Só que tem um porém grande nessa festa toda…

O que esperar na prática: limites declarados pelo projeto

Os checkpoints base, em zero-shot, ficam perto do acaso nesse benchmark

laya marca 0,362 e laya-multilingual marca 0,352, contra baseline aleatório de 0,318 e baseline de classe majoritária de 0,461

Leu direito? A classe majoritária, aquele chute burro de sempre responder a resposta mais comum, bate os dois checkpoints base

E isso não é crítica de blogueiro chato: é o que os próprios autores declaram no model card

O posicionamento oficial é claro, o Laya é base rápida pra especializar, e o 0,766 vem do fine-tuning no split de treino do benchmark

Tem mais um ponto: lembra do RLCD e da honestidade numérica? Na prática o modelo sai excessivamente confiante

Reajustando uma temperatura por (tipo de pergunta, número de opções) em dados held-out, o ECE médio cai de 0,466 para 0,081 no laya e de 0,314 para 0,106 no laya-multilingual

ECE é erro de calibração: quanto menor, mais a probabilidade que ele te dá corresponde à frequência real de acerto

Sair de 0,466 pra 0,081 não é ajuste fino, é diferença entre número confiável e número decorativo

Tome cuidado! Se tu vai usar o P(true) pra decidir se escala pro humano, recalibrar não é opcional

E a última limitação declarada: perguntas do tipo choice degradam acima de 20 opções

Então nada de mandar taxonomia de 80 categorias e esperar milagre

Onde o Laya se encaixa na sua stack de IA

As cargas alvo que a Convai indica são bem específicas: processamento de notas fiscais, roteamento de tickets, moderação, guardrails e observabilidade de traces de agente

Repara no padrão

Tudo isso é a camada de classificação ao redor da stack de LLM, não o LLM

É aquele monte de decisãozinha que hoje você resolve chamando um modelo caro pra responder "isso é urgente?" e depois brigando pra extrair um booleano de dentro de um parágrafo educado

Pensa num agente rodando: cada trace, cada saída, cada input precisa passar por uma peneira antes de virar ação

Se cada peneira dessas custa uma chamada de LLM, a conta e a latência explodem

O argumento do Laya é ocupar exatamente essa camada

O LLM continua fazendo o que LLM faz bem, escrever, raciocinar, planejar

O Laya fica na borda, respondendo rápido as perguntas fechadas

Como começar: instalação e o Router

O pacote oficial é publicado pela Convai no PyPI (autor nandakishor), sob Apache-2.0

1. Confere o Python. O pacote exige Python 3.8 ou superior. O erro comum aqui é rodar num ambiente velho de projeto legado e tomar erro de instalação que não tem nada a ver com o modelo

2. Instala o pacote.

pip install laya

As dependências são torch, transformers, safetensors, huggingface-hub e numpy

3. Roda a primeira vez com paciência. Os pesos são baixados do Hugging Face Hub no primeiro uso, então a primeira execução não representa a latência real. O erro comum é medir performance nessa rodada e sair falando que o modelo é lento

4. Usa o Router como ponto de entrada. É a classe recomendada pela biblioteca

from laya import Router

router = Router()
result = router.predict(state, questions)

O Router detecta idioma e escrita e despacha pro checkpoint adequado sozinho

E cada resultado vem com metadados de roteamento: qual modelo foi usado, qual repositório e o motivo da escolha

Isso é ótimo pra debug, porque quando a resposta vier esquisita tu consegue ver se ele despachou pro checkpoint errado

5. Não espere milagre zero-shot. Esse é O erro comum do Laya, e vale repetir: os checkpoints base ficam perto do acaso sem fine-tuning, e a probabilidade que sai da caixa vem excessivamente confiante. Especializar no teu domínio e recalibrar temperatura em dados held-out não é bônus, é o caminho pro modelo fazer sentido

Runtimes alternativos: Node.js, Apple Silicon e GGUF

Como os pesos são abertos, já apareceu ecossistema em volta

Esses aqui são mantidos pela comunidade, fora do pacote oficial, então trata como tal:

• receptron/laya: roda o Laya a partir de Node.js/TypeScript via ONNX Runtime
• mizorewww/laya-mlx: runtime MLX nativo pra Apple Silicon
• mys/laya-GGUF: conversões GGUF hospedadas no Hugging Face

Se a tua stack é TypeScript inteira, o caminho do ONNX evita ter que subir um serviço Python só pra classificar ticket

Conclusão

O Laya não é um LLM pequeno, e tratar ele como LLM pequeno é o jeito mais rápido de se decepcionar

Ele é motor de decisão: recebe estado, recebe perguntas tipadas, devolve probabilidade em uma passagem só

O valor real aparece depois da especialização, e os próprios autores falam isso na cara dura

Próximo passo, se te interessou: dá uma olhada no repositório oficial em NandhaKishorM/laya, Apache 2.0

E faz o exercício mais útil de todos: abre a tua stack e lista quais decisões hoje queimam uma chamada de LLM caro pra responder algo que cabia numa choice, numa score ou numa noul

Aposto que a lista é maior do que tu imagina 😛

Até o próximo post!