Agentes de IA locales: agentes mínimos, OpenClaw, Hermes, Qwen-Agent

Módulo: 13. Práctica profesional | Tiempo: ~35 min de teoría + 30 min de práctica

Lo esencial

Claude Code es como la electricidad de la red. Pagas una suscripción y tienes luz (precios y versiones vigentes: Lo vigente). Es cómodo y confiable, pero el cable solo es tuyo mientras la cuenta esté pagada y haya internet.

Para octubre de 2026 hay muchos frameworks maduros que permiten correr sistemas de agentes completamente en tu propia computadora. Sin API. Sin internet. Con tool use, memoria, servidores MCP y colaboración entre varios agentes.

La lección Modelos de IA locales: Ollama, LM Studio e IA privada habló de los modelos locales básicos (Ollama, LM Studio): esos eran los "focos". Esta lección trata de la "planta de energía" completa: cuando el modelo + un framework de agentes + herramientas trabajan juntos y resuelven tareas reales sin mandar un solo byte hacia afuera.

Vamos a revisar 8 frameworks clave, ejemplos de modelos para tareas de agentes, los requisitos de hardware, y haremos un balance honesto: dónde gana lo local y dónde pierde frente a la API.

🎨 Imagínalo así: la Claude API es la electricidad de la red de la ciudad. Pagas cada kWh, todo es estable, pero dependes de la compañía. Los agentes locales son paneles solares en el techo. Los instalas una vez y luego generas tú mismo. Alcanzan para las necesidades de la casa (90% de las tareas). Pero si vas a encender una máquina industrial (el nivel de los modelos más potentes de la nube), te conectas a la red de la ciudad. No es "o uno o el otro", es "los dos, para tareas distintas".

🎯 Árbol de decisión: cuándo lo local es mejor que la API

La pregunta principal no es "qué es más impresionante", sino "qué le sirve a tu tarea":

→ ¿Producción B2B con SLA, soporte y garantías de disponibilidad?
   → API (Anthropic/OpenAI). Lo local no es para esto.

→ ¿Trabajas con datos confidenciales (medicina, derecho, código corporativo)?
   → LOCAL, sin duda. Los abogados y los médicos no mandan los datos de sus clientes hacia afuera.

→ ¿Automatización personal sin internet (bot casero, notas, traducciones)?
   → LOCAL. No tiene sentido pagar por tareas privadas.

→ ¿Proyectos de hobby y experimentos?
   → LOCAL. Gratis y sin límites.

→ ¿Mucho volumen + tareas simples (clasificar, traducir miles de registros)?
   → LOCAL sale más barato. La API se come el presupuesto rápido.

→ ¿Razonamiento complejo, ADR, decisiones de arquitectura, código complejo?
   → API (modelos potentes en la nube). Lo local todavía no llega.

→ ¿Vives en un país donde el acceso a las APIs de IA está limitado (revisa la lista de países soportados de Anthropic y OpenAI)?
   → LOCAL = independencia. Nadie te lo apaga.

→ ¿No estás seguro de si necesitas el máximo rendimiento o el máximo ahorro?
   → Híbrido. Local para la rutina, API para lo complejo.

🎨 Imagínalo así: no elijas entre la bici y el auto: ten los dos. A la tienda vas en bici (local); a otra ciudad, en auto (API). La mayoría de quienes construyen con IA usan un stack mixto.

Conceptos clave

• Local agent framework: software que convierte un modelo local (Llama, Qwen, Mistral) en un agente completo con herramientas, memoria y planeación
• Function calling: la capacidad del modelo de no solo responder con texto, sino de llamar herramientas con los argumentos correctos. Es la capacidad básica de los modelos para agentes
• MCP (Model Context Protocol): un protocolo abierto para conectar herramientas a los modelos. Nació en Anthropic y ahora lo soportan los frameworks locales
• Inference backend: el motor que ejecuta el modelo: Ollama (sencillo), vLLM (rápido, producción), SGLang (máximo throughput), llama.cpp (mínimo de dependencias)
• Quantization: comprimir el modelo para correrlo en hardware más modesto. Q4_K_M permite correr un 70B en 40GB en lugar de 140GB
• Open weights: el modelo se publica con sus pesos (puedes descargarlo y ejecutarlo). No confundir con open source (el código de entrenamiento abierto)
• Tool-native model: un modelo entrenado para llamar funciones desde el principio. Las familias actuales (Qwen3, gpt-oss, Hermes 4) son tool-native. Los modelos base viejos sin un fine-tune especial, a menudo no
• Hybrid stack: una combinación de local + API: la rutina en local, lo complejo por API
• MoE (Mixture of Experts): una arquitectura en la que, de todos los parámetros, solo una parte está activa en cada solicitud. Ejemplo: DeepSeek-V3 tiene 671B parámetros y 37B activos; Qwen3-Coder 30B activa unos 3.3B. Calidad de modelo grande, velocidad de modelo mediano

Teoría

Cuándo los agentes locales son mejores que la API

Lo local no reemplaza a la API. Es otra herramienta con otra economía. Hay tres situaciones donde lo local realmente gana:

1. Privacidad y soberanía. Expedientes médicos, código corporativo, notas personales: datos que no deben salir de tu computadora. Las condiciones de entrenamiento con datos son distintas en la API y en las suscripciones, y los abogados del cliente igual pueden decir "no". Lo local resuelve el tema desde la arquitectura: los datos físicamente no salen.

2. Costo con mucho volumen. Si tienes decenas de miles de tareas de clasificación de texto al mes, la factura de la API crece con el volumen, mientras que un modelo local de 7–14B solo cuesta la electricidad. Haz la cuenta con tus volúmenes: los precios de los tokens están en Lo vigente.

3. Independencia. Sanciones, cortes, cambios de políticas. Para quienes viven en países que no están en la lista de países soportados de Anthropic y OpenAI, el acceso a sus APIs está limitado, y no es un riesgo hipotético. Lo local funciona siempre.

Cuándo pierde lo local: razonamiento complejo (los modelos más potentes de la nube), multimodal de alto nivel, contexto largo (cientos de miles de tokens o más), las funciones más nuevas (control de la computadora, voz). Aquí los modelos de la nube suelen ir adelante.

🎨 Imagínalo así: lo local es tu huerto. Los jitomates son frescos, gratis y tuyos. Pero mangos no vas a cosechar ahí: por mangos vas al súper (la API).

Requisitos de hardware: qué necesitas de verdad

El límite principal de la IA local es el hardware. El tamaño del modelo define la RAM/VRAM mínima:

Los precios del hardware varían mucho, por eso la tabla no tiene montos: compáralos con los vendedores antes de comprar. Los modelos concretos de tarjetas y chips cambian cada año; lo que importa es la cantidad de memoria.

Reglas importantes:

• Un modelo de 70B parámetros con cuantización Q4 necesita ~40GB de RAM/VRAM. Con 32GB corre lento (swap); con 16GB no arranca
• Ventaja de Mac: la memoria unificada. Un M2 Max de 64GB se comporta como 64GB de VRAM. En PC la RAM y la VRAM de la GPU van por separado
• Las GPU viejas (GTX 1080, RTX 2060) funcionan, pero lento. Para un agente en tiempo real necesitas una tarjeta de al menos 12 GB de memoria
• Electricidad: una tarjeta de video potente a carga completa consume de 300 a 450 W. Con 8 horas de trabajo al día, se nota en el recibo; haz la cuenta con tu tarifa

🎨 Imagínalo así: si quieres cocinar en casa en lugar de ir al restaurante, necesitas una estufa. Un quemador de gas sirve para la pasta. Una parrilla de inducción, para un buen corte. Una cocina profesional, para un banquete de 50 personas. Primero entiende tu menú y luego compra la cocina.

8 frameworks clave de agentes locales (a octubre de 2026)

Vamos en orden. Cada uno tiene su nicho.

Framework 1: nanoClaude, un agente mínimo para aprender

Qué es: implementaciones mínimas de un agente al estilo de Claude Code que caben en poco código. No es un solo proyecto sino todo un género: en GitHub hay varios proyectos independientes de la comunidad (por ejemplo, nanoclaude y nano-claude-code). La idea se parece a nanoGPT de Karpathy. No lo confundas con NanoClaw: ese es otro proyecto, una alternativa ligera a OpenClaw basada en contenedores.

Ideal para: aprender. Entender cómo funciona un agente por dentro, sin las capas de un framework.

Corre en: normalmente Python. Se conecta a un modelo en la nube o a uno local con Ollama (revisa el README de cada proyecto).

Costo: $0.

Estado: hecho por la comunidad, con calidad y soporte variables. No es para producción: es una herramienta de aprendizaje.

Fuente: https://github.com/karpathy/nanoGPT (la idea), https://github.com/CohleM/nanoclaude (un ejemplo de agente para aprender).

🎨 Imagínalo así: un juego de Lego. Lo armas tú y entiendes cada pieza. No sirve para vivir en él, sino para entender "cómo se construyen las casas".

Framework 2: OpenClaw, un agente personal de código abierto

Qué es: un agente personal de IA de código abierto y autoalojado (licencia MIT). Vive en tu computadora, habla contigo por mensajería (WhatsApp, Telegram, Discord, Slack y otros), recuerda las conversaciones anteriores y puede trabajar con tu correo, calendario, navegador y archivos. Funciona con modelos de la nube (Claude, GPT) y con modelos locales. Lo lleva la organización sin fines de lucro OpenClaw Foundation; no hay versión de pago.

Ideal para: quien quiere un agente personal bajo su control y no quiere entregar sus datos a un servicio ajeno. Para trabajar con código son mejores Claude Code, Codex y los agentes de los IDE, no OpenClaw.

Corre en: Mac, Windows, Linux. Se instala con un script, con npm o con una app de escritorio. Backend: cualquier modelo, incluido uno local con Ollama.

Costo: $0 (código abierto); solo pagas el modelo de la nube que elijas, si usas uno.

Estado: en desarrollo activo; revisa la versión vigente en el sitio oficial.

Fuente: https://openclaw.ai y https://github.com/openclaw/openclaw.

🎨 Imagínalo así: un asistente personal que vive en tu casa. Le escribes por WhatsApp como a una persona, y él abre el correo, el calendario y los archivos de tu computadora. Control total, pero también responsabilidad: da los permisos de acceso con cuidado y al mínimo.

Framework 3: Hermes, de Nous Research: modelos y agente

Qué es: bajo el nombre Hermes, la empresa Nous Research publica dos cosas relacionadas. La primera: una familia de modelos Hermes con fine-tuning (la línea actual es Hermes 4), entrenados para function calling y tareas de agente. La segunda: Hermes Agent, un framework de agentes de código abierto (licencia MIT) con memoria permanente, trabajo por mensajería y delegación de tareas a subagentes. El agente se puede conectar a tu propio modelo o a Nous Portal.

Modelos: Hermes 4 en Hugging Face: 14B, 36B (versión 4.3), 70B y 405B (para el 405B necesitas una GPU de servidor).

Ideal para: function calling sin API, razonamiento de varios pasos sin conexión. Cuando necesitas un modelo que llame bien a las herramientas desde el principio.

Corre en: Ollama / vLLM / TGI. Cualquier framework que sepa trabajar con modelos de esa familia.

Costo: $0 (modelos y agente) + la electricidad.

Fuente: https://huggingface.co/NousResearch y https://hermes-agent.nousresearch.com.

🎨 Imagínalo así: un modelo base normal es un todólogo. Hermes es un modelo que tomó el curso de "cómo trabajar con herramientas". La diferencia es como entre un mesero nuevo y uno con experiencia: los dos toman la orden, pero uno olvida la mitad.

Framework 4: Qwen-Agent, el framework nativo de Alibaba

Qué es: un framework de agentes creado por el equipo de Qwen para sus modelos. Integración estrecha con los modelos Qwen (Qwen3 y posteriores). Soporta function calling, MCP, intérprete de código y RAG.

Modelos: Qwen3 (de 0.6B a 235B parámetros) y Qwen3-Coder (30B y 480B). Las generaciones más nuevas de Qwen, en la página del proyecto.

Ideal para: tareas de código complejas en local, workflows de varios pasos. Si la tarea es "escribe y prueba una función", Qwen3-Coder es de los primeros que conviene probar.

Especial: el framework tiene licencia Apache 2.0, y muchos modelos Qwen también tienen pesos abiertos y Apache 2.0: revisa la licencia de cada modelo.

Corre en: Ollama / SGLang / vLLM. Soporte nativo.

Costo: $0.

Fuente: https://github.com/QwenLM/Qwen-Agent.

🎨 Imagínalo así: un caballo de trabajo. No es el auto más bonito ni tiene los comerciales más vistosos. Pero funciona donde competidores más vistosos se atoran. Qwen es el caballo de trabajo de la IA de código abierto.

Framework 5: DeepSeek, un modelo de razonamiento sin conexión

Qué es: los modelos abiertos del laboratorio chino DeepSeek. DeepSeek-R1 (principios de 2025) fue uno de los primeros modelos de razonamiento con pesos abiertos. A octubre de 2026, la línea actual es DeepSeek V4: V4.1-Flash salió el 10.09.2026 y sus pesos están publicados en Hugging Face.

Modelos: V4.1-Flash es un modelo MoE grande; en hardware doméstico normal, por lo general, no corre: necesitas un servidor. Para hardware doméstico revisa las versiones destiladas y reducidas de R1 (7B, 14B, 32B, 70B) y modelos pequeños de otras familias.

Ideal para: razonamiento sin conexión. Problemas matemáticos, lógica de código compleja, planeación de varios pasos.

Especial: pesos abiertos. También hay una API de pago con precios bajos (precios vigentes: Lo vigente).

Costo: $0 (en local, si el hardware alcanza) o según la tarifa de la API.

Fuente: https://github.com/deepseek-ai.

🎨 Imagínalo así: un modelo de razonamiento es una calculadora que muestra el procedimiento. Antes estos modelos solo estaban tras una suscripción cerrada. DeepSeek dijo "aquí están los pesos, hagan lo que quieran".

Framework 6: Open WebUI + herramientas, un stack completo de ChatGPT local

Qué es: una interfaz web parecida a ChatGPT para modelos locales. Backend: Ollama. Soporta herramientas, RAG, búsqueda web con SearxNG (local), intérprete de código, voz (TTS/STT con Whisper) y conexión a servidores MCP.

Ideal para: una interfaz de chat en tu propia computadora. Cuando necesitas un "ChatGPT local" con funciones avanzadas.

Funciones: varios usuarios (la familia o el equipo), RAG (subes documentos y el modelo los ve), pipelines (lógica a la medida). Es uno de los proyectos más populares de este nicho. Revisa la licencia en el repositorio: incluye condiciones sobre conservar la marca.

Corre en: Docker (se levanta con un solo comando).

Costo: $0.

Fuente: https://github.com/open-webui/open-webui.

🎨 Imagínalo así: la interfaz de ChatGPT, pero todo corre en tu Mac. La familia la usa, los documentos no salen, y la factura de API es cero.

Framework 7: smolagents, el framework mínimo de HuggingFace

Qué es: un framework de agentes minimalista de HuggingFace. La idea principal: el agente escribe código en lugar de llamar herramientas mediante esquemas JSON. Menos sobrecarga, más capacidad.

Ideal para: experimentar, prototipar rápido, aprender. Cuando quieres entender "qué pasa si el agente escribe Python por su cuenta en lugar de usar un conjunto limitado de herramientas".

Corre en: cualquier modelo (local con Ollama / por API con proveedores).

Costo: $0 (el framework).

Fuente: https://github.com/huggingface/smolagents.

🎨 Imagínalo así: un cliente ligero. El framework no estorba y el modelo trabaja directo. Compáralo con CrewAI, que tiene muchas capas y configuración: smolagents deja el mínimo de código entre tú y el modelo.

Framework 8: AutoGen Studio + modelos locales

Qué es: AutoGen es un framework de Microsoft para la colaboración entre varios agentes. AutoGen Studio es una interfaz gráfica sobre él. Es compatible con modelos locales mediante una API compatible con OpenAI. Importante: a octubre de 2026 AutoGen está en modo de mantenimiento (maintenance mode), no tendrá funciones nuevas, y su sucesor es Microsoft Agent Framework. AutoGen Studio sirve para prototipos, no para producción.

Ideal para: colaboración entre varios agentes sin conexión. Cuando necesitas 3 o más agentes que "conversen" entre sí para resolver una tarea.

Corre en: Ollama / LM Studio / cualquier endpoint compatible con OpenAI. AutoGen Studio ofrece un constructor visual.

Costo: $0 (el framework).

Fuente: https://github.com/microsoft/autogen.

🎨 Imagínalo así: un equipo de especialistas trabajando en tu sótano sin internet. Arquitecto, programador, tester: cada uno es especialista, se comunican entre sí y resuelven la tarea.

Además (se mencionan seguido):

• Continue.dev: agente de IDE para VS Code y JetBrains. Funciona con modelos locales. Código abierto. Una alternativa para quien no quiere un editor SaaS
• LM Studio: interfaz gráfica para administrar modelos locales + funciones básicas de agente. Buena para principiantes
• Jan.ai: alternativa de código abierto a ChatGPT. Totalmente local. Interfaz sencilla
• CrewAI local: el CrewAI de siempre con backend de Ollama en lugar de OpenAI

Ejemplos de modelos locales para tareas de agente (a octubre de 2026)

Los modelos son el corazón de un agente local. Sin el modelo adecuado, hasta el mejor framework no sirve:

Los tamaños de descarga de Ollama se verificaron en las páginas de los modelos a octubre de 2026. Cómo elegir: no te creas porcentajes tipo "casi como Sonnet" de comparaciones ajenas. Corre tu propia tarea en dos o tres modelos (ver el Paso 5) y compara el resultado tú mismo. En tareas de arquitectura complejas, la distancia con los modelos potentes de la nube es mayor.

Elección práctica:

• Mac de 32GB → Qwen3 14B o gpt-oss 20B (caben con holgura)
• Mac de 64GB+ o tarjeta de video de 24GB → Qwen3 30B / Qwen3-Coder 30B / Qwen3 32B (el punto ideal entre calidad y velocidad)
• Mac Studio de 128GB+ o un servidor → gpt-oss 120B, Hermes 4 70B y modelos más grandes

Configuración paso a paso: arranque rápido en 30 minutos

Un stack completo de agente local se instala en una tarde:

# Paso 1: Instala Ollama (Mac/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Windows: descarga el instalador desde ollama.com

# Paso 2: Descarga un modelo (una sola vez, ~19GB)
ollama pull qwen3:30b

# Alternativas por tamaño:
# ollama pull qwen3:14b   # ~9GB, para 16GB de RAM
# ollama pull qwen3:8b    # ~5GB, lo mínimo
# Nombres y tamaños vigentes: ollama.com/library

# Paso 3: Instala Open WebUI con Docker
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

# Paso 4: Abre http://localhost:3000 — tu ChatGPT local está listo

Después de la configuración tienes:

• Una interfaz local tipo ChatGPT
• Un modelo que cubre buena parte de las tareas diarias (código, textos, traducciones). Revisa la calidad con tus propias tareas
• Tool calling (el modelo puede llamar funciones)
• RAG (subes un PDF y el modelo responde sobre su contenido)
• Privacidad total (ni un byte hacia afuera)

Casos reales: qué funciona de verdad en local

No es teoría: son patrones que ya funcionan:

Caso 1: un traductor con privacidad primero (abogado)

• Stack: Qwen3 14B + Open WebUI
• Uso: traducir documentos confidenciales de clientes ES↔︎EN↔︎PT
• Velocidad: depende del hardware; mídela en tu computadora
• Costo: sin pago por tokens después de la configuración inicial
• Por qué local: la confidencialidad del cliente descarta servicios externos como DeepL o la Claude API

Caso 2: revisión de código para un código propietario

• Stack: Qwen3-Coder + Continue.dev en VS Code
• Uso: revisión de código sin mandar el código propietario a la API de Anthropic
• Calidad: alcanza para revisiones estándar; las revisiones de arquitectura complejas es mejor dárselas a un modelo potente de la nube
• Costo: sin pago por tokens (necesitas una Mac de 64GB o una PC con tarjeta de video de 24GB)
• Por qué local: la propiedad intelectual de la empresa no sale y no se rompe el NDA

Caso 3: automatización personal (bot casero)

• Stack: un modelo pequeño (Qwen3 8B o Hermes 4 14B) + Open WebUI + herramientas a la medida
• Uso: casa inteligente (integración con Home Assistant), notas personales, recordatorios
• Privacidad: 100% sin conexión
• Hardware: una Mac compacta o una mini PC con 16GB de memoria (pago único)
• Costo: sin pago mensual

Caso 4: agente local para contenido (un canal en redes)

• Stack: Qwen3 14B + smolagents + RAG sobre tu bóveda local de Obsidian
• Uso: escribir posts con el estilo de tus notas y tus posts anteriores
• Costo: sin pago por tokens después de la configuración
• Compromiso: la calidad es menor que la de los modelos potentes de la nube. Para un canal personal, está bien
• Por qué local: tus borradores e ideas se quedan contigo

🎨 Imagínalo así: restaurante vs. cocina de casa. En el restaurante el chef cocina mejor, pero en casa cocinas cuantas veces quieras, con tu receta y sin cuenta que pagar.

Límites y concesiones, con honestidad

Sin lentes color de rosa. Donde lo local es realmente más débil:

Balance honesto a octubre de 2026: para la mayoría de las tareas profesionales, la API sigue ganando. Lo local es para casos de uso específicos (privacidad / costo / sin conexión / soberanía). Pero la distancia se acorta: los modelos abiertos de las últimas generaciones (Qwen3, gpt-oss, DeepSeek V4) cubren muchas tareas cotidianas. Los modelos más potentes de la nube siguen adelante en el razonamiento complejo y en las tareas largas.

🎨 Imagínalo así: lo local es un auto eléctrico de las primeras generaciones. Más barato de mantener, pero con menos autonomía y pocas estaciones de carga. Cada año se acerca más al de gasolina.

Costo de la configuración: único vs. recurrente

La pregunta más común: "¿cuándo se paga solo?"

Comparación con la API:

• Una suscripción a un asistente en la nube cuesta al año la suma de doce meses (precios vigentes: Lo vigente)
• Fórmula de recuperación: precio del hardware ÷ (factura mensual de API − electricidad). El hardware solo se paga con mucho volumen de tareas o cuando la privacidad es necesaria
• Lo local no reemplaza a la API al 100%. En la práctica se usa un esquema híbrido: local para la rutina, API para lo complejo
• Economía híbrida: lo local se queda con las tareas masivas y simples, y en el modelo de la nube solo pagas lo complejo

Antipatrones: qué NO hacer

Los tropiezos típicos de quien empieza:

❌ Usar modelos locales de 7B para producción B2B. La calidad no alcanza. El cliente lo va a notar. Para producción, modelos potentes de la nube, punto.

❌ Correr un modelo de 70B en 8GB de RAM. Se va a arrastrar con el swap. El mínimo para 70B es 40GB de memoria unificada o 48GB de VRAM.

❌ Ignorar el costo de la electricidad. Una GPU a carga completa muchas horas al día sube bastante el recibo. En algunos escenarios eso se come el ahorro frente a la API.

❌ Intentar replicar en local los modelos más potentes de la nube. La distancia es real. No fuerces el hardware.

❌ Saltarse la seguridad. Local ≠ más seguro automáticamente. Un modelo de un repositorio no verificado en Hugging Face puede traer código malicioso en sus scripts. Descarga de fuentes verificadas y no actives trust_remote_code sin leer el código.

❌ Una sola instancia local para todo el equipo sin manejo de colas. Cuello de botella. Si 5 personas mandan solicitudes al mismo tiempo, el modelo se traba. Necesitas un balanceador de carga (vLLM) o instancias separadas.

❌ Comparar local con API en una sola tarea y sacar conclusiones. Lo local gana en volumen y privacidad. La API gana en razonamiento complejo. Hay que comparar por caso de uso concreto.

Por nivel: qué le sirve a quién

Progresión por niveles:

Principiante (apenas empezando):

• Stack: Ollama + Qwen3 14B + Open WebUI
• Cobertura: buena parte de las tareas personales (traducciones, escribir/editar, investigación)
• Hardware: una computadora con 16GB de memoria

Intermedio (con algo de experiencia en código):

• Stack: + smolagents + Continue.dev en el IDE
• Cobertura: un flujo local tipo agente para desarrollar
• Hardware: Mac de 32GB o PC con tarjeta de video de 16GB

Profesional (constructor, agencia):

• Stack: + AutoGen o Microsoft Agent Framework / Hermes 4 70B + servidores MCP propios sin conexión
• Cobertura: un stack local multiagente completo para proyectos propietarios
• Hardware: Mac Studio de 64GB+ o PC con tarjeta de video de 24GB

Empresa (equipo):

• Stack: servidor vLLM + balanceador de carga + modelos con fine-tuning + autenticación
• Cobertura: una plataforma de IA interna para todo el equipo
• Hardware: un servidor dedicado con varias GPU profesionales

Tendencias: hacia dónde va la IA local

Lo que se vuelve posible cada 6 meses:

Más chico, más rápido. Lo que hace un par de años era la frontera, hoy corre en una laptop. Los modelos de una misma calidad son cada vez más pequeños.

Tool-native por defecto. Los modelos nuevos (Qwen3, gpt-oss) se entrenan con function calling de fábrica: los fine-tunes aparte como Hermes hacen falta con menos frecuencia.

Multimodal local. Los modelos locales ya trabajan con imágenes (por ejemplo, Qwen3-VL). El audio (Whisper local) es estándar. El video se está poniendo al día.

Razonamiento sin conexión. DeepSeek-R1 demostró que la capacidad de razonamiento es posible con pesos abiertos. Hoy gpt-oss, Qwen3 y DeepSeek tienen modos de razonamiento, y cada vez caben más en hardware de consumo.

IA en el celular. Los modelos pequeños (1–4B) ya corren en smartphones. El siguiente paso: agentes en el celular sin nube.

Estandarización de MCP. MCP se volvió el estándar para conectar herramientas. Los frameworks locales (Open WebUI, smolagents, Qwen-Agent) soportan servidores MCP: las mismas herramientas funcionan con la Claude API y con modelos locales.

🎨 Imagínalo así: la IA local es como la computadora personal en sus inicios. Cara, complicada, no para todos. Con el tiempo se volverá más sencilla y cercana, como pasó con la computadora y el smartphone.

Práctica

Paso 1: Instalar Ollama y el primer modelo

# Mac/Linux: un solo comando
curl -fsSL https://ollama.com/install.sh | sh

# Verifica la instalación
ollama --version
# Debe mostrar el número de versión

# Descarga Qwen3 14B (buen equilibrio para 32GB de RAM)
ollama pull qwen3:14b

# Si tienes menos memoria, empieza con 8B
ollama pull qwen3:8b

# Prueba el modelo
ollama run qwen3:14b "Hola, ¿cómo estás?"
# Debe responder en español

Paso 2: Probar function calling con Python

# test_function_calling.py — comprobamos que el modelo puede llamar herramientas
import ollama

# Describimos la herramienta como una función
def get_weather(city: str) -> str:
    """Devuelve el clima de una ciudad (de prueba)"""
    weather_db = {
        "Ciudad de México": "+16°C, nublado",
        "Cuenca": "+18°C, soleado",
        "ciudad_x": "+15°C, neblina"
    }
    return weather_db.get(city, "Sin datos")

# Descripción de la herramienta para el modelo
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtener el clima actual de la ciudad indicada",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nombre de la ciudad"
                }
            },
            "required": ["city"]
        }
    }
}]

# Enviamos la solicitud
response = ollama.chat(
    model='qwen3:14b',
    messages=[{
        'role': 'user',
        'content': '¿Cómo está el clima en Cuenca?'
    }],
    tools=tools
)

# Revisamos el resultado
print(response['message'])
# Debe incluir tool_calls con la llamada get_weather(city="Cuenca")

# Simulamos la ejecución de la herramienta
if response['message'].get('tool_calls'):
    for tool_call in response['message']['tool_calls']:
        if tool_call['function']['name'] == 'get_weather':
            city = tool_call['function']['arguments']['city']
            result = get_weather(city)
            print(f"Tool result: {result}")

Paso 3: Instalar Open WebUI con Docker

# Asegúrate de que Docker esté instalado
docker --version

# Levanta Open WebUI
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

# Espera ~30 segundos y luego abre
open http://localhost:3000

# La primera vez:
# 1. Crea una cuenta admin (local, no sale a ningún lado)
# 2. En Settings → Connections → Ollama debería detectarse solo
# 3. En Chat elige el modelo qwen3:14b
# 4. Empieza a conversar

Paso 4: Un agente local sencillo con smolagents

# local_agent.py — agente mínimo con smolagents y Ollama
from smolagents import CodeAgent, OpenAIModel, tool

# Conectamos Ollama mediante el endpoint compatible con OpenAI
# (en versiones viejas de smolagents esta clase se llamaba OpenAIServerModel)
model = OpenAIModel(
    model_id="qwen3:14b",
    api_base="http://localhost:11434/v1",
    api_key="ollama"  # Ollama ignora la clave, pero pide una cadena
)

# Creamos una herramienta propia
@tool
def calculate_compound_interest(principal: float, rate: float, years: int) -> float:
    """
    Calcular el interés compuesto.
    
    Args:
        principal: monto inicial
        rate: tasa anual (por ejemplo 0.05 para 5%)
        years: número de años
    """
    return principal * ((1 + rate) ** years)


@tool  
def read_file(path: str) -> str:
    """
    Leer un archivo del disco.
    
    Args:
        path: ruta al archivo
    """
    with open(path, 'r', encoding='utf-8') as f:
        return f.read()


# Creamos el agente
agent = CodeAgent(
    tools=[calculate_compound_interest, read_file],
    model=model,
    add_base_tools=True  # Agrega python_interpreter y otras
)

# Ejecutamos
result = agent.run(
    "Si deposito $1000 al 7% anual durante 10 años, "
    "¿cuánto tendré al final? Explica el cálculo."
)

print("\n" + "="*50)
print("RESULTADO:")
print("="*50)
print(result)

# Instalación
pip install smolagents

# Ejecución
python local_agent.py

# El agente debe:
# 1. Entender la tarea
# 2. Llamar a calculate_compound_interest(1000, 0.07, 10)
# 3. Obtener ~1967.15
# 4. Explicar el cálculo en español

Paso 5: Comparar local vs. API en tu propia tarea

# compare_local_vs_api.py — una comparación honesta en una misma tarea
import time
import ollama
from anthropic import Anthropic  # pip install anthropic

# Tu tarea: elige algo real
prompt = """Escribe una función en Python que:
1. Reciba una lista de números
2. Devuelva los 3 valores más grandes
3. Incluya type hints
4. Tenga un docstring con un ejemplo
5. Maneje casos límite (lista vacía, menos de 3 elementos)"""

# Opción 1: local con Ollama
print("=" * 50)
print("LOCAL: Qwen3 14B")
print("=" * 50)
start = time.time()
local_response = ollama.chat(
    model='qwen3:14b',
    messages=[{'role': 'user', 'content': prompt}]
)
local_time = time.time() - start
print(local_response['message']['content'])
print(f"\nTiempo: {local_time:.1f}s | Costo: $0")

# Opción 2: API de Anthropic
print("\n" + "=" * 50)
print("API: Claude Sonnet 5.5")
print("=" * 50)
client = Anthropic()  # Requiere ANTHROPIC_API_KEY en el entorno
start = time.time()
api_response = client.messages.create(
    model="claude-sonnet-5-5",  # identificadores de modelo vigentes: documentación de Anthropic
    max_tokens=1000,
    messages=[{"role": "user", "content": prompt}]
)
api_time = time.time() - start
input_tokens = api_response.usage.input_tokens
output_tokens = api_response.usage.output_tokens
# Precios por 1 millón de tokens: Sonnet 5.5, $2 de entrada y $10 de salida (a octubre de 2026).
# Precios vigentes: la página «Lo vigente» del sitio de la Academia
PRICE_IN, PRICE_OUT = 2, 10
cost = (input_tokens * PRICE_IN + output_tokens * PRICE_OUT) / 1_000_000
print("".join(b.text for b in api_response.content if b.type == "text"))
print(f"\nTiempo: {api_time:.1f}s | Costo: ${cost:.4f}")

# Resultados
print("\n" + "=" * 50)
print("COMPARACIÓN:")
print("=" * 50)
print(f"Local: {local_time:.1f}s, $0")
print(f"API:   {api_time:.1f}s, ${cost:.4f}")
print(f"\nCon 1000 tareas así al mes:")
print(f"Local: $0 + electricidad")
print(f"API:   ${cost * 1000:.2f}")

Qué te mostrará esta prueba:

• En tareas de código simples, lo local suele tener una calidad comparable
• La latencia local normalmente es mayor que la de la API
• Con mucho volumen de tareas, lo local empieza a ganar en lo económico (pon tu volumen en el cálculo)
• La calidad del código final la evalúas tú, leyendo las dos respuestas

Herramientas y recursos

• Ollama: el backend más sencillo para modelos locales. Mac/Linux/Windows
• Open WebUI: interfaz tipo ChatGPT para modelos locales
• Hermes (Nous Research): los modelos tool-native Hermes 4
• Hermes Agent: agente de código abierto de Nous Research
• OpenClaw: agente personal de código abierto en apps de mensajería
• Qwen Team: página principal de los modelos y frameworks de Qwen
• Qwen-Agent: framework de agentes para Qwen
• smolagents (HuggingFace): framework mínimo de agentes en Python
• DeepSeek: modelos DeepSeek con pesos abiertos
• AutoGen: framework de Microsoft para multiagentes (en mantenimiento; su sucesor es Microsoft Agent Framework)
• Continue.dev: agente de IDE de código abierto
• LM Studio: interfaz gráfica para administrar modelos locales
• Jan.ai: alternativa local de código abierto a ChatGPT
• vLLM: motor de inferencia de nivel producción
• SGLang: framework de inferencia de máximo throughput
• Karpathy nanoGPT: la base educativa de los nano-agentes
• Precios y versiones: Lo vigente

Conclusiones clave

Los agentes locales no reemplazan a la API: son otra herramienta con otra economía. Privacidad, costo con mucho volumen, trabajo sin conexión, independencia: cuatro razones por las que lo local realmente gana. Para todo lo demás, la API sigue adelante.

El hardware es el cuello de botella. Una computadora con 16–32GB de memoria corre un modelo de 8–14B y cubre muchas tareas personales. Una Mac Studio o una PC con tarjeta de video de 24GB+ son para trabajo serio con modelos de 30B o más. La electricidad también cuenta.

El camino realista es un stack híbrido. Local para la rutina (clasificación, traducciones, código simple, RAG sobre tus documentos personales), API para lo complejo (arquitectura, razonamiento complejo, multimodal). No elijas uno: combínalos.

Qué sigue

→ Self-hosted AI Enterprise Stack: vLLM, SGLang, Docker: cómo armar una plataforma de IA interna para tu equipo cuando una sola computadora ya no alcanza