Gemma 4 12B Unified: el nuevo modelo local multimodal de Google para agentes

Google acaba de ampliar la familia Gemma 4 con un lanzamiento especialmente interesante para desarrolladores: Gemma 4 12B Unified, un modelo open-weight multimodal pensado para correr localmente en laptops y servir como base para agentes con texto, imagen, audio y video.

La noticia no es solo que haya un modelo más en la familia Gemma. Lo importante es el enfoque: Google está empujando Gemma 4 12B como una pieza práctica para crear agentes locales, herramientas developer y experiencias multimodales sin depender siempre de una API cloud.

Qué es Gemma 4 12B Unified

Gemma 4 12B Unified es un modelo de Google DeepMind lanzado el 3 de junio de 2026. Forma parte de Gemma 4, la familia de modelos abiertos construidos a partir de investigación y tecnología relacionada con Gemini.

Según la documentación oficial, Gemma 4 es una familia de modelos multimodales con pesos abiertos, variantes pre-trained e instruction-tuned, licencia Apache 2.0, soporte para más de 140 idiomas y ventanas de contexto de hasta 256K tokens en modelos medianos/grandes.

La variante nueva, 12B Unified, se ubica en el punto medio: más capaz que los modelos edge pequeños, pero todavía lo suficientemente compacta para ejecutarse en hardware local razonable.

La diferencia: arquitectura multimodal encoder-free

El detalle técnico más llamativo es que Gemma 4 12B usa una arquitectura encoder-free para multimodalidad.

Muchos modelos multimodales tradicionales dependen de encoders separados para visión o audio. Eso puede funcionar muy bien, pero también agrega latencia, consumo de memoria y complejidad al fine-tuning.

Gemma 4 12B cambia ese enfoque:

• Para visión, usa un vision embedder pequeño que proyecta patches de imagen hacia el espacio del LLM.
• Para audio, proyecta directamente audio crudo de 16 kHz en frames de 40 ms.
• Texto, imagen y audio terminan entrando al mismo backbone decoder-only.

La consecuencia es una arquitectura más unificada para experimentar con agentes multimodales, análisis de video, audio understanding, coding y razonamiento.

Qué modalidades soporta

Gemma 4 como familia soporta:

• Texto
• Imagen
• Video
• Audio

En particular, Google documenta audio nativo en E2B, E4B y 12B. Eso hace que Gemma 4 12B sea especialmente interesante: es el primer modelo mediano de Gemma capaz de ingerir audio de forma nativa.

Esto abre casos como:

• Transcripción y análisis de audio.
• Comprensión de video con frames + audio.
• Agentes que razonan sobre contenido visual.
• Herramientas locales que procesan imágenes o clips sin subir datos a la nube.
• Workflows de coding asistido por un modelo local.

Tamaños de la familia Gemma 4

Google documenta cinco variantes principales:

Modelo	Enfoque
Gemma 4 E2B	Edge / ultra-mobile
Gemma 4 E4B	Edge más capaz
Gemma 4 12B Unified	Multimodal encoder-free para laptops
Gemma 4 26B A4B	Mixture-of-Experts eficiente
Gemma 4 31B Dense	Modelo denso más potente

También hay soporte de Multi-Token Prediction (MTP) para acelerar inferencia mediante speculative decoding.

Requisitos aproximados de memoria

La documentación de Google AI for Developers lista requisitos aproximados dependiendo de cuantización. Para Gemma 4 12B, las cifras orientativas son:

Precisión / cuantización	Memoria aproximada
FP16/BF16	~26.7 GB
8-bit	~13.4 GB
4-bit	~6.7 GB

Por eso Google lo presenta como viable en laptops con 16 GB de VRAM o memoria unificada, especialmente usando cuantización.

Cómo probar Gemma 4 12B localmente

Google menciona varias rutas para probarlo: LM Studio, Ollama, Google AI Edge Gallery, LiteRT-LM, Hugging Face, llama.cpp, MLX, SGLang, vLLM y Unsloth.

Opción 1: Ollama

Si tienes Ollama instalado, la ruta más simple debería ser:

ollama pull gemma4:12b
ollama run gemma4:12b

Prueba rápida:

ollama run gemma4:12b "Resume en español qué hace especial a Gemma 4 12B Unified para agentes locales."

Nota: el nombre exacto del tag puede variar según cómo Ollama publique la variante. Si falla, revisa la librería oficial de Ollama para Gemma 4.

Opción 2: LM Studio

1. Abre LM Studio.
2. Busca Gemma 4 12B.
3. Descarga una variante instruction-tuned cuantizada.
4. Cárgala en modo local server.
5. Usa el endpoint compatible con OpenAI desde tus apps.

Ejemplo con OpenAI-compatible local server:

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma-4-12b-it",
    "messages": [
      {"role": "system", "content": "Eres un asistente técnico conciso."},
      {"role": "user", "content": "Dame 5 ideas para usar Gemma 4 12B localmente."}
    ],
    "temperature": 0.7
  }'

Opción 3: LiteRT-LM

Google está empujando LiteRT-LM para experiencias locales y servidores compatibles con OpenAI.

Ejemplo tomado del flujo documentado por Google:

litert-lm import \
  --from-huggingface-repo=litert-community/gemma-4-12B-it-litert-lm \
  gemma-4-12B-it.litertlm \
  gemma4-12b

litert-lm serve

Luego puedes conectar herramientas compatibles con OpenAI apuntando al servidor local.

Opción 4: Hugging Face Transformers

Instala dependencias:

python -m venv .venv
source .venv/bin/activate
pip install -U transformers accelerate torch

Ejemplo base:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-4-12B-it"

tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {"role": "system", "content": "Eres un asistente técnico."},
    {"role": "user", "content": "Explica Gemma 4 12B Unified en 5 puntos."}
]

prompt = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tok(prompt, return_tensors="pt").to(model.device)

out = model.generate(**inputs, max_new_tokens=500, temperature=0.7)
print(tok.decode(out[0], skip_special_tokens=True))

Nota: confirma el nombre exacto del repo en Hugging Face, porque Google publica varias variantes y cuantizaciones.

Opción 5: llama.cpp / GGUF

Si usas llama.cpp, busca la colección GGUF de Gemma 4 y descarga una variante cuantizada.

Ejemplo genérico:

./llama-server \
  -m ./models/gemma-4-12b-it-q4_k_m.gguf \
  --ctx-size 32768 \
  --port 8080

Luego:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma-4-12b-it",
    "messages": [
      {"role": "user", "content": "Crea un plan para probar function calling con Gemma 4."}
    ]
  }'

Prompt formatting en Gemma 4

Google cambió/introdujo tokens de control específicos para Gemma 4. Si usas librerías como Transformers, lo ideal es usar el chat template del tokenizer en lugar de construir el prompt manualmente.

Para aplicaciones propias:

• Usa roles system, user, model cuando el runtime los soporte.
• Evita concatenar prompts manualmente si la librería ofrece template oficial.
• Mantén instrucciones de sistema separadas del input del usuario.
• En function calling, valida siempre cualquier salida antes de ejecutar código o herramientas.

Function calling y agentes

Gemma 4 está pensada para workflows agentic y function calling. Pero hay un punto importante: el modelo no ejecuta herramientas por sí solo. Genera la llamada o el código; tu aplicación debe validarlo y ejecutarlo de forma segura.

Ejemplo conceptual:

{
  "tool": "search_docs",
  "arguments": {
    "query": "Gemma 4 MTP speculative decoding"
  }
}

Buenas prácticas:

• Validar JSON/schema antes de ejecutar.
• Limitar herramientas disponibles.
• Registrar cada llamada.
• Usar allowlists para comandos o rutas.
• Nunca ejecutar código generado sin sandbox.

Casos de uso prácticos

Gemma 4 12B puede ser útil para:

• Asistentes locales con privacidad.
• Análisis de documentos e imágenes sin subir datos a un servidor externo.
• Prototipos de agentes con tool calling.
• Transcripción/análisis de audio local.
• Análisis de video frame-by-frame con audio.
• Coding assistants locales.
• RAG local con embeddings + Gemma para generación.
• Apps educativas o enterprise donde la data no debe salir del equipo.

Por qué importa

La carrera de modelos abiertos ya no se trata solo de “más parámetros”. Gemma 4 12B apunta a otra cosa: modelos suficientemente capaces, multimodales y ejecutables localmente.

Eso es importante para desarrolladores porque permite probar agentes, automatizaciones y experiencias IA sin depender por completo de APIs propietarias. También mejora privacidad, latencia y control de costos.

No reemplaza a los modelos frontier cloud para todos los casos, pero sí abre una opción muy atractiva para aplicaciones locales, edge y herramientas internas.

Próxima prueba local

Este lanzamiento queda especialmente interesante para probarlo en hardware real. Pronto intentaré ejecutarlo localmente para revisar rendimiento, consumo de memoria, calidad de respuestas, capacidades multimodales y qué tan práctico resulta para workflows agentic del día a día. Cuando tenga esa prueba, actualizaré la nota con mis impresiones y una guía más aterrizada según la experiencia real.

Fuentes oficiales

• Google AI for Developers: Gemma releases
• Google AI for Developers: Gemma 4 model overview
• Google AI for Developers: Gemma 4 model card
• Google Developers Blog: Gemma 4 12B: The Developer Guide
• Google DeepMind: Gemma 4