LFM2.5-2.6B llega para poner agentes capaces directamente en tus dispositivos: pequeño, optimizado para uso de herramientas e interacción multi-turno, y con latencias que permiten despliegues en CPU, GPU y hasta en teléfonos. ¿Quieres un agente que siga instrucciones, use APIs y funcione dentro de un harness sin depender de la nube? Esto va por ese camino.
Qué es LFM2.5-2.6B
LFM2.5-2.6B es un modelo de lenguaje de ~2.6B parámetros diseñado para ser un "agent model" de alto rendimiento. Se entrenó sobre ~34T de tokens y pasó por una fase intermedia para extender la ventana de contexto a 128K tokens. Luego se transforma en agente mediante una secuencia de fases pensadas para abarcar muchas formas de interacción real con herramientas.
¿Resultado práctico? Un modelo pequeño que compite con modelos 4x más grandes en tareas de uso de herramientas, seguimiento de instrucciones y tareas agenticas multi-paso.
Arquitectura y pipeline de entrenamiento
El proceso post-entrenamiento está compuesto por cuatro etapas claves:
Supervised Fine-Tuning (SFT): dos rondas de SFT, con fuerte ponderación hacia datos agenticos: uso de herramientas, búsquedas web y trayectorias de harness.Teacher specialization: se entrena un teacher especialista por dominio (por ejemplo, matemáticas, código, uso de herramientas).Multi-domain On-Policy Distillation (MOPD): se destilan esos teachers especializados en un solo student.Agentic Reinforcement Learning (Agentic RL): se ejecuta RL multi-turno dentro de harnesses reales, para que el modelo aprenda a coordinar herramientas, prompts del sistema y entornos con estado.
El Agentic RL separa optimización, inferencia y ejecución de entorno en componentes distintos:
- Training Engine: optimiza el modelo.
- Rollout Engine: genera acciones con la política más reciente.
- Sandbox Service: ejecuta acciones en un entorno aislado.
- Blackbox Harness: aloja al agente (ej. OpenClaw, Hermes Agent) y coordina la interacción con el entorno.
- Harness Proxy: permite tratar harnesses como cajas negras sin modificarlos, pero capturando las trayectorias a nivel de token necesarias para reconstruir y validar muestras de RL.
Esto significa que se pueden usar harnesses existentes sin reescribirlos y aun así obtener datos de entrenamiento válidos y reproducibles.
Rendimiento frente a modelos mayores
En una batería de benchmarks (STEM, seguimiento de instrucciones, uso de herramientas y tareas agenticas), LFM2.5-2.6B compite y a menudo vence a modelos 4x su tamaño. Sus puntos fuertes son instrucción y uso de herramientas; donde pierde terreno es en código, donde los modelos más grandes mantienen ventaja.
Puntos clave:
- Lidera en benchmarks de instruction following y casi todos los benchmarks de tool use.
- En tareas agenticas mantiene ventaja sobre modelos Gemma comparables y empata con Qwen en muchas pruebas.
- Se defiende bien en conocimiento y matemáticas; en coding conviene considerar modelos mayores.
Si estás construyendo un agente que necesita coordinar APIs, navegar y ejecutar herramientas en flujos largos, este modelo es una opción eficiente y competitiva.
Inference y despliegue: dónde brilla
LFM2.5-2.6B fue pensado para correr en sitios reales: desde servidores con H100 hasta CPUs y dispositivos móviles.
- Eficiencia de CPU: 220 tok/s en un Apple M5 Max y 113 tok/s en un AMD Ryzen AI Max+ 395, usando menos de 2.5 GB de memoria. A 30 tok/s ya es posible ejecutar agentes en un teléfono.
- Eficiencia de GPU: casi 15K tokens/s en alta concurrencia en una H100, lo que se aproxima a ~1.3B tokens por día en una sola GPU.
- Ecosistema: soporte day-one en
llama.cpp, MLX, vLLM, SGLang y ONNX.
Consecuencia práctica: puedes desplegar agentes locales de alto volumen sin depender exclusivamente de servidores costosos o latencias de red. Para apps con alta exigencia de throughput y despliegue en el edge, LFM2.5-2.6B es una opción sólida.
Ejemplo rápido para probarlo
Instala la versión reciente de transformers (>=5.0.0):
pip install -U transformers
Carga el modelo en Python (sugerencias prácticas: device_map="auto", dtype="bfloat16"):
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "LiquidAI/LFM2.5-2.6B"
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
dtype="bfloat16",
# attn_implementation="flash_attention_2" # descomenta en GPU compatible
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
prompt = "What is C. elegans?"
input_ids = tokenizer.apply_chat_template(
[{"role": "user", "content": prompt}],
add_generation_prompt=True,
return_tensors="pt",
tokenize=True,
).to(model.device)
output = model.generate(
input_ids,
do_sample=True,
temperature=0.2,
top_k=80,
repetition_penalty=1.05,
max_new_tokens=512,
)
print(tokenizer.decode(output[0], skip_special_tokens=False))
Recomendaciones prácticas
- Usa LFM2.5-2.6B cuando necesites agentes locales que interactúen con herramientas, hagan búsquedas y ejecuten tareas multi-turno con baja latencia.
- Si tu prioridad es coding intensivo o generación de código complejo, considera modelos más grandes.
- Aprovecha el soporte a
llama.cppy ONNX para despliegues en dispositivos con recursos limitados. - Para integración en pipelines RL y harnesses como OpenClaw o Hermes, la arquitectura del pipeline facilita usar harnesses existentes sin cambiarlos.
Piensa en casos de uso concretos: un asistente de investigación que consulta APIs y escribe resúmenes, un agente de soporte que ejecuta diagnósticos en máquinas locales, o un bot de scraping controlado con seguridad en el dispositivo. Con LFM2.5-2.6B puedes mover mucha lógica hacia el edge.
Reflexión final
No se trata solo de un modelo pequeño y rápido: LFM2.5-2.6B es una apuesta por agentes prácticos que corren donde tú los necesites. Si estás desarrollando agentes que deben interactuar con herramientas reales y ofrecer latencias bajas, este modelo cambia el balance entre coste, velocidad y capacidad. ¿Te animas a probarlo en tu siguiente prototipo?