Apple como 'perdedor de IA' que termina ganando: lo viví cuando Anthropic no me respondió un mes

87 milisegundos por token. Eso fue lo que medí corriendo Llama 3.2 en mi M3 Pro la primera vez que lo intenté en serio. Tuve que correr el benchmark dos veces porque pensé que había algo mal en la medición.

No es velocidad de servidor. No es lo que vas a ver en un benchmark de H100. Pero es suficiente para autocomplete, para análisis de código, para el 80% de las cosas que le pedía a Claude Code todos los días. Y corre en mi máquina. Con mis datos. Sin que nada salga a internet.

Eso cambió bastante cosas en cómo pienso el ecosistema de IA.

Apple, IA on-device y el moat que nadie vio venir

Hay un post que circuló en HN hace unas semanas sobre el "moat accidental" de Apple. El argumento es simple pero poderoso: Apple pasó la última década construyendo hardware especializado para inferencia (Neural Engine desde el A11 en 2017), construyendo APIs de privacidad que developers odian porque les complican el tracking, y construyendo la reputación de que "tu data no sale del dispositivo".

Nadie lo tomaba en serio como estrategia de IA. Era el "sí, pero los modelos de Apple son una basura comparados con GPT-4". Y en benchmarks de capacidad, es verdad. Apple Intelligence no le gana a Claude 3.5 Sonnet en razonamiento complejo.

Pero el problema está mal planteado. La pregunta no es "¿cuál modelo es más inteligente?". La pregunta que cada vez más empresas, reguladores y usuarios están haciendo es "¿dónde corren mis datos?"

Y ahí Apple tiene una respuesta que ningún hyperscaler puede dar de verdad: en tu hardware, punto.

El mes que Anthropic no me respondió y lo que aprendí

En marzo tuve un problema concreto con mi setup de Claude Code. No voy a entrar en todos los detalles técnicos, pero básicamente una integración que usaba para automatizar parte de mi workflow de code review dejó de funcionar con un cambio en la API. Mandé el ticket, abrí el issue, esperé.

Un mes. Nada.

No es que Anthropic sea una empresa horrible. Son una startup que está escaleando a velocidad de vértigo y el soporte técnico no escala igual que los modelos. Lo entiendo. Pero ese mes me obligó a algo que no hubiera hecho voluntariamente: buscar alternativas.

Primero moví todo a Zed con OpenRouter. Eso resolvió el problema de dependencia de proveedor. Pero mientras exploraba, me crucé con los benchmarks de agentes que estaban siendo cuestionados y empecé a preguntarme algo más profundo: ¿cuánto de lo que uso realmente necesita el modelo más grande y más caro del mercado?

La respuesta honesta: menos de lo que pensaba.

Qué corre bien en local hoy (números reales, M3 Pro, 18GB RAM)

Acá está lo que medí en mi máquina. No es marketing, son números con llama.cpp y ollama:

# Setup que uso actualmente
# ollama corriendo en background, modelos en ~/models

# Benchmark básico: tokens por segundo generación
ollama run llama3.2:3b "Explicá el patrón Repository en TypeScript" --verbose
# Resultado: ~95 tok/s — útil para autocompletado

ollama run llama3.2:11b "Revisá este código por vulnerabilidades de seguridad" --verbose  
# Resultado: ~42 tok/s — usable para análisis

ollama run codellama:13b "Refactorizá esta función" --verbose
# Resultado: ~38 tok/s — suficiente para sesiones de refactor

# Para contextos largos (lo que más duele en local)
ollama run llama3.1:8b --num-ctx 32768
# Resultado: ~29 tok/s con contexto largo — ahí sí se nota la diferencia

// Integración simple con Ollama en mi setup de Next.js
// para análisis de código en el editor

const analizarCodigo = async (codigo: string): Promise<string> => {
  // Todo corre local, nada sale a internet
  const respuesta = await fetch('http://localhost:11434/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'codellama:13b',
      prompt: `Revisá este código TypeScript y encontrá problemas:\n\n${codigo}`,
      // Sin streaming para análisis batch
      stream: false,
    }),
  });

  const data = await respuesta.json();
  return data.response;
};

// Uso en review automatizado de PRs
// Exactamente el tipo de cosa que casi mandaba a Claude Code
// y que ahora proceso localmente sin que el código del cliente
// salga nunca de mi máquina
const revisarPR = async (diff: string) => {
  // Para cosas sensibles: 100% local
  const analisisLocal = await analizarCodigo(diff);

  // Solo escalo a modelo externo para análisis arquitectural complejo
  // donde el razonamiento del modelo grande realmente importa
  if (requiereRazonamientoComplejo(analisisLocal)) {
    return await analizarConModeloExterno(diff);
  }

  return analisisLocal;
};

Este patrón — local primero, externo solo cuando vale la pena — es lo que cambió mi workflow. Y no es solo por privacidad. Es que para el code review de PRs con vibe coding el modelo local es suficiente para el 90% de los casos que necesito cubrir.

El ángulo de privacidad que los developers argentinos subestimamos

Acá hay algo que me parece importante y que no escucho mucho en la comunidad local.

Cuando trabajo con clientes, el código que escribo tiene contexto de negocio. Tiene nombres de tablas, lógica de negocio, a veces fragmentos de queries con estructura de datos sensible. Cada vez que le mandaba eso a Claude Code, ese código transitaba por servidores de Anthropic en EEUU.

Anthropic tiene políticas de privacidad. Las leí. Son razonables. Pero "razonables" no es lo mismo que "el código de mi cliente nunca sale de su infraestructura".

Mientras estaba explorando esto, recordé algo que escribí sobre la interfaz cerebro-computadora para controlar performances con ALS — en ese contexto hablé de que las interfaces más poderosas son las más transparentes para el usuario. El modelo que corre en tu hardware es la interfaz más transparente posible: sabés exactamente dónde está tu data.

Apple Private Cloud Compute (PCC) — el sistema que introdujeron con Apple Intelligence — lleva esto un paso más allá. Los modelos que necesitan más capacidad que la que corre on-device se procesan en servidores de Apple con garantías criptográficas de que ni siquiera Apple puede ver el contenido de tus requests. Publicaron el código fuente del cliente para que cualquiera pueda auditarlo.

Ningún otro proveedor de IA tiene esto. Ni Google, ni Microsoft, ni Anthropic. Es una ventaja competitiva real que tardó años en construirse y que no se puede copiar en 6 meses.

Los gotchas reales de ir on-device (no te lo voy a vender fácil)

Sería deshonesto si no cubriera esto.

El contexto largo es el talón de Aquiles. En local, con 18GB de unified memory, puedo correr un modelo de 13B con contexto de 32k tokens. Eso suena bien hasta que tenés un codebase grande y necesitás 100k tokens de contexto. Ahí la diferencia con Claude 3.5 Sonnet es abismal y no hay solución local hoy.

El razonamiento complejo no escala igual. Para debugging de problemas de concurrencia tipo deadlocks donde necesitás razonamiento multi-step profundo, Llama 3.2 11B no le llega a Claude 3.5 Sonnet. No es ni cerca. El modelo importa para cosas complejas.

El setup tiene fricción. Ollama hace el proceso mucho más simple de lo que era hace dos años, pero sigue siendo más fricción que pip install anthropic. Los modelos pesan entre 4GB y 30GB. Las primeras configuraciones de parámetros te van a decepcionar si no sabés qué estás haciendo.

Apple Intelligence tiene limitaciones reales. Las capacidades on-device de Apple son buenas para texto, resumen, reescritura. Para código son básicas. No reemplazan un modelo de coding especializado todavía.

Lo que cambió no es que los modelos locales sean mejores. Es que la ecuación ahora tiene más variables que "¿cuál responde mejor?"

La estrategia que Apple jugó sin que nadie le diera crédito

Hay algo elegante en lo que hizo Apple que solo se ve en retrospectiva.

Mientras OpenAI, Google y Anthropic competían en benchmarks de capacidad — parámetros, MMLU scores, reasoning benchmarks — Apple siguió construyendo el Neural Engine generación tras generación. No para ganar benchmarks de IA. Para hacer que Face ID, Siri (que todos se reían de Siri) y las fotos procesaran más rápido.

El resultado accidental: tienen el silicon más eficiente para inferencia del mercado de consumo. Los M3 y M4 tienen Neural Engine de 18 TOPs. El M4 Ultra tiene 38 TOPs de Neural Engine. Para modelos de hasta ~30B parámetros cuantizados, eso es competitivo con hardware dedicado de hace dos años.

Y construyeron una base de usuarios de 1.5 billones de dispositivos que ya confían en que Apple no vende sus datos. No porque Apple sea moralmente superior, sino porque su modelo de negocio no depende de la publicidad.

Eso es el moat. No se construyó en un año. Se construyó en una década de decisiones que parecían irracionales desde afuera.

Cuando pienso en esto me acuerdo de algo que leí sobre contribuciones al kernel de Linux: la infraestructura que parece aburrida y que nadie quiere mantener es la que eventualmente se vuelve estratégica. Apple construyó infraestructura de privacidad cuando no era cool hacerlo.

FAQ: Apple IA, privacidad y modelos locales

¿Apple Intelligence es suficiente para reemplazar Claude o GPT-4 en desarrollo?
No hoy. Apple Intelligence brilla en tareas de texto, resumen y reescritura. Para coding complejo, análisis arquitectural o razonamiento multi-step, los modelos de Anthropic y OpenAI siguen siendo superiores. La pregunta más honesta es: ¿cuántas de tus tareas diarias realmente necesitan el modelo más capaz?

¿Qué hardware necesito para correr modelos locales útiles para desarrollo?
Con 16GB de RAM (unificada en Apple Silicon) podés correr modelos de 8-13B que son útiles para el 70-80% de tareas de coding cotidianas. Con 32GB o más, modelos de 30B que compiten con GPT-3.5 en muchas tareas. El M3 Pro con 18GB es mi setup y funciona bien para workflow diario.

¿Qué es Apple Private Cloud Compute y por qué importa?
Es el sistema de Apple para procesar requests de IA que no pueden resolverse on-device. A diferencia de otros providers, Apple usa enclaves seguros con garantías criptográficas auditables: ni Apple puede ver el contenido de tus requests. Publicaron el código del cliente en GitHub para auditoría independiente. Ningún otro proveedor mainstream de IA tiene algo equivalente hoy.

¿Ollama es la mejor forma de correr modelos locales en Mac?
Ollama es la opción con menos fricción para empezar. Alternatives como LM Studio tienen mejor UI. llama.cpp directo te da más control sobre parámetros. Para un developer que quiere empezar sin demasiado setup, Ollama más algún cliente como Open WebUI o la integración con Zed/Continue es el camino más rápido.

¿La privacidad on-device realmente importa si el provider "promete" no entrenar con mis datos?
Depende de tu modelo de amenaza. Si trabajás con código de clientes, datos sensibles, o en industrias reguladas (fintech, salud, legal), las promesas contractuales no son lo mismo que la imposibilidad técnica de acceder a tus datos. On-device o PCC de Apple te da garantías técnicas, no solo contractuales. Para código de side projects personales, probablemente no importa.

¿Esto significa que Apple va a ganar la carrera de IA?
No en el sentido de "modelo más capaz". Probablemente nunca. Pero hay espacio para múltiples ganadores según qué problema resolvés. Apple puede ganar en el segmento de usuarios que priorizan privacidad, cumplimiento regulatorio y experiencia integrada sobre capacidad bruta del modelo. En Europa con el GDPR, en sectores regulados, en usuarios con datos sensibles — ese segmento no es pequeño.

El quilombo está resuelto, pero la estrategia cambió

Volviendo al punto de partida: el mes que Anthropic no me respondió fue incómodo. Pero me forzó a repensar qué corro dónde y por qué.

La conclusión a la que llegué no es "los modelos locales son mejores" ni "Apple ganó la IA". Es más matizada:

El modelo correcto depende del problema. La privacidad es una variable más en esa ecuación. Para el 70% de mis tareas diarias de coding, un modelo local de 13B en mi M3 Pro es suficiente y más privado. Para razonamiento complejo, arquitectura de sistemas, análisis de código que no es sensible — ahí todavía escalo a Claude.

Lo que cambió es que ya no tengo un único proveedor con un único modelo para todo. Tengo una estrategia donde el costo, la privacidad y la capacidad se balancean según cada tarea.

Apple construyó durante diez años algo que ahora tiene valor estratégico. No porque fueran brillantes en IA. Porque fueron consistentes en privacidad cuando no les daba puntos en los titulares.

A veces la estrategia ganadora es la que menos glamour tiene mientras la estás ejecutando.

¿Vos ya corrés algún modelo local en tu setup? ¿O todavía todo va a APIs externas? Me interesa saber qué balance encontraron otros developers.