Ornith-1.0 - modelo open source autoaprimorável para codificação agentic

 (github.com/deepreinforce-ai)
2 pontos por GN⁺ 4 시간 전 | 1 comentários | Compartilhar no WhatsApp
  • Ornith-1.0 é um modelo open source autoaprimorável para codificação agentic, com configurações 9B Dense, 31B Dense, 35B MoE e 397B MoE, pós-treinadas sobre Gemma 4 e Qwen 3.5
  • O framework de treinamento usa aprendizado por reforço para aprender a gerar não só solution rollouts, mas também o scaffold que orienta o rollout, otimizando em conjunto o scaffold e a solução resultante
  • Segundo o README, o Ornith-1.0 alcança desempenho de ponta em benchmarks de código como Terminal-Bench 2.1, SWE-Bench, NL2Repo e OpenClaw em comparação com modelos open source de tamanho semelhante
  • Todos os checkpoints expõem uma interface compatível com OpenAI e suportam janela de contexto de 256K tokens, podendo ser executados com vLLM, SGLang, Hugging Face Transformers, llama.cpp e Ollama
  • Tem licença MIT, pode ser acessado globalmente sem restrições regionais e separa blocos de raciocínio e chamadas de ferramentas por meio de reasoning_content e tool_calls, permitindo integração com frameworks de agentes e CLIs de código

Visão geral do modelo e método de treinamento

  • Ornith-1.0 é uma família de modelos open source autoaprimoráveis para codificação agentic
  • Os tamanhos disponíveis são 9B Dense, 31B Dense, 35B MoE e 397B MoE, pós-treinados sobre Gemma 4 e Qwen 3.5
  • O framework de treinamento autoaprimorável usa aprendizado por reforço
    • O modelo é treinado para gerar não apenas solution rollouts, mas também o scaffold que conduz o rollout
    • O scaffold e a solução resultante são otimizados em conjunto para encontrar trajetórias de busca melhores e soluções de maior qualidade
  • A licença é MIT, com acesso global e sem restrições regionais

Resultados de benchmark

  • Cada modelo foi comparado com modelos de referência equivalentes em tamanho, e os três modelos usaram o mesmo harness e as mesmas configurações de decodificação

  • Ornith-1.0-9B

    • No Terminal-Bench 2.1, registrou 43.1 na referência Terminus-2 e 40.6 na referência Claude Code
    • Registrou 69.4 no SWE-bench Verified, 42.9 no SWE-bench Pro e 52 no SWE-bench Multilingual
    • Registrou 27.2 no NL2Repo e média de 63.1 no Claw-eval
    • No SWE Atlas, registrou 17.9 em QnA, 16.6 em RF e 15.3 em TW

  • Ornith-1.0-35B

    • No Terminal-Bench 2.1, registrou 64.2 na referência Terminus-2 e 62.8 na referência Claude Code
    • Registrou 75.6 no SWE-bench Verified, 50.4 no SWE-bench Pro e 69.3 no SWE-bench Multilingual
    • Registrou 34.6 no NL2Repo e média de 69.8 no Claw-eval
    • No SWE Atlas, registrou 37.1 em QnA, 29.7 em RF e 27.8 em TW

  • Ornith-1.0-397B

    • No Terminal-Bench 2.1, registrou 77.5 na referência Terminus-2 e 78.2 na referência Claude Code
    • Registrou 82.4 no SWE-bench Verified, 62.2 no SWE-bench Pro e 78.9 no SWE-bench Multilingual
    • Registrou 48.2 no NL2Repo e média de 77.1 no Claw-eval
    • No SWE Atlas, registrou 41.2 em QnA, 42.6 em RF e 39.1 em TW

Configuração de avaliação

  • A avaliação Terminal-Bench 2.1 Terminus-2 usa o framework Harbor/Terminus-2, parser=json, temperature=1.0, top_p=1.0 e janela de contexto de 128K
    • Cada execução usa timeout de 4 horas, 32 núcleos de CPU, 48GB de RAM e representa a média de 5 execuções
    • O template de chat do Qwen foi ajustado para consistência entre treinamento e inferência, e o Harbor foi modificado para se alinhar à chave reasoning_content do vLLM
  • A avaliação Terminal-Bench 2.1 Claude Code usa Claude Code 2.1.126, parser=json, temperature=1.0, top_p=1.0, max_new_tokens=131072 e representa a média de 5 execuções
  • SWE-bench Verified / Pro / Multilingual usam o harness OpenHands, temperature=1.0, top_p=0.95 e janela de contexto de 256K
  • SWE Atlas QnA / RF / TW usam o harness mini-SWE-agent, temperature=1.0, top_p=0.95, janela de contexto de 128K e média de 5 execuções
  • NL2Repo usa temperature=1.0, top_p=1.0, contexto de 400K, saída de 48K e filtros anti-hacking
  • ClawEval é um benchmark de código agentic baseado na distribuição de tarefas de usuários reais e usa temperature=0.6 e contexto de 256K

Execução e checkpoints

  • O Ornith-1.0 é um reasoning model e, por padrão, o turno do assistant começa com um bloco <think> … </think> antes de retornar a resposta final
  • A receita de serving ativa o reasoning parser para retornar o chain-of-thought em um campo reasoning_content separado e ativa o tool-call parser para expor blocos <tool_call> como tool_calls no estilo OpenAI
  • As versões mínimas de runtime exigidas são:
    • Transformers ≥ 5.8.1
    • vLLM ≥ 0.19.1
    • SGLang ≥ 0.5.9
  • Os parâmetros de sampling recomendados são temperature=0.6, top_p=0.95, top_k=20
    • Para reproduzir as configurações de benchmark reportadas, use temperature=1.0
  • Todos os checkpoints expõem a mesma interface compatível com OpenAI e suportam uma janela de contexto de 256K, ou seja, 262.144 tokens
    • O Dense 9B cabe em uma única GPU de 80GB
    • Os checkpoints MoE são divididos em nós com múltiplas GPUs via tensor parallelism
  • Checkpoints disponibilizados
    • Ornith-1.0-9B: Dense de cerca de 9B, bf16, para serving em GPU única e fine-tuning
    • Ornith-1.0-9B-GGUF: Dense de cerca de 9B, quantizado em GGUF, para inferência local com llama.cpp / Ollama
    • Ornith-1.0-35B: MoE 35B, bf16, para serving full-precision em múltiplas GPUs
    • Ornith-1.0-35B-FP8: MoE 35B, FP8, para serving com cerca de metade do uso de VRAM em GPUs com suporte a FP8
    • Ornith-1.0-35B-GGUF: MoE 35B, quantizado em GGUF, para inferência local com llama.cpp / Ollama
    • Ornith-1.0-397B: MoE 397B, bf16, para serving full-precision em nós com múltiplas GPUs
    • Ornith-1.0-397B-FP8: MoE 397B, FP8, para serving com eficiência de memória em GPUs com suporte a FP8

API compatível com OpenAI e uso com agentes

  • Quando um servidor vLLM ou SGLang estiver em execução, é possível chamar o endpoint /v1/chat/completions com um cliente compatível com OpenAI
  • O exemplo de servidor local usa base_url="http://localhost:8000/v1";, api_key="EMPTY", model="Ornith-1.0"
  • Na mensagem de resposta, reasoning_content contém o trace de raciocínio em <think>, enquanto content contém a resposta final
  • Ao fornecer ferramentas, o Ornith-1.0 gera chamadas de função bem formadas, e o servidor as interpreta no campo padrão tool_calls
  • SDKs compatíveis com OpenAI em Python, Node.js e curl podem usar o mesmo endpoint

Frameworks compatíveis e CLIs de código

  • O Ornith-1.0 é otimizado para chamadas de ferramentas e recursos de codificação agentic
  • Como oferece endpoint compatível com OpenAI e tool calling, pode ser usado com frameworks de agentes padrão
  • O README inclui exemplos de conexão de ferramentas via servidor MCP e exemplos de chamada de ferramenta da função run_shell
  • Os harnesses e runtimes de agentes mostrados como exemplo são:
    • Hermes Agent: configuração de OPENAI_BASE_URL, OPENAI_API_KEY, MODEL="Ornith-1.0"
    • OpenHands: uso do caminho openai/Ornith-1.0 no LiteLLM e base URL local
    • llama.cpp / Ollama: carregamento dos builds GGUF 9B e 35B para inferência local
    • Unsloth Studio: inferência local ou fine-tuning com FastLanguageModel.from_pretrained
    • OpenClaw: definição do endpoint compatível com OpenAI para o servidor Ornith
  • CLIs de código podem se conectar ao endpoint do Ornith-1.0 definindo OPENAI_BASE_URL e OPENAI_API_KEY
  • O exemplo do OpenCode registra um provider local do Ornith em ~/.config/opencode/opencode.json e usa o modelo Ornith-1.0

Leituras relacionadas

1 comentários

 
GN⁺ 4 시간 전
Opiniões no Hacker News

  • Discussão anterior: https://news.ycombinator.com/item?id=48709744
    https://swelljoe.com/post/will-it-mythos/: “O desempenho é meio ruim; encontrou só um bug que quase todos os modelos encontraram. Isso apesar de ter um desempenho excelente em outros benchmarks para o seu tamanho. […] Mesmo em chat sem ferramentas, o desempenho é ruim, e ele alucina com bastante empenho. No momento estou tentando reproduzir dando acesso total a ferramentas, incluindo bash/Python; nesse caso, este modelo também pode ser competitivo”

    • É estranho que, em 2026, alguém diga seriamente que “o desempenho é ruim em chat sem ferramentas”. Não sei se esse fine-tuning é bom, porque não testei pessoalmente, mas não faz sentido testar um modelo agente sem acesso a ferramentas e esperar que ele se saia bem, não? Não faço ideia do que estavam testando
    • Esse benchmark coloca Kimi K2.6 e K2.7 Code quase no fim da lista. Ambos ficam abaixo do Ornith 35B, e avalia o Gemma 4 26B muito acima do GLM-5.2. Os resultados não parecem muito convincentes

  • Este é o primeiro fine-tuning do Qwen que não foi rejeitado de imediato pela comunidade de LLMs locais e, em alguns casos, até é recomendado. Pelo uso limitado que fiz, parece bom e propõe soluções criativas para problemas de programação. Não espero que modelos de 9–35B criem um app inteiro com um clique. A maioria das reclamações parece vir desse tipo de expectativa

    • A comunidade de LLMs locais foi invadida por antigos vendedores de criptomoedas/NFTs, que trouxeram junto a cultura de exagero da comunidade anterior. Ainda há técnicos com profundidade por lá, mas eles estão sendo cada vez mais abafados por vozes de marketing vazias
    • Infelizmente, foi assim desde o começo. Não há nada de prejudicial em testar modelos locais em tarefas locais, com salvaguardas razoáveis
      Hoje é realmente trabalhoso descobrir as pequenas armadilhas da maioria dos modelos, como Qwen, Gemma, Llama e gpt-oss: tokens especiais, estrutura de prompt, preferências do modelo etc. Mesmo assim, com prompts aprendidos a duras penas e parâmetros ajustados, é possível obter modelos que rodam muito bem em um ambiente de execução agente
    • Não ficou melhor. A maioria da comunidade LocalLLama não gosta muito disso; são só alguns recém-chegados postando
    • Parece que estamos em comunidades diferentes. Os modelos Qwen estão entre os mais recomendados entre os que realmente podem rodar em hardware local acessível ao público

  • Por que esses modelos de “autoaperfeiçoamento” nunca acabam melhorando a ponto de superar os modelos de ponta?

  • Pelos meus testes, o Ornith-1.0 35B foi um pouco melhor que o Qwen-3.6 35B
    Meus testes envolvem adicionar ou modificar funcionalidades em uma grande base de código C++. O interessante é que este modelo é muito mais rápido que o Qwen3.6 35B. O Ornith parece produzir cadeias de raciocínio mais curtas
    Nos meus testes, ele foi até 3 vezes mais rápido para gerar respostas. Estou usando com llamacpp e codex-cli

  • Testei o Ornith-1.0 35B com uma quantização em blocos FP8 feita por mim e gostei. Em uma RTX PRO 6000(sm120), com vLLM, ele passa de 200 tokens/s, e nos últimos dias rodei mais de 140 milhões de tokens em cache em tarefas de programação no estilo agente
    Ele parece ficar mais ou menos entre o Qwen 3.6 35B-A3B e o 27B, mas o bom é que ele pensa demais ou entra no mesmo loop com muito menos frequência que o Qwen 3.6. Olhando o rastreamento de raciocínio, gosto do template da abordagem de decomposição
    Em uma base de código Go de porte médio, ele foi bem em análise básica, execução de tarefas e algumas mudanças de front-end/back-end, mas bateu completamente no limite em uma tarefa simples mais longa de implementação de kernel. Rodei cerca de 100 iterações no ambiente de execução Pi Agent e ele estragou tudo; esse é o tipo de tarefa que modelos públicos mais fortes, como Kimi K2.6 ou GLM 5.2, conseguem fazer

    • Nesse tamanho de modelo, o ambiente de execução pareceu ser mais importante. Pessoalmente, no qwen3.6 27b, mudei do pi bruto para o little-coder; vale dar uma olhada

  • Alguém consegue explicar o que está acontecendo aqui? É só um Qwen com uma pintura por cima? Quem é a deepreinforce-ai e por que este modelo não aparece no site deles?
    Fico curioso sobre como ele se autoaperfeiçoa. O modelo no disco muda, ou ele só melhora durante uma única execução de contexto?

    • Ele não se autoaperfeiçoa. O título é enganoso
      Pelo que vejo, parece que eles treinaram rodando aprendizado por reforço próprio em cima do Qwen e do Gemma 4. Não sei como combinaram os pesos dos dois, nem tenho certeza se usaram o Qwen como base e o Gemma 4 como auxiliar de treinamento. Aqui, “autoaperfeiçoamento” parece se referir ao processo de treinamento, não à forma como os pesos são usados

  • Estes parecem ser apenas versões do Qwen ou do Gemma 4 otimizadas para benchmarks

    • Se for isso, é impressionante que tenham conseguido empurrar ainda mais o Qwen, que já é bastante otimizado para benchmarks

  • “Um 9B denso cabe em uma única GPU de 80 GB”
    Pessoas comuns como nós não vão conseguir usar

    • Parece estranho. Um modelo 9B normalmente cabe até em uma GPU de 24 GB sem quantização
    • Já existem versões quantizadas

  • Usei muitos modelos locais e todos pareceram brinquedos. Mas este me deu a sensação de ser realmente útil. Também ouvi dizer que o Qwen 36-A3B é bom, mas ainda não consegui testar

  • Sistemas de autoaperfeiçoamento são interessantes, mas tornam rastreamento de origem e governança muito mais difíceis. Quando agentes podem mudar o próprio comportamento ao longo do tempo, entender por que agiram de determinada maneira se torna cada vez mais importante