Ollaya: como executar modelos de decisão localmente como alternativa open source ao Jev

Ferramentas de IA — Geral
, , , , , ,
1

Ollaya é uma ferramenta de código aberto que executa modelos de decisão localmente, atrás de uma API compatível com Jev da TypeSafe e sem pagar por chamada. Apesar do nome, não é Ollama: é um projeto independente, sem afiliação com Ollama nem com TypeSafe, e o código escrito para Jev pode apontar para sua própria máquina mudando três variáveis de ambiente.

Status em 26 de setembro de 2026: a versão atual é v0.6.0, publicada em 25 de setembro. O site do projeto ainda identifica Ollaya como Beta, e a lista de modelos muda a cada release.

O projeto toma a experiência de desenvolvimento de Ollama quase comando por comando: um único binário, modelos que você baixa com pull e executa com run pelo nome, Modelfiles para personalizá-los e uma API REST local. A diferença está no que executa: modelos que respondem perguntas tipadas com probabilidades calibradas em vez de gerar texto. Em inglês, a categoria é conhecida como decision models, e Ollaya se apresenta como uma alternativa de código aberto a Jev para local inference.

Este artigo se baseia no código, nas notas de versão e na documentação publicados por Ollaya. Nós não o executamos nem reproduzimos seus benchmarks de forma independente.

O que é um modelo de decisão?

Um modelo de decisão lê um estado e retorna uma resposta tipada com probabilidades calibradas para cada pergunta, em uma única passagem do modelo. O estado pode ser uma mensagem, um e-mail, um ticket ou qualquer objeto JSON. As perguntas são de três tipos: choice, score e noul. O modelo nunca gera texto.

Esse resultado é fácil de converter em ação: derivar o ticket, bloquear a mensagem ou escalar quando uma probabilidade ultrapassa um limite.

O modelo fechado Jev da TypeSafe criou essa categoria. Explicamos como funciona e quanto custa em Jev da TypeSafe: como funciona a IA que toma decisões sem gerar texto. Esse artigo terminava com uma limitação: os pesos do Jev não são públicos, então você não pode hospedá-lo por conta própria. A resposta de Ollaya é servir modelos de decisão abertos atrás da mesma forma de API.

Este é o primeiro exemplo do README:

ollaya run laya --preset triage "I was charged twice for my subscription this month and want a refund."


intent            refund       ████████████████ 1.00
is_urgent         no           ██████████████░░ 0.88
frustration       1.76 / 3     ██████░░░░░░░░░░ 0.36
refund_requested  yes          ██████████████░░ 0.90
churn_risk        no           ██████████░░░░░░ 0.61

Qual é a diferença entre Ollaya, Ollama e Jev?

Ollaya aplica o fluxo de trabalho de Ollama a modelos de decisão em vez de LLM generativos, e expõe o formato de API de Jev com modelos abertos por baixo.

Contra Ollama:

  • Os comandos lhe serão familiares: serve, run, pull, list, ps, show, rm, cp, stop e create.
  • Se o daemon não estiver em execução, a CLI o inicia.
  • A porta padrão é 11435, uma a mais que a 11434 de Ollama, então ambos podem funcionar ao mesmo tempo.

Se o que você procura é executar LLM generativos em sua máquina, Ollama continua sendo a ferramenta; comparamos com suas alternativas em LM Studio, Ollama ou llama.cpp: o que realmente funciona em sua máquina.

Contra Jev:

  • Os endpoints /v1/systemone, /v1/decisions e /v1/models são idênticos aos da TypeSafe a nível de protocolo.
  • Os modelos são outros, e sua qualidade também varia segundo a tarefa (vemos isto abaixo).

Quais modelos você pode executar com Ollaya?

Em 26 de setembro de 2026 (v0.6.0), o README lista estes modelos. Cada um mantém sua própria licença:

Modelo O que é Licença
laya Roteador: envia o inglês para laya:en e outros idiomas para laya:multilingual Apache-2.0
laya:en Modelo de decisão em inglês (ModernBERT-large); o mais rápido Apache-2.0
laya:multilingual Mais de 100 idiomas (mmBERT-base) Apache-2.0
laya:typed-decisions Ajustado sobre fluxos de decisões tipadas Apache-2.0
decider, decider:0.8b Decodificadores Qwen3.5 de Mapika; os mais precisos e os mais lentos Apache-2.0
kev LoRA e pointer head de Jared Palmer sobre Qwen3.5-0.8B (novo em v0.6.0) Apache-2.0
von Von 1.1 de Victor Hugo Panisa sobre ModernBERT-large, contexto de 8k tokens (novo em v0.6.0) Apache-2.0
qwen3guard Guarda de segurança de Qwen (safe / controversial / unsafe, 119 idiomas; novo em v0.6.0) Apache-2.0
nli:modernbert-large Classificador NLI zero-shot de Moritz Laurer Apache-2.0
nli:deberta-v3-large Classificador NLI zero-shot de Moritz Laurer MIT
gliclass Classificador zero-shot de Knowledgator que segue instruções Apache-2.0

Dois detalhes importam se você trabalha em português:

  • O roteador cobre o texto que não está em inglês. laya envia qualquer texto em outro idioma para laya:multilingual. É relevante porque TypeSafe indica que Jev oferece atualmente sua maior precisão em inglês.
  • Ollaya nunca rehospeda pesos. Apenas publica pequenos grafos ONNX (uns 3 MB cada um) que leem os pesos originais do repositório do Hugging Face de cada autor, fixados a um commit e verificados com sha256.

Como se instala Ollaya?

Linux e macOS (Apple silicon):

curl -fsSL https://ollaya.dev/install.sh | sh

No Linux você precisa de x86-64 ou ARM64 com glibc 2.38 ou superior: Ubuntu 24.04, Debian 13, Fedora 39, RHEL 10 ou posteriores. Se houver uma GPU NVIDIA com driver R580 ou superior, o instalador adiciona o runtime de CUDA.

Windows (x64, PowerShell):

irm https://ollaya.dev/install.ps1 | iex

Docker:

docker run -d --gpus=all -p 11435:11435 ghcr.io/ollaya-dev/ollaya:cuda

Use ghcr.io/ollaya-dev/ollaya se você tiver apenas CPU. A imagem do Docker também é o caminho para distribuições Linux mais antigas.

App de desktop: existe para macOS, Windows e Linux em ollaya.dev/download. Inicia e interrompe o servidor, baixa modelos e os executa em uma única janela. No macOS fica na barra de menus, que v0.6.0 redesenhou.

O Ollaya funciona no Windows? Você precisa de GPU?

Sim, mas no Windows funciona apenas com CPU. Para usar uma GPU NVIDIA no Windows você precisa do WSL 2 com o instalador do Linux.

A GPU não é obrigatória em nenhuma plataforma: Ollaya funciona com CPU em todas, e no Linux x86-64 usa uma GPU NVIDIA quando a encontra. Os números de velocidade que o projeto publica foram medidos em GPU (veja abaixo), então espere latências maiores em CPU.

Como usar Ollaya com Claude Code através do MCP?

Você registra seu servidor MCP (MCP server) no Claude Code com um único comando:

claude mcp add ollaya -- ollaya mcp

ollaya mcp fala MCP por stdio e inicia o servidor local se não estiver em execução. Expõe quatro ferramentas:

  • decide responde perguntas tipadas sobre um estado. Recebe state, questions ou preset, e model (padrão: laya).
  • list_models mostra o que você tem instalado.
  • show_model retorna os detalhes de um modelo, incluindo sua licença.
  • pull_model baixa um modelo. decide também o baixa no primeiro uso.

E no Claude Desktop, Cursor ou VS Code?

No Claude Desktop, adicione este bloco a claude_desktop_config.json (Settings → Developer → Edit Config):

{
  "mcpServers": {
    "ollaya": { "command": "ollaya", "args": ["mcp"] }
  }
}

Se Claude Desktop não encontrar ollaya, use o caminho completo, por exemplo /usr/local/bin/ollaya ou ~/.local/bin/ollaya.

No Cursor e VS Code usa-se o mesmo comando, ollaya mcp, em .cursor/mcp.json ou .vscode/mcp.json. VS Code precisa de "type": "stdio".

Há uma skill para agentes?

Sim. Ollaya inclui uma skill que ensina ao Claude Code quando uma decisão tipada é melhor que raciocinar em texto e como agir de acordo com as probabilidades:

npx skills add ollaya-dev/ollaya --skill ollaya-decisions

Adicione -g para instalá-la em todos os seus projetos.

O Ollaya pode impedir que um agente execute um comando perigoso?

Para isso existe o novo --preset agent da v0.6.0. Recebe a solicitação do usuário (request) e o comando proposto (command), e responde quatro perguntas:

  • action: executar, perguntar ou bloquear (run, ask ou block)
  • on_task: se a solicitação realmente precisa desse comando
  • risk: quanto dano poderia causar
  • destructive: se apaga ou sobrescreve trabalho

As notas de versão usam este exemplo:

ollaya run decider --preset agent '{"request": "Fix the typo in README.md", "command": "git push --force origin main"}'

De acordo com as notas de versão, decider:2b bloqueia esse comando em cerca de 180 ms em uma RTX 4090:

Pergunta Resposta Probabilidade
action block 0,53
on_task fora da tarefa 0,75
destructive sim 0,90

A mesma solicitação com um sed que corrige o erro obtém run com 0,90. O preset também funciona a partir do servidor MCP (preset: "agent") e a partir do app de desktop.

Tenha em mente que uma probabilidade de bloqueio de 0,53 é um sinal, não uma garantia. Mantenha as verificações de permissões rigorosas em código determinístico.

Como migrar seu código de Jev para Ollaya?

Apontar o SDK oficial do Python da TypeSafe (0.7.1) para localhost com três variáveis de ambiente:

export TYPESAFE_BASE_URL=http://localhost:11435
export TYPESAFE_API_KEY=local           # o SDK precisa de uma chave não vazia; qualquer valor funciona
export TYPESAFE_DEFAULT_MODEL=laya      # caso contrário, o SDK envia "jev-latest"

Três diferenças a ter em mente:

  • Os nomes do modelo mudam. Você precisa de laya ou laya:en, não jev-latest.
  • Dê nomes descritivos às suas perguntas. Quando uma pergunta não tem instructions, o modelo lê seu id em seu lugar, assim is_urgent funciona melhor que q1.
  • Limites: no máximo 256 perguntas por requisição, entre 2 e 255 opções e entre 2 e 10 níveis de pontuação. Cada modelo tem além disso um orçamento de opções: cerca de 125 para laya:en e 250 para laya:multilingual.

O Ollaya é tão bom quanto o Jev?

Depende da tarefa, e a própria documentação do Ollaya deixa isso claro. Todos os números a seguir são publicados pelo projeto; não foram verificados de forma independente.

Onde vai à frente:

  • laya:typed-decisions obtém 0,766 no benchmark typed-decisions, contra 0,727 que TypeSafe publicou para o Jev 1.13.
  • O erro de calibração do Laya após ajustar a temperatura é 0,081, contra 0,246 do Jev.

Onde fica claramente para trás:

  • Os checkpoints base do Laya estão perto do acaso em zero-shot sobre typed-decisions (0,362).
  • Perguntas de múltipla escolha com muitas opções (mais de cerca de 20) são fracas. No Banking77, o Laya obtém 0,425 contra 0,870 do Jev.

Velocidade: medida de ponta a ponta em uma RTX 4090, o projeto informa essas medianas:

Modelo Cinco perguntas
laya:multilingual 8 ms
laya:en 10 ms
von 23 ms
kev 185 ms

Fidelidade: as exportações ONNX escolheram a mesma resposta que a referência de PyTorch em fp32 em 100% de 2.383 perguntas por checkpoint do Laya.

Siga o conselho da própria documentação: meça com seus dados antes de mover tráfego de produção. Para os limites dos quais você dependa, reajuste as temperaturas com seus dados rotulados e incorpore-os em um Modelfile.

O Ollaya é grátis? Seus dados saem de sua máquina?

Ollaya é open source sob licença Apache-2.0. Executá-lo não tem custo por chamada; o custo é seu próprio processamento.

Os modelos têm suas próprias licenças, como mostra a tabela anterior: todos são Apache-2.0 exceto nli:deberta-v3-large, que é MIT. Se você construir um produto sobre um deles, revise a licença desse modelo em vez de presumir que a do projeto o cobre.

O servidor escuta por padrão em 127.0.0.1:11435. A rede é usada apenas para baixar modelos, e a documentação indica que os estados e as perguntas nunca são registrados. É uma diferença relevante em relação a qualquer API de decisão hospedada quando o estado contém tickets ou e-mails de clientes.

Para quem faz sentido o Ollaya hoje?

Três perfis tiram mais proveito dele hoje:

  • Equipes que já prototipam com o Jev e querem uma alternativa local ou testar sem chamadas à API.
  • Quem constrói agentes no Claude Code ou Cursor e quer um filtro rápido antes que comandos destrutivos sejam executados.
  • Equipes cujo trabalho não está em inglês, graças ao roteador multilíngue.

Está em Beta, a lista de modelos cresce a cada semana e em alguns tipos de tarefa os modelos abertos ficam claramente para trás do Jev. Como forma instalável de colocar uma etapa de decisão de menos de 100 ms na frente de um agente, merece uma tarde de testes.