LFM2.5-24B-A2B roda agentes de IA localmente sem depender da nuvem

A Liquid AI publicou em 13 de outubro de 2026 o LFM2.5-24B-A2B, um modelo de raciocínio com 24 bilhões de parâmetros no total, mas que ativa só 2 bilhões por token. Isso é o que a empresa chama de arquitetura MoE (mixture of experts, ou mistura de especialistas): em vez de acender o modelo inteiro a cada palavra gerada, o sistema escolhe um subconjunto pequeno de "especialistas" internos para processar aquele token específico.

O resultado prático, segundo o anúncio no Hugging Face, é um modelo que pensa antes de responder, chama ferramentas externas e executa tarefas de múltiplos passos dentro de frameworks de agente populares, tudo isso rodando no próprio hardware do desenvolvedor.

O ângulo que interessa a quem constrói agentes é direto: se o modelo roda local, ele não depende de uma API de nuvem para cada chamada. Isso muda a equação de custo (sem cobrança por token de provedor externo) e a equação de privacidade (nenhum dado sai da máquina). Para quem lida com dados sensíveis, como registros de clientes ou informações internas de uma empresa, essa é a diferença entre poder usar IA generativa ou ter que esperar aprovação de compliance.

Por que ativar só 2 bilhões de parâmetros muda o jogo

O LFM2.5-24B-A2B herda a arquitetura do LFM2-24B-A2B, anterior da própria Liquid AI: 40 camadas, 64 especialistas por bloco MoE com roteamento top-4 (o modelo escolhe 4 especialistas de 64 a cada passo) e um híbrido de convoluções curtas com portão (gated short convolutions) e GQA (grouped-query attention, uma forma de atenção que reduz memória compartilhando chaves e valores entre cabeças).

A diferença para a versão anterior está em três pontos: a janela de contexto cresce de 32 mil para 131 mil tokens, o vocabulário do tokenizador dobra de 65 mil para 128 mil tokens (o que melhora a tokenização de idiomas que não usam alfabeto latino) e, pela primeira vez nessa família, o modelo é só de raciocínio: ele sempre produz uma cadeia de pensamento explícita antes da resposta final, em vez de responder direto.

Na prática, isso significa que cada chamada ao modelo carrega um custo computacional de "pensar em voz alta" antes de entregar o resultado. Com 2 bilhões de parâmetros ativos por token, esse pensamento sai mais barato do que em um modelo denso do mesmo tamanho total, mas ainda assim consome mais tokens de saída do que um modelo que responde sem raciocínio intermediário.

Da pré-treinagem ao agente: cinco etapas até virar útil

O volume de dados de pré-treinamento saltou de cerca de 17 trilhões para cerca de 33 trilhões de tokens em relação ao modelo anterior. Depois vem uma etapa de "mid-training": 2 trilhões de tokens a 32 mil tokens de contexto, com peso em raciocínio, matemática, código, seguir instruções e texto multilíngue, seguidos por 300 bilhões de tokens a 131 mil tokens de contexto, focados em dados de contexto longo. Chamadas de ferramenta e trajetórias de múltiplas interações aparecem nas duas fases.

O pós-treinamento é o que transforma o modelo base em agente, em cinco estágios:

1. SFT (supervised fine-tuning): ajuste fino supervisionado com exemplos rotulados.
2. Especialização de professores: modelos maiores são treinados em domínios específicos para servir de referência.
3. MOPD não agêntico (multi-domain on-policy distillation): o modelo aprende destilando o conhecimento dos especialistas em tarefas que não envolvem uso de ferramentas.
4. MOPD agêntico: segunda rodada de destilação, agora focada em tarefas que exigem chamar ferramentas.
5. RL agêntico: o modelo treina dentro de frameworks de agente de verdade, como OpenClaw, Hermes Agent, Pi e OpenCode, aprendendo com reforço a partir do próprio desempenho em tarefas reais.

Esse pipeline explica por que o modelo se sai bem em tarefas de ferramenta mesmo sendo pequeno: ele não aprendeu a usar ferramentas só por imitação, mas por reforço dentro dos próprios ambientes de agente.

O que os números dizem (e o aviso que vem junto)

A Liquid AI comparou o LFM2.5-24B-A2B com Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it e Nemotron-3.5-Lightning (30B-A3B) em 16 benchmarks, todos avaliados com vLLM usando os parâmetros de geração recomendados por cada benchmark. É importante marcar que esses números são autorreportados pela própria fabricante do modelo, não uma medição de terceiro independente, então valem como ponto de partida, não como veredito final.

O padrão é claro: o LFM2.5-24B-A2B lidera ou empata em 5 dos 8 benchmarks de uso de ferramentas e tarefas agênticas, com destaque para o AutomationBench, onde tira mais de três vezes a nota do segundo colocado. Também lidera nos três benchmarks de seguir instruções (IFEval, IFBench e Multi-IF). Por outro lado, perde feio em conhecimento geral (GPQA Diamond, HLE, AA-Omniscience) e em código (SWE-Bench Verified e SciCode), onde modelos maiores como o Qwen3.6-35B-A3B seguem na frente. A recomendação da própria Liquid AI é combinar o modelo com busca ou retrieval para tarefas que dependem de conhecimento factual amplo.

Velocidade real: do notebook ao datacenter

Os números de inferência são o argumento central para quem quer rodar agentes continuamente sem estourar o orçamento de nuvem. Em hardware de borda, o modelo decodifica 184 tokens por segundo em um Apple M5 Max e 114 tokens por segundo em um Ryzen AI Max+ 395, até 1,7 vezes mais rápido que o próximo concorrente da mesma categoria, usando menos memória. Em GPU, ele passa de 21 mil tokens de saída por segundo em alta concorrência num único NVIDIA B300.

Para quem decide infraestrutura, isso traduz em uma conta simples: rodar o modelo localmente elimina o custo por chamada de API de provedores de nuvem, mas exige investimento inicial em hardware (um Mac com chip Apple Silicon recente, uma GPU como a B300, ou aluguel pontual de instância com GPU). Para um agente que roda continuamente, 24 horas por dia, chamando ferramentas a cada poucos segundos, esse cálculo tende a favorecer o hardware próprio bem mais rápido do que parece à primeira vista.

Como colocar para rodar hoje

O modelo tem suporte desde o lançamento em llama.cpp, MLX, vLLM, SGLang e ONNX. Para testar via transformers (necessário transformers>=5.0.0):

pip install -U transformers

from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

model_id = "LiquidAI/LFM2.5-24B-A2B"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    dtype="bfloat16",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

prompt = "What is C. elegans?"
input_ids = tokenizer.apply_chat_template(
    [{"role": "user", "content": prompt}],
    add_generation_prompt=True,
    return_tensors="pt",
    tokenize=True,
)["input_ids"].to(model.device)

output = model.generate(input_ids, do_sample=True, temperature=0.1, top_k=50, max_new_tokens=512, streamer=streamer)

Para usar dentro de um agente de verdade, a Liquid AI recomenda servir o modelo localmente atrás de um backend compatível com a API da OpenAI e apontar o harness para ele. Com o Hermes Agent, por exemplo:

hermes config set model.provider custom
hermes config set model.base_url http://localhost:8080/v1
hermes config set model.default LFM2.5-24B-A2B
hermes config set model.context_length 131072
hermes config set model.api_mode chat_completions
hermes config set agent.tool_use_enforcement true

A porta muda conforme o backend de serving: llama.cpp e MLX usam 8080, vLLM usa 8000, SGLang usa 30000 e LM Studio usa 1234.

Onde não compensa trocar pelo modelo grande

Se o agente que você está construindo depende de conhecimento factual amplo e pouco estruturado (perguntas gerais de ciência, história, cultura) ou de gerar código complexo em repositórios reais, o LFM2.5-24B-A2B ainda perde para modelos maiores como o Qwen3.6-35B-A3B nos benchmarks de SWE-Bench Verified e GPQA Diamond. Nesses casos, o caminho sugerido pela própria fabricante é combinar o modelo pequeno com busca ou RAG (retrieval-augmented generation, geração aumentada por busca) em vez de trocar o modelo inteiro.

O modelo e sua versão base, o LFM2.5-24B-A2B-Base, estão com pesos abertos no Hugging Face desde o lançamento, junto com guias de fine-tuning para quem quer adaptar o comportamento a uma tarefa específica. A própria equipe resume a proposta no fim do anúncio:

Mal podemos esperar para ver o que vocês vão construir.

We can't wait to see what you build.Equipe Liquid AI, no anúncio do LFM2.5-24B-A2B

Para quem já tem um agente rodando em cima de modelo de nuvem e sente o custo por token pesando no orçamento, vale o teste: baixar o modelo, apontar o harness para o endpoint local e comparar o comportamento nas próprias tarefas de tool calling antes de decidir se a troca compensa.

Fonte: Hugging Face Blog