Me está encantando Gemma 4 🤩

Hay una sensación muy concreta que cambia cómo juzgas un modelo local.

Es el momento en el que piensas: me podría subir a un avión, seguir trabajando, y no echar de menos internet.

Eso es justo lo que me ha pasado estos días con Gemma 4 26B A4B corriendo en local en mi MacBook Pro M3 Max, servido con el setup más simple posible de LM Studio: activar server on y listo.

Y creo que ahí está la parte importante.

No en el benchmark. No en la demo bonita. No en la típica captura de “mira, también corre en mi portátil”.

Lo importante es que, por primera vez en bastante tiempo, un setup local me empieza a parecer una herramienta seria y no sólo una curiosidad técnica.

No me interesa “si corre”. Me interesa si sirve

La conversación sobre modelos locales muchas veces se queda en un punto bastante infantil.

• cuánta RAM consume,
• cuántos tokens por segundo da,
• si entra o no entra,
• y si alguien ha conseguido hacerlo funcionar con una configuración suficientemente exótica.

Todo eso está bien, pero no es la pregunta que más me importa.

La pregunta útil es otra:

¿Hay ya tareas reales que prefiero no mandar a una API de terceros y que, aun así, puedo resolver bien desde mi propia máquina?

Con Gemma 4, mi respuesta empieza a ser claramente que sí.

Y eso cambia bastante el criterio.

Qué estoy haciendo en local de verdad

No estoy hablando de prompts de escaparate.

Lo he estado usando para algo bastante más terrenal: traducción y clasificación de histórico de conversación de WhatsApp.

Y aquí la palabra importante no es “traducción” ni “clasificación”.

La palabra importante es histórico.

Porque en cuanto trabajas con conversaciones reales, aparecen varias cosas que hacen que lo local tenga muchísimo sentido:

• hay contexto personal,
• hay datos sensibles,
• hay información que no me apetece regalar a un tercero,
• y muchas veces el trabajo consiste más en procesar volumen con criterio que en pedir una respuesta brillante de una sola vez.

Para este tipo de tarea, hay algo especialmente satisfactorio en poder decir:

esto lo estoy resolviendo sólo con mis propios vatios.

No es sólo una cuestión romántica ni ideológica.

Es privacidad, sí. Pero también es control, coste marginal y soberanía operativa.

Si una tarea la puedo resolver bien dentro de mi máquina, cada vez me parece menos razonable asumir que tiene que salir fuera por defecto.

Lo interesante no es sólo el modelo. Es que ya aguanta flujos agentic útiles

La parte que más me interesaba probar no era si Gemma 4 respondía bien a preguntas sueltas.

Eso ya no me dice demasiado.

Lo que quería ver era si aguantaba un flujo un poco más serio. En mi caso, un pequeño harness con memoria y con acciones para decidir cuándo tenía sentido:

• analizar imágenes con su capacidad de visión,
• o llamar a tools de búsqueda en internet.

Y aquí creo que está una de las mejores señales de esta generación.

El tool calling funciona bastante bien.

No estoy diciendo que de repente haya dejado obsoletas a todas las APIs propietarias ni que esté al nivel de los mejores modelos hosted en cualquier situación. Eso sería una lectura bastante ingenua.

Lo que sí digo es esto:

ya no me parece una prueba simpática. Me parece suficientemente bueno como para meterlo en trabajo real.

Ese matiz importa mucho.

Porque entre “puede hacer una demo” y “me sirve en un flujo de trabajo” hay un salto enorme.

Y ese salto, para mí, es precisamente el que Gemma 4 empieza a cruzar en local.

LM Studio aquí importa más de lo que parece

También hay una lección práctica importante: la fricción del runtime cuenta muchísimo.

Parte de por qué esta prueba me parece relevante es que no he necesitado un ritual extraño para empezar.

No he montado un laboratorio. No he tenido que convertirme en operador full-time de mi propio stack local. No he necesitado una integración heroica.

He tirado de LM Studio con el enfoque más directo posible, exponiendo el modelo con server on, y a partir de ahí ya podía tratarlo como un backend razonable para mis flujos.

Eso reduce mucho la distancia entre “quiero probar algo” y “lo estoy usando de verdad”.

Y cuando la fricción baja, la adopción cambia.

Hay muchas tecnologías que no fracasan por falta de capacidad, sino porque exigen demasiado peaje operativo para empezar a sacarles valor. Aquí, al menos en esta configuración, no he sentido eso.

Gemma 4 importa. Pero TurboQuant también es parte de la historia

Cuando hablo de esto, no me interesa entrar en una discusión absurda sobre a quién hay que darle exactamente el mérito.

No creo que el punto sea decidir si todo esto es “por Gemma 4” o “por TurboQuant” o “por LM Studio” o por la combinación concreta de quantizaciones, runtimes y optimizaciones que hoy hacen posible esta experiencia.

De hecho, creo que la lectura útil es justo la contraria.

La lectura útil es que por fin se están alineando varias capas a la vez:

• un modelo suficientemente competente,
• arquitecturas pensadas para eficiencia real,
• cuantización y optimizaciones que dejan de ser una rareza,
• runtimes usables,
• y soporte razonable para tool calling, visión y contexto largo.

Ahí es donde TurboQuant me parece interesante.

No como paper bonito para comentar en X. Sino como parte de una tendencia mucho más relevante: la compresión y la eficiencia ya no son sólo un detalle técnico; son una condición para que lo local deje de ser anecdótico.

Cuando mejora la historia de memoria, contexto y rendimiento, cambia mucho menos de lo que parece una cosa muy importante: la disposición que tienes a meter estos modelos en flujos reales.

Y eso, al final, vale más que una comparativa más de leaderboard.

El momento “puedo trabajar en un avión” no es una anécdota

Para mí esta es la prueba mental más útil.

Si siento que podría estar en un avión trabajando con esto y no echar de menos conexión a internet, entonces ya no estoy delante de un juguete.

Estoy delante de una pieza de infraestructura personal.

Eso no significa que todo tenga que correr local.

Significa algo bastante más interesante: que la pregunta por defecto empieza a cambiar.

Antes la pregunta era:

• ¿qué API voy a llamar para resolver esto?

Ahora cada vez se parece más a esto:

• ¿de verdad necesito que esta tarea salga de mi máquina?

Ese cambio de pregunta es pequeño en apariencia, pero enorme en sus implicaciones.

Porque afecta a:

• privacidad,
• coste,
• latencia,
• dependencia de terceros,
• resiliencia offline,
• y diseño de producto.

Para producción on premise, esto ya me parece una conversación seria

Hay otra razón por la que este salto me importa: Gemma 4 está bajo Apache 2.0.

Y eso mueve bastante la conversación.

No estamos sólo ante “un modelo que mola tener en local”.

Estamos ante un modelo open source bajo Apache 2.0, con un encaje mucho más realista para despliegues on premise en producción.

Y ese punto me parece más importante de lo que parece.

Porque en muchos entornos el problema no es si un modelo hosted es mejor en abstracto.

El problema es otro:

• qué datos pueden salir,
• qué cumplimiento necesitas,
• cuánto vendor lock-in aceptas,
• qué coste operativo y económico toleras,
• y qué nivel de control quieres sobre tu propia infraestructura.

Si yo ya puedo hacer en un portátil tareas útiles de traducción, clasificación y routing agentic con tool calling razonable, la extrapolación hacia entornos on premise deja de sonar futurista.

No digo que el camino a producción sea trivial. No lo es.

Digo que ya me parece plausible sin necesidad de autoengañarse.

Y eso, en este espacio, ya es decir bastante.

Lo que no estoy diciendo

También conviene no leer esto con triunfalismo barato.

No estoy diciendo que vaya a sustituir cualquier API externa. No estoy diciendo que siempre vaya a ser la mejor opción. No estoy diciendo que ya no haya trade-offs en calidad, velocidad o ergonomía.

Sigue habiendo muchos casos donde un servicio hosted tiene todo el sentido del mundo:

• cuando necesitas throughput alto,
• cuando te importa exprimir el mejor rendimiento posible en cada tarea,
• cuando el coste de operación local compensa peor,
• o cuando quieres olvidarte por completo del runtime.

Pero una cosa no quita la otra.

El hecho de que no sea la respuesta universal no le resta importancia a lo que sí ha cambiado.

Y lo que sí ha cambiado, en mi caso, es muy simple:

ya hay trabajo útil que prefiero no enviar fuera, y ahora tengo una opción local que no se siente como un sacrificio absurdo.

Mi lectura, en una frase

No estoy especialmente contento porque “mi portátil pueda correr un LLM”.

Estoy contento porque Gemma 4 en local ya me cambia de verdad qué tareas merece la pena mandar a una API y cuáles no.

Si encima a eso le sumas una experiencia razonable con LM Studio, un harness pequeño con memoria, visión y tools, y una licencia Apache 2.0 que hace creíble pensar en on premise, entonces la conclusión para mí es bastante clara.

Lo local vuelve a ser serio.

Y cuando eso pasa, no sólo cambia tu setup.

Cambia también tu criterio arquitectónico.