Como funciona o function calling no Muse Glimmer, o modelo agêntico aberto da Meta

Agente não trava por falta de inteligência

Agente trava na hora de chamar a ferramenta certa, com o argumento certo, no formato certo

Fala aí, beleza? A Meta Superintelligence Labs lançou em 10 de agosto de 2026 o Muse Glimmer, um modelo de linguagem causal com encoder de percepção dedicado, 30 bilhões de parâmetros, destilado do Muse Spark e feito pra tarefas agênticas autônomas em hardware de consumo

E os pesos saíram abertos, sob licença Apache 2.0

Entre os recursos que a Meta descreve tem um que merece atenção especial de quem monta agente: o Reliable Tool Use

É sobre isso que a gente vai conversar aqui, no conceito e no que a documentação realmente afirma, sem esticar nada

Function calling e schema: o que é isso para quem nunca montou um agente

Vamos do começo, porque esse assunto costuma vir embrulhado em jargão

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

Uma ferramenta (tool) é qualquer coisa que o modelo sozinho não sabe fazer: consultar um banco, ler um arquivo, bater numa API de clima, rodar um cálculo, buscar na web

O modelo é bom em decidir, não em executar

Então a gente descreve a ferramenta pra ele num contrato, e esse contrato é o schema

O que vai dentro de um schema:

O schema diz três coisas basicamente: o nome da função, quais parâmetros ela aceita e de que tipo é cada parâmetro (texto, número, booleano, lista)

Se você já mexeu com tipagem em qualquer linguagem, é a mesma ideia: um contrato que o outro lado precisa respeitar

Na prática, um contrato genérico diz mais ou menos isso:

{
  "name": "buscar_pedido",
  "description": "Busca um pedido pelo número",
  "parameters": {
    "numero_pedido": { "type": "string" },
    "incluir_itens": { "type": "boolean" }
  }
}

Esse é só um exemplo ilustrativo do conceito, pra você sentir o formato de um contrato

E o modelo executa a função?

NÃO

Essa é a parte que mais confunde quem está começando

O modelo não executa nada, ele apenas pede: "chame buscar_pedido com esses argumentos"

Quem executa é o programa em volta (seu código, seu orquestrador, seu framework)

O loop é esse aqui:

1. você manda a pergunta do usuário mais a lista de schemas das ferramentas disponíveis
2. o modelo responde com uma chamada de função e os argumentos preenchidos
3. seu programa executa aquela função de verdade
4. o resultado volta pro modelo como mais uma mensagem
5. o modelo lê o resultado e decide: responde ao usuário ou chama outra ferramenta

Repetiu o passo 5 várias vezes? Pronto, você tem um agente

Esse loop é igual em qualquer modelo que suporte chamada de ferramenta, vale a pena ver como isso aparece com agents e function calling no DeepSeek pra fixar o conceito antes de comparar implementações

Como o Muse Glimmer trata as chamadas de função

Agora sim, o que a Meta descreve no anúncio do modelo

O Reliable Tool Use significa que o modelo lida com uma ampla variedade de chamadas de função, invocando ferramentas com schemas precisos ao longo de fluxos de trabalho extensos

Repare nas duas palavras que carregam o peso aí: precisos e extensos

Recuperação de falha integrada:

Quando uma chamada de ferramenta falha ou devolve um resultado inesperado, o modelo diagnostica o erro e tenta de novo, em vez de parar

Isso é failure recovery embutido no próprio modelo, não uma gambiarra de retry que você escreve por fora

Quem já viu agente morrer educadamente no primeiro 500 de uma API sabe exatamente o tamanho desse problema 😀

Planejamento em horizonte longo:

O modelo encadeia raciocínio em horizontes longos, sustentando planos coerentes em fluxos complexos e prolongados, com invocação sequencial de ferramentas

Ou seja: não é chamar uma função e responder, é manter o plano de pé enquanto chama uma, lê o resultado, chama a próxima, e por aí vai

A Meta cita o τ3-Bench entre os benchmarks em que o modelo atinge boas taxas de sucesso em uso agêntico de ferramentas

E a parte multimodal?

Pelo encoder de percepção dedicado, o modelo aceita texto e imagens intercalados

Isso permite que o agente interprete capturas de tela, gráficos e documentos junto da conversa, no meio do fluxo, sem você ter que quebrar o processo em dois sistemas

Massa, né?

Por que o uso de ferramentas é o gargalo real de qualquer agente

Aqui está o ponto que eu queria chegar

Tem uma distância enorme entre "o modelo escreve um texto bonito" e "o modelo completa a tarefa"

E quase nunca o que quebra no meio é a inteligência do texto

O que quebra é bem mais chato que isso:

• a chamada malformada, com JSON quebrado ou nome de função que não existe
• o parâmetro errado, string onde era número, campo obrigatório faltando, valor inventado
• a desistência no primeiro erro, quando a API devolve algo estranho e o agente simplesmente encerra

Os três fatos do Muse Glimmer batem exatamente nesses três buracos

Schema preciso ataca a chamada inválida

Recuperação de falha evita o agente morrer no meio do caminho

Horizonte longo mantém o plano coerente quando a tarefa tem muitas etapas

O que muda pra quem constrói:

O modelo integra raciocínio multi-etapas, uso confiável de ferramentas, compreensão multimodal e recuperação de falhas num único modelo que roda localmente, sem infraestrutura de nuvem e sem acesso à rede

Sem nuvem também quer dizer sem taxa de API, o que muda a conta de qualquer fluxo que faz dezenas de chamadas por tarefa

É um contraste direto com o modelo mental de quem vive contando token e olhando o teto de uso, do jeito que acontece quando você precisa entender como funcionam as cotas de mensagens de um serviço hospedado

E tem o contexto de mercado: depois de mais de um ano focada em modelos fechados, a Meta volta a publicar modelos abertos com o Muse Glimmer, com os pesos sob Apache 2.0

Força de raciocínio: quando usar low, medium, high ou xhigh

O Muse Glimmer suporta força de raciocínio controlável, com quatro opções

A orientação da própria página do modelo é usar high ou xhigh pra código complexo e tarefas agênticas, e forças menores quando velocidade importa mais

A direção é essa e dá pra seguir com segurança: tarefa agêntica pede força alta, tarefa rápida aceita força baixa

Onde um agente local com function calling faz sentido

Bora aterrissar isso em cenário de verdade

Automação que não pode sair da máquina:

Como a execução é local, sem infraestrutura de nuvem, sem acesso à rede e sem taxas de API, o dado que o agente manipula não precisa atravessar a internet

Pra fluxo com arquivo interno, contrato, planilha de cliente, isso muda o jogo

Agente que lê tela e documento junto da conversa:

Com entrada de texto e imagem intercalada, dá pra montar um fluxo em que o agente recebe uma captura de tela, entende o que está ali e decide qual ferramenta chamar em seguida

Gráfico, documento, print de erro, tudo entra no mesmo fio da conversa

Fluxo longo com muitas etapas encadeadas:

A janela de contexto é de 256 mil tokens

Isso segura histórico de chamadas, resultados de ferramentas e o plano em andamento sem você ter que picotar a tarefa em pedacinhos

Orquestração com padrão que já existe:

O Muse Glimmer funciona com OpenClaw, Hermes Agent e outros padrões de orquestração agêntica

Ou seja: se o seu agente já roda em cima de um desses, você não precisa reinventar a camada de orquestração pra experimentar o modelo

É plugar no lugar do modelo que já está lá e ver o loop de chamada rodando

O que você precisa para rodar o Muse Glimmer na sua máquina

Aqui eu vou ser bem literal, porque tem muita coisa circulando que não está nas páginas oficiais

Onde o modelo está

Ele está disponível na biblioteca do Ollama sob o nome muse-glimmer, com as tags publicadas 30b, 30b-q4_K_M, 30b-mlx e 30b-q4_K_M-dflash

Os pesos também estão no Hugging Face, na organização meta-models, no repositório Muse-Glimmer-30B, junto das variantes Muse-Glimmer-30B-GGUF, Muse-Glimmer-30B-ExecuTorch-PTE e Muse-Glimmer-30B-assistant

O repositório principal inclui o arquivo chat_template.jinja

Hardware

O modelo pode ser quantizado pra menos de 20 GB, o que permite rodar localmente numa única GPU de consumo ou num Mac

Não é PC da Nasa, e isso é justamente a graça de um modelo agêntico de 30 bilhões de parâmetros

Apple Silicon

O motor MLX do Ollama entrega desempenho de ponta em Apple Silicon pra este modelo, com suporte a DFlash e entrada de imagem

DFlash, o opcional

Existe um drafter de decodificação especulativa implementado sobre DFlash, de uso opcional, que troca memória por geração mais rápida

Com DFlash, o modelo roda de 1,5x a 1,8x mais rápido em Apple Silicon

Tome cuidado com uma coisa: as tags estão confirmadas, mas o passo a passo de execução muda de motor pra motor

Vá pela página da biblioteca do Ollama ou pelo repositório do Hugging Face e siga a instrução que está lá

Acho zoado ensinar comando por achismo, e comando errado no terminal é o tipo de coisa que faz você perder uma tarde =)

Vídeo: como eu uso Skills nos meus projetos

Se você está começando a organizar as capacidades de um agente e quer ver isso do zero, esse vídeo do canal mostra as Skills que eu uso em todos os meus projetos com Claude Code

É um material introdutório sobre como estruturar o que o agente sabe fazer, que é o mesmo raciocínio por trás de descrever ferramenta com schema

Vale a pena? O que os números dizem sobre o Muse Glimmer

Agora a parte que ninguém gosta de escrever no dia do lançamento

Na página de dados do Artificial Analysis, o Muse Glimmer (high) marca 35 no Artificial Analysis Intelligence Index

E no GDPval-AA v2 ele marca 953 de Elo, abaixo da linha de base humana de 1.000 e atrás de outros modelos do mesmo nível de inteligência

O trabalho de conhecimento agêntico é apontado justamente como a fraqueza do modelo na sua classe de tamanho

Irônico, né? O ponto fraco medido cai em cima da categoria que o modelo foi feito pra atacar

Do outro lado da balança:

• 44 no Openness Index, medida de disponibilidade e transparência do modelo
• posição perto da fronteira de inteligência por parâmetros entre os modelos de pesos abertos
• 256 mil tokens de janela de contexto
• entrada de texto e imagem, saída de texto
• conhecimento até janeiro de 2026

E ainda tem a arquitetura, que é bem interessante de olhar: atenção híbrida com três camadas de janela deslizante de 2.048 tokens com rotary position embedding, seguidas por uma quarta camada de atenção total com NoPE, padrão repetido 13 vezes, totalizando 52 camadas

O veredito honesto, então, é esse: o Muse Glimmer é promissor como agente local e aberto, com Apache 2.0, rodando sem nuvem e sem taxa de API

Não é substituto de modelo de fronteira em trabalho agêntico pesado, e os próprios números dizem isso

Conclusão

Se tem uma coisa pra levar deste post, é que o gargalo do seu agente quase nunca é o número de parâmetros

Schema bem escrito e tolerância a falha valem mais que tamanho de modelo

O function calling no Muse Glimmer é interessante porque ataca exatamente esses dois pontos: schema preciso em fluxo extenso, e diagnóstico do erro com nova tentativa em vez de parada seca

Próximo passo concreto, se você quiser tirar a prova:

1. baixe pela tag do Ollama ou pelo repositório da organização meta-models no Hugging Face
2. suba com força de raciocínio high, que é a orientação pra tarefa agêntica
3. ligue duas ou três ferramentas simples, com schema enxuto e parâmetro bem tipado
4. force um erro de propósito numa delas e observe o loop de chamada e recuperação acontecendo

Faça o teste e tire sua própria conclusão, que é sempre melhor que confiar em benchmark de terceiro

Até o próximo post! 🙂