Liquid AI LFM 2.5: guía completa | Modelos edge-native para agentes IA on-device

Qué es Liquid AI y LFM 2.5

Liquid AI es una startup que construye Liquid Foundation Models (LFMs) —una nueva clase de modelos con arquitectura híbrida no-Transformer diseñada para correr en edge devices: laptops, teléfonos, robots y dispositivos IoT. A diferencia de los modelos tradicionales que requieren cloud GPUs, los LFMs están optimizados para inferencia local con costo marginal cero.

La familia LFM2.5 es su generación más reciente (2026), enfocada en agentes on-device: modelos que planifican, llaman tools y ejecutan tareas multi-paso completamente en tu dispositivo, sin cloud API, sin costo por token y con privacidad total.

El flagship —LFM2.5-2.6B, lanzado el 4 de agosto de 2026— es un modelo de 2.6 billones de parámetros que supera a modelos 4x más grandes en tool use e instruction following, corre a 220 tokens/segundo en CPU de Apple M5 Max, y cabe en menos de 2.5 GB de memoria.

Arquitectura: por qué no es un Transformer

Los LFMs usan una arquitectura híbrida que combina:

22 bloques de convolución short-gated (double-gated short convolution blocks)
8 capas GQA (Grouped Query Attention)
Vocabulario extendido a 128K tokens (doblado respecto a LFM2 para soportar scripts no-Latin)

Esta arquitectura es más eficiente que un Transformer puro para inferencia en CPU porque las convoluciones 1D tienen complejidad lineal con el context length, no cuadrática como la attention estándar. Esto permite context windows de 128K tokens en un dispositivo con menos de 2.5 GB.

La familia LFM2.5 completa

Modelo	Parámetros	Context	Tipo	Uso principal	Release
LFM2.5-2.6B	2.6B (dense)	128K	Agentic	Flagship on-device agent	Ago 2026
LFM2.5-8B-A1B	8.3B (1.5B active, MoE)	128K	Reasoning	Razonamiento + tool calling on-device	May 2026
LFM2.5-1.2B-Instruct	1.2B (dense)	32K	Chat	Chat general, recomendado para mayoría	Feb 2026
LFM2.5-1.2B-Thinking	1.2B (dense)	32K	Reasoning	Math y lógica	2026
LFM2.5-1.2B-Base	1.2B (dense)	32K	Base	Fine-tuning y custom checkpoints	2026
LFM2.5-1.2B-JP	1.2B (dense)	32K	Japanese	Generación de texto en japonés	Jun 2026
LFM2.5-350M	350M (dense)	32K	Fast	Edge rápido, baja latencia	2026
LFM2.5-230M	230M (dense)	32K	Smallest	Dispositivos mínimos (Raspberry Pi, phone CPU)	Jun 2026
LFM2.5-VL-1.6B	1.6B	—	Vision-Language	Image understanding + extract	2026
LFM2.5-VL-450M	450M	—	Vision-Language	VL compacto para extract	2026
LFM2.5-Audio-1.5B	1.5B	—	Audio	TTS, ASR, voice chat	2026
LFM2.5-Audio-1.5B-JP	1.5B	—	Audio JP	Audio en japonés	2026
LFM2.5-Encoder-350M	350M	—	Encoder	Long context en CPU	2026
LFM2.5-Encoder-230M	230M	—	Encoder	Encoder compacto	2026
LFM2.5-Embedding-350M	350M	—	Embedding	Búsqueda multilingual	2026
LFM2.5-ColBERT-350M	350M	—	Retriever	Retrieval bi-direccional	2026

LFM2.5-2.6B: el flagship agentic

Especificaciones técnicas

Propiedad	Valor
Parámetros totales	2.69B
Parámetros activos	2.6B (dense, no MoE)
Capas	30 (22 convolución + 8 GQA)
Context window	131,072 tokens (128K)
Vocabulario	128,000 tokens
Training data	~34 trillones de tokens
Memoria (cuantizado)	<2.5 GB
Precisión	BF16 / FP4+FP8 mixed (variantes)
Idiomas	16: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, Polish
Tool calling	Nativo (entrenado dentro de harnesses reales)
Licencia	LFM Open License v1.0 — gratis hasta $10M ARR

Velocidad de inferencia

Hardware	Tokens/seg	Notas
Apple M5 Max (CPU)	220 tok/s	Debajo de 2.5 GB de memoria
AMD Ryzen AI Max+ 395 (CPU)	113 tok/s	CPU inference
Teléfono (CPU)	30 tok/s	Agente funcional on-device
NVIDIA H100 SXM5 (GPU)	~15,000 tok/s	Alta concurrencia, ~1.3B tokens/día

LFM2.5-2.6B es el modelo más rápido en su clase de tamaño en todas las configuraciones testeadas.

Benchmarks: supera a modelos 4x más grandes

Benchmark	LFM2.5-2.6B (2.6B)	Gemma-4-E2B (5.1B)	Gemma-4-E4B (8B)	Qwen3.5-4B (4.7B)	Qwen3.5-9B (9.7B)
AA Omniscience	-29.50	-74.47	-49.03	-54.30	-50.43
AIME25 (math)	51.87	26.33	34.27	49.33	56.07
LiveCodeBenchv6	59.41	54.92	63.77	60.85	69.86
IFBench	59.17	34.08	39.24	48.40	56.47
Multi-IF	80.07	69.44	77.35	55.67	62.55
IFStruct	85.49	64.85	76.65	36.25	78.50
BFCLv4 (tool use)	56.88	36.98	46.39	50.56	60.13
ToolSandbox	77.83	52.40	65.00	75.55	76.44
τ³-Bench Banking	5.67	3.35	4.12	5.45	5.15
Claw-Eval average (EN)	62.85	53.14	58.02	62.28	66.53
PinchBench	68.22	44.24	55.09	71.26	71.45
BrowseComp+ (OpenClaw)	26.89	8.31	15.90	24.46	27.23

LFM2.5-2.6B lidera en todos los benchmarks de instruction following y en casi todos los de tool use, perdiendo solo contra Qwen3.5-9B (que es 3.7x más grande) en BFCLv4. En tareas agentic, supera a ambos modelos Gemma y compite de cerca con Qwen.

Weakness honesta: coding (LiveCodeBenchv6) es donde los modelos más grandes mantienen una ventaja clara.

Cómo se entrenó: pipeline de 4 etapas

El post-training convierte el base model en un agente mediante cuatro etapas:

Etapa 1: Supervised Fine-Tuning (SFT)

Dos rondas consecutivas: cobertura broad primero, luego shaping targeted en skills prioritarias (tool use, reasoning, agentic tasks). El mix de SFT es 7x más grande que el usado para LFM2.5-8B-A1B, con peso heavy hacia tool use, web search, software engineering y agent traces.

Etapa 2: Teacher Specialization

Desde el checkpoint SFT compartido, se entrena un experto por dominio: instruction following, math, knowledge + hallucination control, code, tool use, long context. Cada experto optimiza profundamente para su dominio sin competir con objectives no relacionados.

Etapa 3: Multi-Domain On-Policy Distillation (MOPD)

Los expertos se usan como teachers para destilar sus capacidades en un único student. A diferencia de off-policy distillation, MOPD deja al student rollout bajo su propia policy. Cada prompt se rutea al teacher del dominio correspondiente, que supervisa con feedback a nivel de token.

Etapa 4: Agentic Reinforcement Learning

El modelo aprende a operar dentro de agent harnesses reales (Hermes Agent, OpenClaw, Pi). Se corre multi-turn RL donde el modelo trabaja en tareas de productividad reales: research, writing, coding, data analysis, document management, tool use y multi-step workflows.

Framework: verl con GRPO
Reward: LLM-as-a-judge rubric + programmatic checks + hard safety gate
Training Engine: FSDP
Rollout Engine: SGLang
Sandbox Service con Blackbox Harness y Harness Proxy

Instalación y quick start

LFM2.5-2.6B está disponible en Hugging Face en múltiples formatos: nativo (Transformers), GGUF (llama.cpp), MLX (Apple Silicon), ONNX (cross-platform).

Opción 1: Transformers (Python, GPU o CPU)

# Instalar dependencias
pip install "transformers>=5.2.0" torch accelerate

# Descargar y correr
python -c "
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = 'LiquidAI/LFM2.5-2.6B'

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map='auto',
    dtype='bfloat16',
)

tokenizer = AutoTokenizer.from_pretrained(model_id)

inputs = tokenizer.apply_chat_template(
    [{'role': 'user', 'content': 'What is machine learning?'}],
    add_generation_prompt=True,
    return_tensors='pt',
    tokenize=True,
    return_dict=True,
).to(model.device)

output = model.generate(**inputs,
    temperature=0.2,
    top_k=80,
    repetition_penalty=1.05,
    max_new_tokens=512,
)

input_length = inputs['input_ids'].shape[1]
response = tokenizer.decode(output[0][input_length:], skip_special_tokens=True)
print(response)
"

Opción 2: llama.cpp (CPU, edge, sin GPU)

# Instalar llama.cpp
brew install llama.cpp

# Correr interactivo (descarga automática desde HuggingFace)
llama-cli -hf LiquidAI/LFM2.5-2.6B-GGUF -c 4096 --color -i \
  --temp 0.1 --top-k 50 --repeat-penalty 1.05

# O servir como API OpenAI-compatible
llama-server -hf LiquidAI/LFM2.5-2.6B-GGUF -c 4096 --port 8080

El flag -hf descarga el modelo directamente desde Hugging Face. Para otros métodos de instalación (Windows, Linux), ver llama.cpp releases.

Opción 3: MLX (Apple Silicon optimizado)

# Instalar MLX
pip install mlx-lm

# Servir el modelo
mlx_lm.server --model LiquidAI/LFM2.5-2.6B-MLX --port 8080

# O usar directamente en Python
python -c "
from mlx_lm import load, generate

model, tokenizer = load('LiquidAI/LFM2.5-2.6B-MLX')
response = generate(model, tokenizer, prompt='What is AI?', max_tokens=512)
print(response)
"

Opción 4: vLLM (GPU serving, producción)

# Instalar vLLM
uv venv && source .venv/bin/activate
uv pip install -U vllm --torch-backend auto

# Servir el modelo (OpenAI-compatible)
vllm serve LiquidAI/LFM2.5-2.6B --max-model-len 131072

# Con tool calling habilitado
vllm serve LiquidAI/LFM2.5-2.6B \
  --enable-auto-tool-choice \
  --tool-call-parser lfm2 \
  --max-model-len 131072

Query con OpenAI SDK:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

response = client.chat.completions.create(
    model="LiquidAI/LFM2.5-2.6B",
    messages=[{"role": "user", "content": "What is machine learning?"}],
    temperature=0.3,
)

print(response.choices[0].message.content)

Opción 5: SGLang (GPU serving, alto throughput)

# Instalar SGLang
uv pip install "sglang>=0.5.10"

# Lanzar servidor
sglang serve \
  --model-path LiquidAI/LFM2.5-2.6B \
  --host 0.0.0.0 \
  --port 30000 \
  --tool-call-parser lfm2

# Query (OpenAI-compatible)
python -c "
from openai import OpenAI

client = OpenAI(base_url='http://localhost:30000/v1', api_key='None')

response = client.chat.completions.create(
    model='LiquidAI/LFM2.5-2.6B',
    messages=[{'role': 'user', 'content': 'What is machine learning?'}],
    temperature=0.3,
)

print(response.choices[0].message.content)
"

Opción 6: LM Studio (desktop, sin código)

Descargar LM Studio, buscar "LFM2.5-2.6B" en el modelo browser y correrlo con un click. Soporta GGUF nativamente.

Opción 7: Ollama

# Pull del modelo
ollama pull LiquidAI/LFM2.5-2.6B

# Correr
ollama run LiquidAI/LFM2.5-2.6B "What is machine learning?"

Configurar un agente local con LFM2.5-2.6B

Solo dos pasos: servir el modelo detrás de un endpoint OpenAI-compatible y apuntar tu agent harness hacia él.

Paso 1: Servir el modelo

# Con llama.cpp
llama-server -hf LiquidAI/LFM2.5-2.6B-GGUF -c 131072 --port 8080

# O con vLLM
vllm serve LiquidAI/LFM2.5-2.6B --enable-auto-tool-choice --tool-call-parser lfm2 --port 8000

Paso 2: Conectar tu agent harness

LFM2.5-2.6B funciona out-of-the-box con:

Hermes Agent
OpenClaw
Pi
Cualquier harness que soporte OpenAI-compatible endpoints

Configura el base_url del harness a http://localhost:8080/v1 (o el puerto que elegiste) y el model a LiquidAI/LFM2.5-2.6B.

Ejemplo: agente con tool calling en Python

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8080/v1", api_key="none")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="LiquidAI/LFM2.5-2.6B",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    temperature=0.2,
)

# El modelo decide llamar a get_weather
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    for call in tool_calls:
        args = json.loads(call.function.arguments)
        print(f"Calling {call.function.name}({args})")
        # Ejecutar tu tool...

LFM2.5-8B-A1B: el modelo de reasoning

Si necesitás más capacidad de razonamiento y podés permitirte 8.3B parámetros (1.5B activos en MoE):

Propiedad	Valor
Parámetros totales	8.3B (MoE)
Parámetros activos	1.5B
Context window	128K tokens
Reasoning	Sí
Tool calling	Sí
Structured outputs	Sí
Release	Mayo 2026

# Con vLLM
vllm serve LiquidAI/LFM2.5-8B-A1B \
  --enable-auto-tool-choice \
  --tool-call-parser lfm2 \
  --max-model-len 131072

Licencia y pricing

Aspecto	Detalle
Licencia	LFM Open License v1.0
Uso comercial	Gratis hasta $10M ARR
Download	Gratis en Hugging Face
Fine-tuning	Permitido (TRL, LEAP Finetune, Unsloth)
Deploy comercial	Permitido bajo $10M ARR
>$10M ARR	Requiere acuerdo comercial con Liquid AI
API hosted	No — solo self-hosted (no hay inference providers)
Playground	playground.liquid.ai (gratis)

Costo real: $0 por token. El modelo corre en tu hardware. No hay API bill. No hay cloud. Si tenés una Mac, un PC con GPU o incluso un teléfono, tenés un agente IA funcional sin costo recurrente.

Formatos disponibles

Formato	Mejor para	Runtime
Nativo (Transformers)	Fine-tuning, acceso a internals	Transformers, vLLM, SGLang
GGUF	CPU/GPU local, cualquier plataforma	llama.cpp, LM Studio, Ollama
MLX	Apple Silicon optimizado	MLX framework
ONNX	Cross-platform, hardware diverso	ONNX Runtime

Comparación con alternativas

Feature	LFM2.5-2.6B	DeepSeek V4 Flash	Claude Fable 5	GPT-5.6 Sol
Parámetros	2.6B (dense)	284B / 13B active (MoE)	Cerrado	Cerrado
Context	128K	1M	200K+	200K+
On-device	✅ (teléfono, laptop)	Parcial (167GB weights)	❌ (cloud only)	❌ (cloud only)
Costo/token	$0 (self-hosted)	$0.14/$0.28 per 1M	$10/$50 per 1M	$5/$30 per 1M
Tool calling	✅ Nativo	✅	✅	✅
Open weights	✅	✅ (MIT)	❌	❌
Privacidad	Total (local)	Parcial (RPC law)	Cloud	Cloud
Reasoning	Bueno	Alto	Frontier	Frontier
Coding	Moderado	Alto	Frontier	Frontier
Velocidad CPU	220 tok/s (M5 Max)	N/A	N/A	N/A

Casos de uso

1. Agentes locales privados

Correr un agente que planifica, llama tools y ejecuta multi-step tasks en tu laptop o teléfono, sin que ningún dato salga del dispositivo. Ideal para tareas con datos sensibles: análisis de archivos privados, automation personal, research confidencial.

2. Agentes masivamente paralelos

Cuando el costo marginal es cero, podés correr millones de tokens en background tasks sin cloud bill. Agentes que monitorean, procesan datos, clasifican contenido o ejecutan workflows 24/7 en hardware local.

3. Edge IoT y robots

LFM2.5-230M corre en Raspberry Pi. LFM2.5-2.6B corre en un teléfono. Esto habilita agentes IA en dispositivos con restricciones de conectividad, latencia o privacidad: robots industriales, dispositivos médicos, vehículos.

4. RAG local

Usar LFM2.5-Embedding-350M + LFM2.5-2.6B para un pipeline RAG completo que corre 100% local. Sin enviar documentos a un cloud API. Ideal para empresas con políticas estrictas de datos.

5. Fine-tuning para dominios específicos

Los weights son abiertos y fine-tuneable con TRL, LEAP Finetune y Unsloth. Podés especializar el modelo para tu dominio sin pagar por API training.

6. Voice agents on-device

LFM2.5-Audio-1.5B permite TTS, ASR y voice chat completamente local. Combinado con LFM2.5-2.6B para reasoning, tenés un voice agent que no necesita internet.

Limitaciones honestas

Coding: los modelos más grandes (Qwen3.5-9B, y especialmente modelos frontier como Claude/ChatGPT) siguen siendo significativamente mejores en coding
Reasoning complejo: para tareas que requieren reasoning profundo (math avanzado, investigación científica), modelos frontier siguen siendo superiores
No hay API hosted: solo self-hosted. Si no querés manejar infra, necesitás un cloud provider que hostee LFM (actualmente ninguno lo hace)
Licencia condicional: gratis hasta $10M ARR, después requiere acuerdo comercial
Ecosistema joven: menos integraciones y community tooling que modelos más populares (Llama, Qwen)
Tool calling en BFCLv4: pierde contra Qwen3.5-9B (60.13 vs 56.88), aunque gana en ToolSandbox

Conclusión

LFM2.5-2.6B es el caso más claro de la tendencia "small models are getting good enough". Un modelo de 2.6B que cabe en 2.5 GB, corre a 220 tok/s en CPU de Apple, y supera a Qwen 9B en tool use cambia las matemáticas de los agentes IA.

Cuando el costo marginal es cero, los agentes pueden correr everywhere, all the time, sin cloud bill. La privacidad es total porque el loop completo —planning, tool calls, execution— vive en tu dispositivo. Y el modelo es open-weight, fine-tuneable y deployable comercialmente gratis hasta $10M.

Para devs que necesitan agentes en edge devices, workflows privados o automation masiva sin costo por token, LFM2.5-2.6B es la opción más pragmática de 2026. No reemplaza a Claude o GPT para razonamiento frontier, pero para tool execution confiable on-device, es best-in-class.

La familia completa —desde 230M para Raspberry Pi hasta 8B-A1B MoE para reasoning— cubre un rango de deployment que ningún otro lab ofrece con una sola arquitectura. Liquid AI está construyendo el stack de IA edge-native que el mercado necesitaba.

Liquid AI LFM 2.5: la familia de modelos edge-native que corre agentes IA en tu teléfono a costo cero