Todas las que usamos Claude Code conocemos esa sensación. Abres una sesión nueva, lanzas tu consulta y observas cómo el agente empieza a divagar:

⏺ Explore(“¿Cómo se comunica el host de extensiones con el proceso principal?”)

⎿ Hecho (52 usos de herramientas · 89.4k tokens · 1m 37s)

Es agotador. Cada. Maldita. Vez.

Como Claude no tiene memoria de tu base de código, empieza a lanzar agentes de exploración que recorren todo mediante llamadas constantes de grep, glob y lectura de archivos. Cada pequeña llamada consume tokens y, lo que es peor, cada archivo escaneado reduce tu valiosa ventana de contexto.

Lo medí en uno de mis proyectos: 60 llamadas a herramientas y 157,800 tokens. Casi 2 minutos de espera antes de que Claude siquiera comenzara a trabajar en lo que realmente necesitaba. Y la parte más frustrante es que, al cerrar la sesión, todo ese conocimiento costoso se esfuma. ¿Abres otra? Empezamos desde cero. Es un "impuesto de exploración" que pagamos constantemente.

Las soluciones que se quedan a medias

No soy la única que ha notado esto, y la comunidad ha intentado poner parches:

• Archivos Markdown de memoria: Esas notas en CLAUDE.md con resúmenes y arquitectura. Ayudan un poco, pero Claude sigue sin entender las relaciones reales; solo está leyendo un documento estático.
• Subagentes con archivos compartidos: Sistemas elaborados donde los agentes actualizan archivos de memoria. Es mejor, pero sigue siendo un arreglo improvisado. Falta estructura.
• Relleno manual de contexto: Copiar y pegar código antes de preguntar. Funciona, sí, pero es tedioso y, seamos sinceras, no escala.

Nada de esto le da a Claude lo que realmente necesita: entender cómo está conectado tu código.

¿Y si los agentes de exploración tuvieran un mapa?

Esa es la idea detrás de CodeGraph. En lugar de escanear archivos a ciegas, los agentes consultan un grafo de código preconstruido que entiende perfectamente:

• Qué funciones llaman a cuáles.
• Qué clases heredan de qué otras.
• Dónde se implementan las interfaces.
• Cómo los imports conectan los archivos.
• Cuál es el radio de impacto real cuando tocas algo.

No es un resumen que la IA tenga que interpretar; es una base de datos estructurada a la que Claude puede preguntar directamente. Los agentes siguen trabajando, pero son infinitamente más eficientes. Las consultas al grafo son instantáneas, eliminando el escaneo archivo por archivo.

⏺ Explore(“¿Cómo se comunica el host de extensiones con el proceso principal?”)

⎿ Hecho (3 usos de herramientas · 56.6k tokens · 17s)

La clave es codegraph_explore, una sola herramienta que devuelve secciones completas del código fuente para cada símbolo relevante. Adiós a las 52 llamadas separadas; ahora, una sola consulta al grafo le da a la IA todo lo que necesita.

Datos reales: El impacto es innegable

Ejecuté el mismo prompt con y sin CodeGraph activado en toda la base de código de VSCode. El veredicto es claro: los agentes utilizan aproximadamente un 94% menos de llamadas a herramientas y son cerca de un 82% más rápidos. Esto se traduce en un ahorro directo de dinero, tokens y tiempo.

Configuración en 5 minutos

¿Te animas a probarlo? Solo necesitas Node.js 18+ y Claude Code. Ejecuta este comando:

npx @colbymchenry/codegraph

El instalador interactivo se encarga de todo: configura el servidor MCP en ~/.claude.json, ajusta los permisos y te pregunta si deseas inicializar tu proyecto. Luego, simplemente reinicia Claude Code y corre:

codegraph init -i

En unos 30 segundos, tendrás miles de archivos indexados, nodos mapeados y relaciones listas.

¿Cómo funciona la magia?

CodeGraph analiza tu base de código mediante tree-sitter y guarda todo en una base de datos SQLite local. Claude Code se conecta vía MCP y consulta este grafo cuando necesita entender algo. Además, usa un FileWatcher que monitorea cambios en tiempo real, resincronizando todo en menos de un segundo.

¿Qué ganas con esto?

• Construcción inteligente de contexto: Análisis más rápido y ahorro masivo de tokens.
• Análisis de impacto: Saber qué se puede romper antes de cambiar nada.
• Compatibilidad total: Funciona con más de 19 lenguajes (de TypeScript a Rust, Go, Python y más).
• Privacidad 100% local: Ningún dato sale de tu máquina. Sin claves API externas.
• Detección de tests afectados: Ejecuta solo lo necesario integrando git diff para tus procesos de CI.

Detalles técnicos para profundizar

CodeGraph extrae nodos (funciones, clases, métodos) y relaciones (llamadas, imports, herencias) usando una arquitectura robusta:

1. Motor de análisis: Tree-sitter para extraer ASTs.
2. Almacenamiento: SQLite local con búsqueda FTS5.

Herramientas MCP:

• codegraph_context: Para contexto completo.
• codegraph_search: Búsqueda rápida de símbolos.
• codegraph_callers / codegraph_callees: Para rastrear relaciones.
• codegraph_impact: Para calcular el efecto de tus cambios.

La resolución de referencias es fina: empareja llamadas, resuelve imports complejos y entiende patrones de frameworks, dándole a Claude una visión estructurada de tu trabajo.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

La excusa se acabó.Hoy, crear un chatbot dejó de ser un dolor de cabeza técnico. Se ha convertido, más bien, en un desafío de ejecución.

Porque, cuando descubres la combinación correcta de herramientas, pasar de cero a un bot funcional es cuestión de minutos, sin necesidad de escribir ni una sola línea de código. No hace falta el modelo más caro ni el más veloz; lo que realmente marca la diferencia es saber cómo conectar las piezas con elegancia.

El sistema: Skill + MCP

La clave reside en una dupla muy concreta:

• Una skill instalada en BuilderBot Cloud.
• Un MCP (Model Context Protocol) conectado de forma impecable.

Esta sinergia te permite orquestar todo el proceso con fluidez: extrae información de tu negocio, diseña flujos inteligentes, configura respuestas y prepara todo para salir a producción.

Paso a paso: Tu proceso de creación

Paso 1: Instala la skillEl inicio es sumamente sencillo: accede al enlace, cárgalo en tu entorno y verifica que ya forme parte de tu panel de habilidades. Nota: Aunque al principio sugerimos usar un modelo potente para esta configuración inicial, después podrás operar con total ligereza usando modelos más eficientes.

Paso 2: Conecta el MCPAquí es donde das vida a la conexión. Dirígete a la sección de conectores, crea uno nuevo, añade la URL del MCP y enlaza usando tu API Key de BuilderBot. Es un paso pequeño, pero esencial para que el sistema empiece a ejecutar acciones complejas por ti.

Paso 3: Genera tu chatbot automáticamenteEste es el momento de ver la magia ocurrir. Con una sola instrucción, el sistema analiza tu negocio, extrae los datos que realmente importan, diseña la estructura y configura el asistente. Todo sucede en menos de tres minutos, sin necesidad de intervención manual.

Paso 4: Publica en WhatsAppYa casi estás. Solo accede a la sección de publicación, escanea el código QR desde tu WhatsApp Business y activa el bot. En ese instante, ya estás lista para interactuar con usuarios reales.

Resultados reales

Olvídate del código, de las configuraciones tediosas y de construir flujos desde cero. El sistema genera respuestas coherentes, naturales y totalmente alineadas con la esencia de tu negocio.

Lo importante no es la IA, es el sistema

Cometemos el error de pensar que todo depende de la capacidad del modelo, pero la realidad es otra:

• No gana el más inteligente.
• No gana el más caro.
• Gana quien mejor sabe integrar.

Cuando logras esa conexión perfecta, reduces tiempos, ganas agilidad y, sobre todo, escalas tu negocio sin fricción.

Conclusión

Hoy tienes el poder de construir un chatbot funcional en minutos. No necesitas un gran equipo técnico, ni meses de desarrollo, ni presupuestos desorbitados. Solo necesitas comprender el flujo, ejecutar y probar.

Porque el problema ya no es la tecnología. El problema o la gran oportunidad, es simplemente si decides aprovecharla o no.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

La oferta de trabajo más honesta en la historia de la tecnología podría ser también la más reveladora sobre dónde está realmente la industria.

Una oferta de empleo que recientemente circuló merece mucha más atención de la que recibió.

Anthropic, la empresa cuyo CEO afirmó públicamente que la IA reemplazará a los ingenieros de software en 6–12 meses, publicó un puesto de Software Engineer con una compensación total de $570,000. Base de $300K. Equity de $220K. Bono de firma de $50K.

Imagen generada por IA

Escondido al final de la oferta, en una nota marcada en rojo que internet no paraba de capturar:

“Nota: Este puesto puede no existir en 12 meses.”

Detente un momento en eso.

Una empresa lo suficientemente confiada en la trayectoria de la IA como para decirlo públicamente. No lo suficientemente confiada como para dejar de contratar ingenieros por medio millón al año.

Esa tensión no es hipocresía. Es, de hecho, la señal más clara de dónde está realmente el mercado.

Lo que te dicen los datos de contratación

Si eliminas los titulares y observas lo que realmente ocurre en la capa de infraestructura de las empresas de IA:

Lo que dicen los CEOs públicamente:

• "La IA reemplazará a los ingenieros de software"
• "Estamos construyendo agentes de código autónomos"
• "Este puesto puede no existir en 12 meses"

↓

Lo que las empresas realmente están haciendo:

• Contratando ingenieros L5/L6 por $500K+
• Ampliando equipos de infraestructura
• Compitiendo agresivamente por talento senior

↓

Conclusión:
La narrativa y la asignación de recursos apuntan en direcciones opuestas.

Esto no es exclusivo de Anthropic. En toda la industria, las empresas que más están construyendo IA son también las que mejor pagan a los ingenieros. No es coincidencia, es un dato.

El colapso de dos vías (y qué es lo que realmente está colapsando)

Sí hay una historia real sobre desplazamiento laboral. Pero es más específica de lo que sugieren los titulares.

Espectro de roles en ingeniería:

[Ejecutor de tareas] ──────────────► [Resolutor de problemas]
|                                             |
Escribe código repetitivo               Diseña sistemas
Sigue especificaciones                   Toma decisiones
QA manual                                 Depura fallos complejos
Reportes repetitivos                    Decide qué construir
|                                             |
v                                             v
ALTO RIESGO DE DESPLAZAMIENTO      BAJO RIESGO DE DESPLAZAMIENTO
(disminuyendo, no desapareciendo)     (se sigue contratando y pagando)

Los roles que están siendo presionados:

• Puestos junior basados en generar código rutinario
• Roles de QA puramente manuales
• Analistas junior que solo formateaban datos y hacían reportes

No han desaparecido. Pero hay menos puestos, el nivel ha subido y el volumen se está reduciendo.

Los ingenieros senior —los que diseñan sistemas desde requisitos ambiguos, toman decisiones estratégicas y entregan productos reales en producción— siguen siendo escasos y altamente demandados.

Por qué “reemplazar ingenieros” es el marco equivocado

Así es como se ve hoy un flujo de trabajo con IA:

┌──────────────────────────────────────────────┐
│        Ciclo de desarrollo de funcionalidades │
│                                              │
│  Ingeniero define requisitos                 │
│         │                                    │
│         ▼                                    │
│  IA genera código base                       │
│         │                                    │
│         ▼                                    │
│  Ingeniero revisa y refactoriza              │
│         │                                    │
│         ▼                                    │
│  IA sugiere tests y edge cases               │
│         │                                    │
│         ▼                                    │
│  Ingeniero toma decisiones de arquitectura   │
│  (lo que la IA no puede hacer: contexto      │
│   negocio, deuda técnica, capacidad equipo)  │
│         │                                    │
│         ▼                                    │
│  Deploy                                      │
└──────────────────────────────────────────────┘

Lo que falta en la IA: juicio, contexto, trade-offs. Lo difícil.

# AI is very good at this:
def generate_crud_endpoints(model: str) -> List[Route]:
   # Generates standard REST endpoints in seconds
   ...

# AI still needs human direction for this:
def decide_architecture():
   """
   Should we:
   - Build a microservice (scalable, complex ops)
   - Extend the monolith (fast, growing debt)
   - Use a managed service (cost, vendor lock-in)
   
   Answer depends on: team size, runway, growth projections,
   existing infra, org priorities.
   
   No model has that context. You do.
   """

El trabajo no desaparece. Desaparece la parte fácil del trabajo.

Y esa parte fácil era la que hacía que el rol pareciera ejecución, no ingeniería.

La barra ha subido (no es que la puerta se esté cerrando)

Hay una versión realista de esta historia:

Si tu trabajo diario es convertir tickets en código siguiendo patrones, eso hoy es más automatizable. Eso es real.

Pero quienes diseñan sistemas, toman decisiones y resuelven problemas complejos no solo sobreviven… aumentan su valor.

Porque a medida que la IA ejecuta más, el valor se mueve hacia el juicio.

Distribución del valor en ingeniería (cambiando):

2022:  [Juicio 40%] ──── [Ejecución 60%]

2025:  [Juicio 70%] ──────────── [Ejecución 30%]
▲
│
Aquí se concentra
la compensación

Lee el comportamiento, no el discurso

Lo más útil que puede hacer hoy un ingeniero no es leer teorías apocalípticas.

Es observar qué hacen las empresas con dinero real.

• Están contratando
• De forma selectiva
• Con salarios altos
• Para resolver problemas, no ejecutar tareas

La oferta de Anthropic, incluida la letra pequeña, es más honesta que la mayoría de opiniones.

No saben exactamente qué pasará. Nadie lo sabe.

Pero necesitan ingenieros hoy. Y compiten fuerte por ellos.

Eso no es contradicción. Es el mercado hablando.

La pregunta no es si la IA cambia la ingeniería. Ya lo hizo.

La pregunta es:
¿estás del lado del juicio… o del lado de la ejecución? 🔥

Gracias por leer Código en Casa.

Resulta que la herramienta de IA más comentada del momento no viene de gigantes como OpenAI o Anthropic. En realidad, es una plataforma open source compleja, un tanto improvisada, que ya ha despertado disputas legales, prohibiciones en grandes corporaciones… y, al mismo tiempo, elogios entusiastas de desarrolladoras en todo el mundo.

Se llama OpenClaw, y su razón de ser es la creación de agentes de IA autónomos. Decidí configurarla, diseñar mi propio agente y entrenarlo para ver si realmente podía hacer mi trabajo por mí. Aquí te cuento mi experiencia.

Cuidado con "la garra"

Llevamos más de un año escuchando promesas sobre el futuro de la “IA agéntica”. Nos dicen que no solo responderá preguntas, sino que ejecutará tareas útiles por nosotras. Pero, siendo sinceras, las grandes tecnológicas son demasiado cautas (y sensibles a los costes) como para soltar algo así al gran público.

Los agentes de IA actúan en nombre del usuario, y eso implica riesgos: desde errores a gran escala hasta daños reales en sistemas. Además, son carísimos de mantener. Por eso, las versiones comerciales que conocemos están tan limitadas; están diseñadas para no “escaparse” ni disparar las facturas de la empresa.

OpenClaw es la excepción. Al ser de código abierto y agnóstica al modelo, puedes conectarla con los LLM de OpenAI, Anthropic o Grok. Al instalarla localmente, le otorgas permisos totales. Esta combinación de acceso al hardware y potencia de cálculo es, sencillamente, demoledora.

Un nombre con historia… y bastantes líos

Al principio, sus creadores lo llamaron “Clawdbot”, un guiño evidente a Claude (de Anthropic). Como era de esperar, a Anthropic no le hizo ninguna gracia y amenazó con demandas. Tras un breve paso por el nombre MoltBot, finalmente adoptaron OpenClaw, inspirado en la pinza de una langosta.

Pero el nombre no es su único frente abierto. Debido a su profundo acceso a datos y hardware, expertos en seguridad han dado la voz de alarma. De hecho, Meta y otras big tech ya han prohibido su uso interno por riesgos de privacidad. Y, qué quieres que te diga, esas prohibiciones solo hicieron que me entraran más ganas de probarlo.

Mi reto: ¿Puede una IA reemplazarme?

Para minimizar riesgos, configuré OpenClaw en un servidor privado virtual (VPS) de Hostinger. Te aviso: la curva de aprendizaje es dura, sobre todo si no estás familiarizada con la programación. Me llevó varias horas y bastante apoyo de ChatGPT dejarlo a punto.

Mi objetivo era ambicioso: crear un agente que investigara noticias de IA, seleccionara un tema relevante, redactara un artículo con mi estilo, incluyera citas y me entregara el resultado final. Tras una configuración intensa, nació mi clon: AI News Desk.

Resultados: ¿Reemplazo a la vista?

Usarlo es sencillo, aunque los tiempos son otros. Mientras ChatGPT busca la rapidez y el bajo coste, OpenClaw no tiene esos incentivos: consume recursos sin piedad para darte el mejor resultado. En mis pruebas, cada tarea tardaba unos 20 minutos y costaba entre 2 y 3 dólares en créditos de API.

¿El resultado? Sorprendentemente bueno. En una de las pruebas, el agente investigó más de 50 fuentes sobre Anthropic, generó un titular potente y escribió un artículo estructurado impecablemente. Incluso imitó mis giros lingüísticos y mi uso de estadísticas.

Como periodista artificial, OpenClaw es brillante:

• Selecciona temas con criterio.
• Cruza múltiples fuentes.
• Mantiene el rigor sin inventar datos (adiós, alucinaciones).

A veces se pone demasiado técnica… pero, siendo honesta, ¡yo también!

¿Es este el futuro de los negocios?

Aunque no dejaría que OpenClaw publicara por mí sin supervisión, su potencial es innegable. No solo escribe; puede gestionar emails, verificar datos, construir apps y controlar dispositivos. Es la demostración de que la IA agéntica ya está aquí, aunque todavía tiene una barrera importante: el coste.

Un día de uso intensivo puede salir por 15 dólares. Por eso, de momento, estos agentes avanzados son terreno de empresas o usuarias muy comprometidas.

Mi conclusión: El futuro agéntico que nos prometieron llegará de forma masiva solo cuando sea rentable. Mientras tanto, herramientas como OpenClaw nos permiten asomarnos hoy a lo que será la norma mañana.

¿Te atreverías a darle las llaves de tu ordenador a un agente así? Me encantaría leer tu opinión en los comentarios.

Gracias por leer Código en Casa.

Muchas pensábamos que OpenClaw ya había ganado la carrera de los asistentes personales, a pesar de esos tropiezos que tuvo al principio. Sin embargo, la realidad nos cuenta una historia distinta: OpenClaw se enfrenta ahora a una competencia feroz de alternativas que ninguna de nosotras hubiera imaginado en aquel momento, casi mágico, de su lanzamiento.

Como te he comentado en mis tutoriales anteriores, OpenClaw no es precisamente la aplicación que yo elegiría para instalar en mi ordenador de trabajo. Por si lo habías olvidado, aquí te refresco algunos de los problemas de seguridad más críticos que me preocupan:

• CVE-2026–25253: Una vulnerabilidad crítica que permite a los atacantes robar tus tokens de autenticación.
• Riesgo real: Investigadores de Palo Alto Networks y Gary Marcus lo han descrito como una “pesadilla de seguridad” y un escenario de fuga de datos inminente.
• Privilegios excesivos: Se ejecuta con permisos completos del sistema por defecto, lo que nos deja una superficie de ataque inmensa.

Ahora que la idea de OpenClaw ha demostrado ser demasiado valiosa como para ignorarla, han florecido alternativas increíbles. Si te apetece experimentar, aquí te traigo 5 opciones que merecen toda nuestra atención.

1. NanoClaw: Seguridad desde la simplicidad radical

NanoClaw es el resultado de lo que sucede cuando una desarrolladora se cansa del código pesado de OpenClaw y decide crear algo que se pueda auditar en menos de 10 minutos.

Desarrollado por el ingeniero Gavriel Cohen en un solo fin de semana usando Claude Code, funciona con apenas 500 líneas de TypeScript (frente a las más de 400.000 de OpenClaw). Lo he probado estos días y su modelo de seguridad me parece impecable: cada agente corre en su propio contenedor aislado. Si la IA llega a "alucinar" e intenta borrar archivos, el daño se queda encerrado en ese entorno.

• Lo mejor: Confianza absoluta gracias a su transparencia.

2. PicoClaw: Inteligencia en la palma de tu mano

PicoClaw nos demuestra que no necesitamos servidores carísimos para tener un asistente eficiente. Funciona con menos de 10MB de RAM; podrías desplegarlo incluso en un móvil antiguo o en una Raspberry Pi de 10$.

Lo que más me fascina es que el 95% de su código fue generado por agentes de IA en un proceso autoevolutivo. Es ligero, rápido (arranca en menos de un segundo) y extremadamente portátil.

3. TrustClaw: La solución profesional en la nube

Si buscas algo más corporativo, TrustClaw es la opción ideal. A diferencia de los anteriores, es un servicio gestionado en la nube donde todo funciona mediante OAuth.

Es perfecto para entornos profesionales donde necesitamos conectarnos a más de 1000 herramientas sin complicarnos con la seguridad local. Aquí el intercambio es sencillo: cedemos un poco de control a cambio de muchísima comodidad y una disponibilidad 24/7.

4. Nanobot: Mi favorito para aprender e investigar

Desarrollado por la Universidad de Hong Kong, Nanobot prioriza que entendamos qué está pasando bajo el capó. Es un framework sencillo, escrito en Python, que mantiene funciones clave como el soporte MCP y la memoria persistente. Si te gusta estudiar cómo interactúan los LLM, esta es tu herramienta.

5. IronClaw: Arquitectura blindada

Para las que trabajamos con entornos críticos (como cripto o Smart Contracts), IronClaw es la respuesta. Está escrito en Rust con un enfoque de "confianza cero". Cada herramienta se ejecuta en un sandbox de WebAssembly, asegurando que tus credenciales nunca queden expuestas. Es, sencillamente, el estándar de oro en seguridad.

Mis conclusiones

OpenClaw nos abrió los ojos a lo que los agentes de IA locales pueden hacer por nosotras, pero estas alternativas nos enseñan que la seguridad y la eficiencia no tienen por qué ser secundarias.

• NanoClaw → Transparencia pura.
• PicoClaw → Portabilidad máxima.
• TrustClaw → Comodidad profesional.
• Nanobot → Aprendizaje y sencillez.
• IronClaw → Seguridad extrema.

En los próximos días estaré haciendo pruebas más técnicas y publicaré una comparativa detallada. Si ya estás probando alguna de estas joyas, ¡cuéntamelo en los comentarios! Me encantaría saber qué es lo que mejor te está funcionando.

Gracias por leer Código en Casa.

Hace más de un año, me quedé fascinada viendo a un ingeniero presentar unos diagramas que parecían dibujados a mano en una reunión general de la empresa. No lo conocía, pero la curiosidad me ganó: lo busqué en Slack y le pregunté qué herramienta usaba. Me contó que era Excalidraw, una opción de código abierto.

Unos meses después, me encontré ante un verdadero reto: tenía que resolver un árbol de decisiones supercomplejo y convertirlo en un diagrama claro. Decidí experimentar y probé combinando ChatGPT, Mermaid.js y Excalidraw.

Aunque tuve que hacer algunos ajustes manuales tras la primera generación, descubrí un flujo de trabajo increíble y logré exactamente lo que buscaba. Hoy quiero contarte cómo lo hice.

Mis aliadas en este proceso:

• ChatGPT
• Código Mermaid (una herramienta basada en JavaScript para conectar el prompt con Excalidraw)
• Excalidraw

Paso 1: Pedirle ayuda a ChatGPT con la lógica

Como mi tarea era crear un árbol lógico complejo para un chatbot, decidí empezar por lo primero: la estructura. Usé un prompt detallado (aquí te muestro uno hipotético para el ejemplo) y, tras un par de ajustes, el resultado me encantó. Estaba satisfecha, pero había un problema: era una lista larguísima... ¿Cómo convertía eso en un diagrama sin morir en el intento?

Hacerlo a mano me habría quitado muchísimo tiempo. Hace años, un mentor me enseñó que si pasaba demasiado tiempo en tareas repetitivas, era el momento de buscar una forma más inteligente de trabajar. Investigando un poco, descubrí que Mermaid podía ser la clave para visualizarlo.

Paso 2: Generar el código Mermaid

Sinceramente, no tenía ni idea de cómo escribir en el lenguaje de Mermaid, pero en lugar de ponerme a estudiarlo desde cero, preferí delegar: le pedí a ChatGPT que generara el código por mí. ¡Y funcionó de maravilla!

Paso 3: Magia en Excalidraw

Copié el código, abrí excalidraw.com y busqué en el menú la opción "Mermaid to Excalidraw". Pegué mi código emocionada, pero ocurrió algo inesperado: saltó un error.

En lugar de frustrarme o intentar depurarlo yo sola perdiendo el foco, volví a pedirle ayuda a ChatGPT. Le pasé el error, lo corrigió de inmediato y me dio un código nuevo. Lo pegué otra vez en Excalidraw y... ¡voilà! Sin errores. ¡Increíble!

Reflexiones finales

Al final, obtuve un árbol lógico complejo que, aunque visualmente necesitaba un par de toques personales, era un punto de partida espectacular para colaborar con mi equipo, especialmente por lo rápido que lo generé.

Sé que en noviembre de 2023 FigJam lanzó funciones de IA similares y también se pueden lograr resultados geniales ahí (de eso les hablaré en otra ocasión). Pero mi mayor aprendizaje no fue la herramienta, sino el proceso.

Logré definir la lógica, generar el código y corregir errores en menos de un minuto por tarea. Lo que antes me habría tomado horas, ahora fluye en instantes. Este experimento me motivó a seguir explorando cómo optimizar procesos pesados usando el poder de la IA.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

Si estás en el mundo de la inteligencia artificial y la automatización de procesos, seguro que ya conoces n8n. Es una herramienta increíble, pero hay un problema que escucho constantemente en la comunidad: "En mi computadora funciona perfecto, pero cuando lo instalo para un cliente, n8n no carga o se vuelve inestable".

La respuesta no es magia, es arquitectura. Para que tus automatizaciones dejen de fallar en producción, primero debes entender cómo "piensa" y cómo se organiza n8n internamente. En este artículo, vamos a desglosar sus tres pilares y luego lo pondremos a prueba en un servidor real para ver hasta dónde aguanta.

Los tres pilares de n8n: ¿Cómo se reparte el trabajo?

Imagina que n8n es un restaurante. Para que los platos salgan a tiempo y el local no sea un caos, se necesitan tres áreas trabajando en equipo:

1. n8n Main: La Cara Visible

Este es el servicio principal (que suele correr por el puerto 5678). Es la interfaz que ves en tu navegador: donde arrastras los nodos, haces clic en los botones y configuras tus flujos. Siguiendo nuestra analogía, el Main es el salón del restaurante; es lo que el cliente ve y donde se toman los pedidos, pero no es donde se cocina la comida.

2. La Cola de Procesos: La Comandera

¿Qué pasa cuando llegan 50 pedidos a la vez? No pueden entrar todos a la cocina al mismo tiempo. Aquí entra la cola de procesos (muchas veces gestionada por herramientas como Redis). Su función es organizar los pedidos en una fila india o sistema FIFO (First In, First Out): el primero que llega es el primero que se atiende. Ella decide quién espera y quién pasa a la siguiente etapa.

3. Los Workers: La Cocina

Aquí es donde ocurre la magia (y el esfuerzo). Los Workers son los encargados de ejecutar las tareas pesadas: analizar una imagen con IA, hacer una petición HTTP o escribir en una base de datos. Si tienes muchos pedidos pero solo una cocinera (un Worker), el servicio será lento. Si tienes muchos Workers pero poca memoria, la cocina colapsará.

Laboratorio de Pruebas: Exprimiendo un VPS

Para entender esto en la práctica, decidí poner a prueba un VPS (Servidor Virtual Privado) de HostGator. Este tipo de servidores son ideales porque ofrecen recursos dedicados y un precio fijo mensual, lo que te da tranquilidad financiera frente a los modelos de pago por ejecución.

El Escenario de Prueba

Configuré un flujo de trabajo que no es excesivamente complejo, pero sí representativo:

1. Un Webhook que recibe información externa.
2. Una cadena de Agentes de IA que categorizan tickets de soporte.
3. Conexiones a modelos de lenguaje externos.

Para monitorear qué sucede "bajo el capó" mientras el servidor trabaja, utilizo una herramienta llamada htop. Imagínalo como un panel de control que me muestra en tiempo real cuánta energía están consumiendo el procesador (CPU) y la memoria RAM.

Pruebas de Estrés: ¿Cuándo se rompe el sistema?

No basta con que un flujo funcione una vez; lo importante es saber cuántas veces puede funcionar al mismo tiempo.

1. El impacto inicial (100 peticiones)

Simulamos una ráfaga de 100 peticiones rápidas, como si una campaña publicitaria enviara tráfico de golpe.

• Resultado: El servidor (de 2 vCPU) mostró un pequeño pico de actividad, pero se recuperó rápido. La "fila" se movió con agilidad.

2. Prueba de resistencia (120 segundos constantes)

Aquí forzamos al sistema a recibir datos sin parar durante dos minutos.

• Lo que notamos: Al observar el monitor de recursos, el procesador empezó a trabajar al máximo. En la interfaz visual, notamos que n8n ya no cargaba tan rápido. Esto sucede porque el "cerebro" (Main) tiene que compartir los recursos con los "cocineros" (Workers).

3. El límite absoluto (Alta concurrencia)

Subimos la apuesta a 200 peticiones simultáneas.

• El colapso: El consumo de memoria RAM llegó a su límite de seguridad y el CPU se saturó. En este punto, la pantalla se queda en blanco. El servidor intenta protegerse reservando un poco de memoria para no "morir" del todo y poder reiniciarse, pero el servicio de n8n deja de responder.

Conclusión: La clave es el equilibrio

Por defecto, n8n viene configurado para manejar 10 ejecuciones paralelas. Si intentas procesar 50 cosas a la vez en un servidor pequeño, se va a colgar.

La clave para que tus automatizaciones sean estables en el mundo real es dimensionar correctamente tu servidor según el volumen de datos que esperas recibir. No escatimes en recursos si planeas manejar procesos críticos o flujos con mucha concurrencia.

Gracias por leer Código en Casa, ¿Te gustaría que hiciéramos más pruebas comparando diferentes potencias de servidores? ¡Cuéntamelo en los comentarios y si quieres ver como se hace te dejo el video aqui 👇!

Con Vercel MCP, tu IA se conecta directamente a tus despliegues. Ya no tienes que imaginar qué salió mal; solo dale un prompt:

“Obtén los logs del último despliegue. ¿Por qué falló la compilación?”

La IA recupera los logs, encuentra el error exacto y te sugiere la solución. Así te mantienes siempre en tu flujo de trabajo.

El plan básico es gratuito. El plan Pro comienza en 20 $ por usuario.

#7 — Docker

Esto soluciona esa situación tan típica: funciona en mi máquina, pero en CI explota. Ahí es cuando empiezas a comparar variables de entorno, revisar imágenes base y hacer suposiciones.

Con Docker MCP, tu IA puede inspeccionar directamente el contenedor. Solo tienes que darle un prompt:

“¿Por qué este contenedor falla en CI pero no en local?”

Ahora ella revisará los logs de construcción del Dockerfile, la caché de capas y las diferencias de entorno. Se acabó el adivinar. Si trabajas con contenedores, esto se vuelve muy potente rápidamente.

La mayoría de las configuraciones son autoalojadas o de código abierto, sin coste directo. Solo pagas por tu infraestructura.

#6 — Apify

Cada vez que necesitas datos de una web, terminas construyendo un scraper, y ya sabemos que los scrapers fallan. Cambia un selector o el diseño, y todo se rompe.

Apify elimina ese problema. Tienes acceso a scrapers mantenidos para más de 2.000 “actors”. Solo necesitas pedirlo:

“Encuentra todas las empresas de TI en mi ciudad usando Google Maps. Exporta nombre, web y teléfono. Guarda como CSV.”

Y listo.

Incluye 5 $de crédito mensual gratuito. Los planes de pago empiezan alrededor de 49$.

#5 — Playwright

Este es de los más útiles. Mientras Apify recopila datos, Playwright ejecuta acciones.

Le da a tu IA un navegador que puede controlar: hacer clic, escribir, desplazarse o gestionar archivos. ¿Necesitas iniciar sesión en un panel antiguo, pasar la verificación en dos pasos y descargar un informe diario? Ella lo hace.

Funciona en local y en CI. Es gratuito e ideal para automatizar interacciones reales.

#4 — Ref

El problema: le preguntas algo a la IA sobre una librería y ella se pone a revisar toda la documentación —miles de líneas, historial y ejemplos— para responderte una sola duda.

Ref lo soluciona. Permite a la IA hacer preguntas muy específicas a la documentación. En lugar de un genérico “lee la documentación de Playwright”, el prompt sería:

“¿Cuáles son los parámetros de page.waitForSelector?”

Te devuelve solo esa función: la firma y la explicación. Sin ruido innecesario.

Gratis para documentación pública. Hay planes de pago para indexar documentación privada.

#3 — File System MCP

Sin esto, tu IA está un poco ciega: solo ve el código que tú le pegas. No sabe dónde se usa una función ni de qué depende.

Con File System MCP, la IA puede ver todo tu proyecto. Solo necesitas un prompt:

“Encuentra componentes no utilizados.”

Escanea toda tu carpeta src. Ahora entiende las relaciones reales, no solo fragmentos sueltos.

Es gratuito, funciona en local y permite hacer cambios a nivel de proyecto completo.

#2 — Exa

Google está diseñado para humanos: anuncios, SEO y clics. Exa está diseñado para IAs. Busca por significado y devuelve resultados estructurados.

Ejemplo de prompt:

“Encuentra discusiones sobre esta condición de carrera en React en 2026.”

Te trae el issue de GitHub, el hilo relevante y la solución real.

Incluye 1.000 solicitudes gratuitas. Los planes de pago empiezan en unos 50 $ al mes.

#1 — Sequential Thinking

Los modelos a veces tienen demasiada prisa por responder.

Sequential Thinking les obliga a planificar antes de hablar. Divide el problema, enumera supuestos, estructura los pasos y luego genera la solución.

Úsalo para arquitectura, debugging complejo o diseño de sistemas. No es para scripts simples, es para lógica avanzada.

Es gratuito y de código abierto.

La diferencia: pasar de adivinar a diseñar.

Deja de copiar contexto. Empieza a conectar sistemas.

Con estas herramientas combinadas, pasas de pegar información a integrar sistemas completos.

Ese es el cambio:

de conversar a construir,

de fragmentos aislados a una visión completa,

de la suposición a la ingeniería.

MCP no es solo una función. Es la diferencia entre una IA que habla y una IA que realmente trabaja.

¿Aprendiste algo útil hoy? Entonces compártelo.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

El mundo tecnológico está revolucionado con los agentes de IA, y no es para menos. Cada semana nos despertamos con un anuncio nuevo: asistentes de programación que parecen magia, "empleados" de IA que no conocen el café ni el sueño, y agentes capaces de organizarte un viaje entero mientras tú descansas.

Pero ya estamos en 2026, y es momento de que nos hagamos las preguntas difíciles: ¿qué está funcionando realmente? ¿qué sigue siendo ciencia ficción? Y, sobre todo, ¿en qué deberíamos centrar nuestros esfuerzos como desarrolladoras y empresas?

Tras haber pasado el último año construyendo, rompiendo e investigando agentes de IA, he visto de todo: desde avances que me han dejado con la boca abierta hasta fracasos espectaculares. Así que, vamos a separar juntas el ruido de la realidad.

¿Qué es (y qué NO es) un agente de IA?

Antes de dejarnos llevar por la emoción, pongamos los pies en el suelo. Un agente de IA es, básicamente, un software impulsado por modelos de lenguaje que tiene "superpoderes" para:

• Percibir su entorno: Lee texto, analiza imágenes, consulta APIs y revisa bases de datos.
• Tomar decisiones: No solo sigue reglas; decide pasos basados en los objetivos que le asignamos.
• Ejecutar acciones: "Tiene manos". Llama a APIs, escribe código y manipula archivos.
• Aprender del feedback: Ajusta su rendimiento según los resultados.

Suena increíble, ¿verdad? Y lo es. Pero aquí está la cura de humildad:

• No tienen conciencia ni sentimientos (aunque a veces nos parezcan muy amables).
• No son infalibles; pueden tomar decisiones equivocadas con mucha seguridad.
• No están listos para reemplazar el juicio humano en escenarios críticos.
• Siguen siendo propensos a errores o a las famosas "alucinaciones".

El Hype: De qué habla todo el mundo (y qué está pasando de verdad)

1. “Los agentes reemplazarán a todos los ingenieros de software”

La promesa: Agentes como Devin o GitHub Copilot Workspace lo harán todo. Tú pides, ellos construyen. La realidad: Son asistentes de ensueño, pero están lejos de quitarnos el puesto.

• Lo que hacen genial: Generar código base, depurar errores simples, escribir tests y sugerir APIs.
• Donde fallan: Decisiones de arquitectura compleja, entender los matices reales del negocio o refactorizar bases de código gigantes.
• Veredicto: Multiplican nuestra productividad, pero el criterio de ingeniería sigue siendo nuestro.

2. “Atención al cliente 100% autónoma”

La promesa: Un agente que gestiona todo el soporte 24/7 sin humanos. La realidad: Funcionan para el Nivel 1, pero se pierden cuando las cosas se ponen feas.

• El problema: Fallan en situaciones emocionales complejas o casos que requieren una excepción humana. A veces, un cliente frustrado solo necesita sentir que alguien lo escucha de verdad.
• Veredicto: Útiles para filtrar y resolver lo básico (FAQs, recogida de datos), pero los humanos seguimos siendo el corazón del servicio.

3. “Asistentes personales que gestionan tu vida”

La promesa: Un agente que organiza tus viajes, emails y calendario. La realidad: Estamos cerca, pero aún nos falta un hervor.

• Los retos: La autenticación en mil servicios, gestionar fallos en reservas y, lo más importante, la confianza. ¿Dejarías que una IA gaste $2,000 de tu tarjeta sin supervisión?
• Veredicto: Fantásticos para redactar correos o investigar, pero dales permiso para gastar con cuidado.

La Realidad: Donde los agentes realmente brillan hoy

Si quieres ver resultados reales ahora mismo, estos son los campos ganadores:

1. Análisis de Datos: Generar reportes, detectar anomalías y crear dashboards automáticos. Aquí funcionan de maravilla porque los inputs son claros.
2. Investigación y Síntesis: Estudios de mercado, análisis de la competencia o monitorización de noticias. Mucha info, bajo riesgo.
3. Automatización de Workflows: Procesar facturas, clasificar tickets o calificar leads. Tareas repetitivas con reglas definidas.
4. Generación de Código Específico: Crear APIs CRUD, scripts de datos o documentación técnica.

El reto técnico: Lo que no te cuentan en las presentaciones

No todo es tan sencillo como parece. Si vas a construir agentes, prepárate para lidiar con:

• Fiabilidad: Los modelos no son deterministas. Necesitas tests robustos y supervisión humana.
• Coste: Cada ejecución puede costar entre $0.50 y $2. ¡Optimiza tus prompts y usa caché!
• Integración: Pelear con límites de APIs, tokens de autenticación y el estado entre llamadas es el pan de cada día.
• Evaluación: Es muy difícil medir qué tan bien lo está haciendo un agente. Necesitas datasets de evaluación y mucho A/B testing.

¿A qué deberíamos apostar este año?

• Este 2026: Céntrate en el desarrollo asistido, agentes especializados (que hagan una sola cosa muy bien) y sistemas multi-agente donde colaboren entre ellos.
• En 2–3 años: Veremos asistentes personales mucho más reales y una "economía entre agentes".
• Ciencia ficción (5+ años): Razonamiento humano real, sentido común profundo y fiabilidad perfecta.

Mis consejos prácticos para ti

Si estás empezando, mi mejor consejo es: empieza pequeño. No intentes automatizar toda tu empresa de golpe. Mantén siempre a un humano en el proceso (Human-in-the-loop), diseña pensando en que el agente va a fallar y, sobre todo, prioriza el retorno de inversión.

En conclusión: Los agentes de IA en 2026 son herramientas poderosas, pero no son varitas mágicas. La verdadera magia ocurre cuando combinamos la capacidad de procesamiento de la IA con el juicio y la empatía humana.

Los que ganen este año serán quienes entiendan las capacidades reales, construyan sistemas robustos y no dejen de iterar.

¿Y tú? ¿Cuál ha sido tu experiencia real con los agentes? ¿Te han salvado el día o te han dado algún dolor de cabeza extra? Me encantaría leerte.

Recursos para seguir aprendiendo

• Frameworks: LangGraph, AutoGen, CrewAI.
• Lectura: Documentación de Claude (¡es oro!), guías de OpenAI y cursos de DeepLearning.AI.
• Comunidad: arXiv para los papers más recientes y los Discords de desarrolladores.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

No es una metáfora. Es una arquitectura real.

Lo que he construido es un “Headquarter” de agentes de Inteligencia Artificial: un sistema donde múltiples agentes autónomos colaboran entre sí, cada uno con una función específica dentro de un ecosistema organizado.

Pero lo importante no es la interfaz ni cómo se representa visualmente. Lo importante es cómo está diseñado el sistema y, sobre todo, dónde vive.

Estos agentes no están en mi ordenador personal. Están desplegados en un VPS (servidor virtual privado) que funciona 24/7. Eso significa que siguen trabajando incluso cuando yo no estoy conectado.

La arquitectura: cómo se organiza un sistema de agentes

El sistema está dividido en tres niveles, como si fuera una empresa.

Nivel 1: Dirección (CEO)

En la parte superior estoy yo.

Mi rol no es ejecutar tareas, sino tomar decisiones de alto nivel:

• definir objetivos
• aprobar propuestas
• rechazar ideas

No escribo código, no redacto contenido, no edito. Solo dirijo.

Nivel 2: Operaciones (COO)

Aquí entra ZEN, el director de operaciones.

Su función es crítica: recibe mis instrucciones y las descompone en tareas concretas para los agentes. No ejecuta directamente, pero se asegura de que todo siga las reglas y objetivos definidos.

Nivel 3: Ejecución (equipo operativo)

Aquí está la verdadera fuerza del sistema:

• Begoña → especialista en X y blogs. Analiza estilo, aplica técnicas avanzadas y gestiona comunidad.
• Rockety → enfocado en YouTube. Optimiza guiones, hooks y calendario de contenido.
• Amar → perfil visual. Genera contenido para Instagram y miniaturas.
• Tomas → adapta contenido a LinkedIn con tono profesional y formatos específicos.

Cada agente tiene un rol claro, lo que permite escalar sin caos.

Infraestructura: el error que comete el 90%

Para que esto funcione, necesitas infraestructura real.

Estoy utilizando VPS de HostGator optimizados para agentes de IA con tecnología OpenClaw. La ventaja es que son prácticamente “plug and play”.

Hay planes económicos, pero si quieres ejecutar varios agentes simultáneamente, necesitas RAM.

Recomendación:

• usar planes NVMe 4 u 8

¿Por qué?

Porque cuando un agente procesa información o utiliza modelos de lenguaje, sin suficiente memoria:

• el sistema se ralentiza
• o directamente se bloquea

La infraestructura no es opcional. Es el cuello de botella.

Las herramientas: cómo los agentes actúan en el mundo real

La inteligencia sin acción no sirve.

Por eso los agentes necesitan herramientas:

Twikit

Permite interactuar con X sin depender de APIs oficiales extremadamente caras.

Firecrawl

Convierte páginas web en contenido limpio en Markdown, eliminando ruido y optimizando tokens.

Notion API

Actúa como base de datos central:

• los agentes guardan contenido
• se aprueba desde cualquier dispositivo
• se disparan automáticamente nuevas acciones

Esto crea un flujo completamente automatizado.

Claude Code: potencia sin control de coste

Claude Code es una herramienta extremadamente potente para programar desde terminal.

El problema es claro: el coste.

Si analizas repositorios grandes o ejecutas tareas complejas usando la API oficial, el consumo de tokens se dispara.

La solución es usar modelos alternativos compatibles.

Ollama: ejecutar modelos gratis en local

Ollama permite correr modelos en tu propia máquina o VPS.

Instalación

curl -fsSL https://ollama.com/install.sh | sh

Descargar modelo

ollama pull devstral-small-2

Configuración

export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL="http://localhost:11434"

Ejecutar:

claude --model devstral-small-2

Esto hace que Claude Code use un modelo local en lugar de conectarse a Anthropic.

El factor crítico: hardware

Si tienes 16GB de RAM, funcionará… pero lento.

Para una experiencia fluida:

• mínimo 32GB de RAM

En Apple Silicon, la memoria unificada mejora el rendimiento.

LM Studio: alternativa visual

Para quienes prefieren interfaz gráfica:

• buscar modelo
• descargar
• iniciar servidor

Por defecto usa el puerto 1234, así que solo necesitas cambiar el BASE_URL.

Costes: el cambio radical

Mover carga a modelos locales o baratos cambia completamente la economía.

Ejemplo:

• DeepSeek V3 vía OpenRouter
• coste por millón de tokens → centavos

Comparado con modelos premium, el ahorro es de hasta el 98%.

llama.cpp: exprimir al máximo el hardware

Para usuarios avanzados:

Compilación

Mac:

cmake llama.cpp -B llama.cpp/build -DGGML_METAL=ON

Linux:

cmake llama.cpp -B llama.cpp/build -DGGML_CUDA=ON

Un punto clave:
puedes usar Claude Code para resolver errores de instalación automáticamente.

Detalle técnico crítico

El flag --jinja es obligatorio.

Sin él:

• fallan las herramientas
• aparecen errores de formato

Ejecución

llama-server -hf modelo \
 --alias "Qwen3-Coder" \
 --port 8000 \
 --jinja \
 --flash-attn on \
 --ctx-size 64000

Modelos GGUF: cómo hacer viable lo imposible

Los modelos GGUF están cuantizados.

Ejemplo:

• Q4_K_M → reduce tamaño
• mantiene calidad

Esto permite ejecutar modelos grandes en hardware limitado.

Latencia: el detalle que pocos consideran

• modelos locales → respuesta inmediata
• modelos cloud → depende de la ubicación

Configuración ejemplo:

export ANTHROPIC_BASE_URL=https://openrouter.ai/api
export ANTHROPIC_AUTH_TOKEN=TU_KEY
export ANTHROPIC_MODEL="deepseek/deepseek-chat"

Algunos modelos baratos pueden incluso superar a los premium en tareas específicas.

Qué usar realmente (sin teoría)

No hay una única solución.

• Privacidad total → Ollama / LM Studio
• Coste mínimo → DeepSeek / Minimax
• Máxima calidad → Claude Opus

La estrategia óptima:

• modelos baratos/locales → tareas repetitivas
• modelos premium → decisiones críticas

Conclusión

Esto no va de usar IA.

Va de construir sistemas que trabajen por ti.

Antes, el trabajo era manual y consumía horas cada día.
Ahora, todo ocurre dentro del “Headquarter” mientras tú te enfocas en lo que realmente importa.

Deja de ser el operador.
Pasa a ser el arquitecto.

Monta tu infraestructura.
Elige tu modelo.
Y deja que los agentes hagan el trabajo pesado.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

Y si quieres verlo te comparto el video para que lo hagas. 👇

En las primeras versiones de este recorrido, conseguir que Claude Code funcionara con algo distinto a la API oficial de Anthropic era… complicado, por decir lo poco. Las integraciones eran frágiles, la configuración me parecía un experimento de laboratorio y cada actualización corría el riesgo de romperme por completo el flujo de trabajo.

Avanzamos hasta hoy: Claude Code ahora tiene un soporte mucho mejor para proveedores alternativos (incluyendo Ollama, LM Studio, llama.cpp, OpenRouter y otros). Esto cambia la pregunta práctica de: “¿Puedo hacer que esto funcione?” a: “¿Qué opción debería elegir para mi caso de uso (coste / velocidad / calidad / privacidad) — y cómo lo configuro en 5 minutos?”

Así que aquí tienes mi guía actualizada, con mi opinión personal incluida.

Mi entorno de pruebas para los ejemplos

Para que tengas una referencia, he estado probando todo esto en una MacBook Pro M1 (32GB de RAM) y en una Nvidia DGX Spark (120GB de RAM, GPU GB10). Te mostraré primero los caminos más simples (Ollama local y routing cloud sencillo), y luego las configuraciones que me parecen más flexibles.

Especificaciones mínimas de máquina (para que programar con un LLM local sea “aceptable”)

Si quieres que Claude Code + modelos locales sea realmente usable para programar (y no se quede solo en una demo bonita), yo apuntaría a:

• RAM: 32GB (memoria unificada en Apple Silicon o RAM en PC).
• Tamaño del modelo: ~24B parámetros como punto de partida.

Con 16GB puedes ejecutar modelos más pequeños, pero mi experiencia suele ser peor: te encuentras con más errores, tienes que hacer más intentos y acabas perdiendo más tiempo total.

Modelos que te recomiendo para empezar

• devstral-small-2 (24B): Me parece un buen punto de partida en calidad de código.
• qwen3-coder:30b: Para mí, es la mejor capacidad de programación que sigue siendo viable en 32GB.
• GLM4.7-flash:q8_0: Un equilibrio fantástico entre coste y latencia (cuantizado).

¿Por qué usar modelos alternativos?

Seamos honestas: Claude Code con la API oficial es excelente, pero se vuelve caro muy rápido. Yo misma estaba consumiendo créditos a toda velocidad solo probando funcionalidades.

Así que empecé a buscar alternativas. Resulta que Claude Code funciona con cualquier proveedor que hable el formato de API de Anthropic, y ahora mismo hay muchísimos.

Conclusión: las alternativas de terceros pueden ahorrarte hasta un 98% frente a Opus 4.5. DeepSeek V3.2 es el más barato (~0.28/0.28/0.42 por millón de tokens), mientras que opciones locales como Ollama me salen completamente gratis. Si prefieres suscripciones en lugar de pago por uso, tienes opciones desde aproximadamente 3$/mes (ZhipuGLM) o 10$/mes (MiniMax).

Opción 1: Ollama local

Tiempo: 5 minutos | Coste: Gratis | Ideal para: Privacidad y trabajar sin internet.

Si quieres algo que funcione sin complicarte la vida, Ollama es tu mejor aliada.

Paso 1: Instalar Ollamacurl -fsSL https://ollama.com/install.sh | sh

Paso 2: Descargar un modeloCon mis 32GB de RAM, puedo usar cómodamente el modelo de 24B: ollama pull devstral-small-2(Elige según tu RAM basándote en mis pruebas anteriores).

Paso 3: Conectar con Claude CodeForma sencilla: ollama launch claude --model devstral-small-2

O configuración manual (en tu ~/.zshrc o ~/.bashrc):

Bash

export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL="http://localhost:11434"

Luego:

Bash

source ~/.zshrc
claude --model devstral-small-2

¡Y listo! Ya tienes Claude Code corriendo en local.

Rendimiento en mis pruebas:

• En Mac M1 (32GB): qwen3-coder (32B) me fue muy lento; prefiero devstral-small-2.
• GLM-4.7-flash:bf16 (30B) tiene una velocidad bastante buena, similar a Claude Opus 4.5.

Opción 2: llama.cpp + HuggingFace

Tiempo: 15–20 minutos | Coste: Gratis | Ideal para: Usar cualquier modelo de HuggingFace.

Ollama es genial, pero si como yo quieres un modelo específico que acaba de salir, aquí entra llama.cpp.

Paso 1: Compilar llama.cppEn macOS (Apple Silicon):

Bash

brew install cmake
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build -DGGML_METAL=ON
cmake --build llama.cpp/build --config Release -j
cp llama.cpp/build/bin/llama-* llama.cpp/

En Linux (GPU NVIDIA):

Bash

sudo apt-get update && sudo apt-get install build-essential cmake git -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j
cp llama.cpp/build/bin/llama-* llama.cpp/

Nota: -DGGML_METAL=ON activa la aceleración en Mac y -DGGML_CUDA=ON para NVIDIA. Como dato curioso: en Mac la instalación fue sencilla, pero en la máquina NVIDIA me dio problemas, así que usé Claude Code con kimi-k2.5:cloud para que me ayudara a solucionarlo… y funcionó de maravilla.

Paso 2: Iniciar servidor (y descargar modelo)Ejemplo con qwen3-coder:

Bash

llama-server -hf bartowski/cerebras_Qwen3-Coder-REAP-25B-A3B-GGUF:Q4_K_M \
    --alias "Qwen3-Coder-REAP-25B-A3B-GGUF" \
    --port 8000 \
    --jinja \
    --kv-unified \
    --cache-type-k q8_0 --cache-type-v q8_0 \
    --flash-attn on \
    --batch-size 4096 --ubatch-size 1024 \
    --ctx-size 64000

Importante: El flag --jinja es obligatorio para que funcionen las herramientas (tools).

Paso 3: Conectar Claude Code

Bash

export ANTHROPIC_BASE_URL="http://localhost:8000"
source ~/.zshrc
claude --model Qwen3-Coder-REAP-25B-A3B-GGUF

Rendimiento:

• Nvidia DGX: Bastante bien.
• Mac M1: Lento (para mi gusto, no es ideal para uso diario).

Opción 3: LM Studio

Tiempo: 5 minutos | Coste: Gratis | Ideal para: Privacidad y comodidad máxima.

LM Studio es una de mis herramientas favoritas, sobre todo por lo fácil que nos pone elegir modelos.

Paso 1: InstalarDesde su web o vía terminal: curl -fsSL https://lmstudio.ai/install.sh | bash

Paso 2: Descargar modeloEn la app lo buscas y descargas, o en servidor usas lms chat y luego /download.

Paso 3: Iniciar servidorlms server start --port 1234

Paso 4: Conectar Claude Code

Bash

export ANTHROPIC_BASE_URL=http://localhost:1234
export ANTHROPIC_AUTH_TOKEN=lmstudio
claude --model qwen/qwen3-coder-30b

Opción 4: Ollama Cloud

Tiempo: 2 minutos | Coste: Pago por uso | Ideal para: Potencia cloud con mi flujo local.

Ollama tiene variantes :cloud que se ejecutan fuera de tu máquina pero usan los mismos comandos que ya conoces.

Paso 1:ollama pull kimi-k2.5:cloud o ollama pull minimax-m2.1:cloud

Paso 2:ollama launch claude --model minimax-m2.1:cloud o simplemente claude --model kimi-k2.5:cloud

Opción 5: APIs de proveedores cloud

Tiempo: 2 minutos | Coste: Pago por uso | Ideal para: Control total y máxima velocidad.

Ejemplo con OpenRouter:

Bash

export ANTHROPIC_BASE_URL=https://openrouter.ai/api
export ANTHROPIC_AUTH_TOKEN=TU_KEY_DE_OPENROUTER
export ANTHROPIC_API_KEY=
export ANTHROPIC_MODEL="openai/gpt-oss-120b:free"

Nota: Dejar ANTHROPIC_API_KEY vacío me ayuda a evitar conflictos.

Minimax:Me parece que tiene una calidad buenísima y es extremadamente barato (un 98% menos que Opus 4.5):

Bash

export ANTHROPIC_BASE_URL=https://openrouter.ai/api
export ANTHROPIC_AUTH_TOKEN=<MINIMAX_API_KEY>
export ANTHROPIC_MODEL="MiniMax-M2.1"

Lo mismo te sirve para GLM, DeepSeek o Kimi.

Conclusión

La idea principal que quiero transmitirte es esta: Claude Code es mucho más flexible de lo que parece a simple vista. No estás limitada en absoluto a la API de Anthropic.

• Si necesito privacidad → me voy a modelos locales.
• Si quiero rendimiento puro → elijo cloud.
• Si busco un coste bajo → DeepSeek, Minimax, etc.

Eso sí, bajo mi punto de vista, si necesitas una calidad alta y consistente hoy por hoy, Opus 4.5 sigue siendo el mejor equilibrio entre calidad y velocidad.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

15 extensiones que todo desarrollador serio debería probar….

Puedes ver quién cambió cada línea de código, cuándo y por qué directamente en tu editor. Al pasar el cursor por encima de cualquier línea, se muestra el historial de confirmaciones, el autor y los enlaces a los cambios completos. También puedes comparar ramas y explorar el historial de archivos sin salir de VS Code. Esto es esencial para comprender la evolución de un proyecto y colaborar de manera eficaz.

En 2025, con herramientas impulsadas por IA y flujos de trabajo de desarrollo más inteligentes, utilizar las extensiones de VS Code adecuadas puede marcar una gran diferencia. Aquí tienes una lista detallada de las 15 extensiones que todo desarrollador serio debería probar.

1. GitLens: potencia Git dentro de VS Code

GitLens lleva tu experiencia con Git al siguiente nivel.

GitLens: Git potenciado - Visual Studio Marketplace

Extensión para Visual Studio Code: potencia Git dentro de VS Code. Visualiza la autoría del código de un vistazo mediante Git blame...

marketplace.visualstudio.com

2. Tabnine: autocompletado con tecnología de IA

Tabnine predice tus próximas líneas de código utilizando IA.

Tabnine: chat con IA y autocompletado para JavaScript, Python, Typescript, Java, PHP, Go y más...

Extensión para Visual Studio Code: Tabnine es el asistente de código con IA que acelera y simplifica el software...

marketplace.visualstudio.com

Aprende tus patrones de codificación, por lo que las sugerencias se ajustan a tu estilo. Por ejemplo, puede autocompletar un componente React, incluyendo props y lógica de estado, o generar plantillas de funciones completas. Esto reduce el trabajo repetitivo y ayuda a evitar pequeños errores de sintaxis, lo que aumenta la velocidad general de codificación.

3. Codeium: asistente de codificación con IA gratuito

Codeium es un asistente de código con IA gratuito que funciona en varios lenguajes.

Tabnine: chat con IA y autocompletado para JavaScript, Python, Typescript, Java, PHP, Go y más...

Extensión para Visual Studio Code: Tabnine es el asistente de código con IA que acelera y simplifica el software...

marketplace.visualstudio.com
Puedes generar funciones, clases o código repetitivo al instante. Por ejemplo, la creación de un punto final de API REST se agiliza cuando Codeium sugiere una estructura de funciones lista para usar. Es perfecto para desarrolladores que buscan productividad con IA sin suscripciones de pago.

4. Prettier: formateador de código

Prettier mantiene tu código limpio y coherente. Formatea JavaScript, TypeScript, HTML, CSS, JSON y más.

Prettier: formateador de código - Visual Studio Marketplace

Extensión para Visual Studio Code: formateador de código que utiliza Prettier

marketplace.visualstudio.com
Esto elimina los debates sobre espacios, sangrados y saltos de línea. Para los equipos, Prettier garantiza que todos sigan el mismo estilo de codificación, lo que facilita las revisiones de código y reduce las fricciones.

5. ESLint: detección temprana de errores

ESLint detecta errores y aplica estándares de codificación en JavaScript y TypeScript.

ESLint: Visual Studio Marketplace

Extensión para Visual Studio Code: integra ESLint JavaScript en VS Code.

marketplace.visualstudio.com
En lugar de descubrir problemas durante el tiempo de ejecución, ESLint resalta los problemas mientras escribes, lo que te ayuda a mantener un código de alta calidad. También permite reglas personalizadas, lo que lo hace adaptable a tu equipo o flujo de trabajo personal.

6. Live Server: vista previa del frontend en tiempo real

Live Server: Visual Studio Marketplace

Extensión para Visual Studio Code: inicia un servidor local de desarrollo con función de recarga en vivo para estático y dinámico...

marketplace.visualstudio.com
Live Server actualiza automáticamente el navegador cada vez que guardas tus archivos HTML, CSS o JS. Esto supone un cambio revolucionario para el desarrollo frontend, ya que te permite ver los cambios al instante sin necesidad de recargar manualmente. Acelera drásticamente las pruebas y la iteración de la interfaz de usuario.

7. REST Client: prueba API dentro de VS Code

REST Client: Visual Studio Marketplace

Extensión para Visual Studio Code: REST Client para Visual Studio Code

marketplace.visualstudio.com
REST Client le permite enviar solicitudes HTTP directamente desde VS Code utilizando archivos .http. Puede probar los puntos finales GET, POST, PUT o DELETE sin salir del editor. Esto le ahorra la molestia de cambiar a herramientas externas como Postman y mantiene optimizado su flujo de trabajo de pruebas de API.

8. Docker: gestione contenedores de forma eficiente

Docker - Visual Studio Marketplace

Extensión para Visual Studio Code: facilita la creación, gestión y depuración de aplicaciones en contenedores.

marketplace.visualstudio.com
La extensión Docker le permite crear, ejecutar y gestionar contenedores directamente en VS Code. Puede ver registros, ejecutar comandos e inspeccionar imágenes sin salir del editor. Si sus proyectos dependen de entornos en contenedores, esta extensión simplifica su flujo de trabajo y reduce los cambios de contexto.

9. GitHub Copilot: compañero de codificación con IA

GitHub Copilot es un asistente de codificación con IA que escribe código, genera pruebas e incluso sugiere documentación. A diferencia del autocompletado básico, entiende el contexto de tu proyecto. Por ejemplo, puede generar una ruta Express.js completa con el manejo adecuado de errores en segundos, lo que agiliza y facilita el desarrollo.

10. Thunder Client: herramienta API ligera

Thunder Client es una alternativa rápida y ligera a Postman, integrada directamente en VS Code. Admite colecciones, autenticación y variables de entorno. Para los desarrolladores de backend, esta extensión supone un ahorro de tiempo, ya que permite realizar pruebas de API sin salir del editor.

11. Tailwind CSS IntelliSense

Tailwind CSS IntelliSense - Visual Studio Marketplace

Extensión para Visual Studio Code - Herramientas inteligentes de Tailwind CSS para VS Code

marketplace.visualstudio.com
Esta extensión mejora el desarrollo de Tailwind CSS con autocompletado, resaltado de sintaxis y linting. En lugar de memorizar cientos de clases de utilidad, IntelliSense sugiere las clases adecuadas a medida que se escribe. Acelera drásticamente el estilo del frontend y reduce los errores.

12. Path Intellisense

Path Intellisense autocompleta las rutas de los archivos a medida que se escribe, lo que ayuda a importar o vincular archivos. Ya no es necesario adivinar los nombres de las carpetas ni navegar manualmente por los directorios. Esto resulta especialmente útil en proyectos grandes con estructuras anidadas.

13. Error Lens

Error Lens - Visual Studio Marketplace

Extensión para Visual Studio Code: mejora el resaltado de errores, advertencias y otros diagnósticos del lenguaje.

marketplace.visualstudio.com
Error Lens resalta los errores y las advertencias directamente en el editor de código, en lugar de en la pestaña Problemas. Esta información en tiempo real agiliza considerablemente la depuración y evita que pequeños errores pasen desapercibidos.

14. Peacock: codificación por colores para múltiples proyectos

Peacock le permite codificar por colores sus espacios de trabajo de VS Code. Si trabaja en varios proyectos, puede identificar al instante qué proyecto está abierto simplemente por el color del editor. Esto reduce los errores de cambio de contexto y mantiene su flujo de trabajo organizado.

15. Better Comments

Better Comments le permite clasificar los comentarios en notas, advertencias, tareas pendientes o resaltados utilizando colores.

Better Comments - Visual Studio Marketplace

Extensión para Visual Studio Code: mejora los comentarios de tu código añadiendo anotaciones con alertas, información, tareas pendientes y...

marketplace.visualstudio.com

Esto hace que los comentarios sean más legibles y ayuda a los futuros desarrolladores (incluido tú mismo) a comprender rápidamente las partes importantes de tu código.

Nota del editor: no estoy afiliado a ninguna de las herramientas o desarrolladores mencionados. Todos los enlaces son no patrocinados y se basan en el uso personal o la confianza de la comunidad.

Empieza con 3-5 extensiones que se adapten a tu flujo de trabajo y amplíalas gradualmente. La configuración adecuada puede transformar VS Code de un simple editor a un potente entorno que aumenta la productividad. En 2025, estas herramientas te ayudarán a programar de forma más inteligente, rápida y eficiente.

Todas las extensiones son de VS Code Marketplace. Instálalas con un solo clic y personaliza tu flujo de trabajo para obtener la máxima productividad.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

Llevo los últimos seis meses siguiendo el mundo de los "asistentes de programación con IA" con una frustración que no para de crecer. Con cada nuevo lanzamiento parece que se repite la misma historia: le pasas un archivo al modelo, te corrige un error y listo. Copiar, pegar y a seguir.

Pero la semana pasada hubo algo que me llamó la atención de una forma que, de verdad, no he podido ignorar.

Claude Sonnet 5 , que en teoría sale a mediados de febrero de 2026, parece estar adoptando un enfoque radicalmente diferente. Después de pasarme horas sumergida en filtraciones, pruebas de la comunidad y pistas sobre su arquitectura, creo que estamos a punto de presenciar un auténtico cambio de paradigma.

Actualización de última hora: los rumores dicen que podría salir hoy mismo (4 de febrero). Si es verdad, este artículo va a envejecer o increíblemente bien... o muy mal en cuestión de horas. Sea como sea, prepárense.

Aquí les explico lo que encontré.

El problema del que nadie habla: los programadores con IA están "ciegos"

Hay algo que me viene dando vueltas en la cabeza desde hace tiempo.

Los modelos actuales —incluso los mejores, como GPT-5.2 o Claude Sonnet 4.5— tratan el código como si fuera solo... texto. Ven caracteres, predicen el siguiente token y esperan que todo salga bien.

Pero la realidad es otra: el código no es solo texto. Es una aplicación viva que se renderiza en una pantalla, que responde a clics y que existe en un espacio visual.

A esto yo lo llamo el "problema del programador ciego".

Piénsenlo un momento. Si le piden a una IA que escriba una función draw_circle(), puede que el código sea correcto. Pero, ¿entiende de verdad dónde se dibuja ese círculo en una pantalla de 1920x1080? ¿Sabe cómo se relaciona con el botón que tiene al lado? ¿Comprende la relación espacial entre los elementos?

La respuesta es que no. Y por eso seguimos peleándonos con los layouts y el CSS.

Dos problemas constantes:

1. Ceguera espacial: El modelo predice tokens, no coordenadas. Centrar un div perfectamente sigue siendo casi una cuestión de azar.
2. Amnesia de contexto: En cuanto pasas de las 500 líneas, el modelo empieza a olvidar estados, usuarios o decisiones que tomó al principio.

Y aquí es donde entra Sonnet 5 (cuyo nombre en clave interno es "Fennec").

¿Qué hace diferente a Sonnet 5? Piensa en espacio, no en texto

Según lo que se ha filtrado, Anthropic ha hecho un cambio brutal.

El titular es este: Sonnet 5 está diseñado con un enfoque "visual-first", respaldado por un contexto nativo de 1 millón de tokens.

Sí, leyeron bien: un millón.

Eso no significa solo que "recuerda más código". Significa que puede mantener en memoria el estado completo de una aplicación: variables, componentes y todas sus relaciones.

Pero lo verdaderamente importante no es el tamaño del contexto, sino cómo lo procesa. En lugar de ver el código como si fuera una novela, modela las relaciones lógicas y espaciales. En otras palabras: no solo escribe código, sino que entiende lo que ese código genera.

Las pruebas que lo hacen creíble

Sé que suena a puro hype, pero aquí es donde la cosa se pone seria. Usuarios como @chetaslua y @marmaduke091 han estado probando versiones tempranas y los resultados son... difíciles de explicar con los modelos que tenemos hoy.

Juegos completos con un solo prompt

@marmaduke091 ha generado juegos enteros en Canvas:

• Un juego de karts en 3D con HUD y sistema de colisiones.
• Un plataformas estilo Celeste con físicas reales.
• Un simulador de carreras con un drift superrealista.

No son plantillas. Son juegos funcionales. Esto indica que el modelo no solo escribe JavaScript: visualiza el sistema completo.

Construir un sistema operativo en una sola página

@chetaslua probó algo aún más extremo: un "WebOS" con ventanas que se pueden arrastrar, barra de tareas y más de 12 apps (Paint, Terminal, VS Code...) funcionando a la vez sin perder el estado. Gestionar miles de variables de forma coherente requiere ese millón de tokens que mencionábamos.

El experimento más loco: anatomía 3D sin modelos externos

Se le pidió un visor anatómico en 3D sin usar archivos externos. ¿El resultado? El modelo calculó matemáticamente los órganos usando Three.js. No descargó el corazón; lo generó desde la lógica matemática.

La otra gran filtración: Opus 4.6

No solo viene Sonnet 5. También se ha filtrado Opus 4.6, y la idea es que trabajen en equipo:

• Sonnet 5: rápido y visual.
• Opus 4.6: profundo y arquitecto.

Imaginen el flujo: uno diseña la estrategia y el otro construye. Un flujo de trabajo sencillamente brutal.

Qué significa esto (y por qué el "prompt engineering" está muriendo)

Si esto es real, entramos de lleno en la era del Context Engineering. Los cambios clave serán:

1. De funciones a sistemas: Ya no pediremos "hazme una función", sino "constrúyeme una app completa".
2. Lo visual es matemático: La IA no necesitará ver imágenes para generar interfaces; podrá derivarlas lógicamente.
3. Futuro multimodelo: La clave será saber orquestar diferentes modelos.

¿Qué viene ahora?

Si todo se cumple, veremos las APIs a mediados de febrero. Mi opinión personal es clara: si siguen trabajando con modelos de 200k tokens, se van a quedar cortos muy pronto. El techo acaba de subir muchísimo.

¿Han visto alguna otra filtración sobre Sonnet 5 que les haya volado la cabeza? Me encantaría leer sus teorías en los comentarios.

Nota sobre tus preferencias: Si quieres que siempre utilice este tono (femenino y castellano neutro) para futuros textos, puedes configurarlo en 'Tus instrucciones para Gemini' aquí. Allí puedes agregar tus preferencias específicas para que no tenga que recordártelo cada vez.

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

Latent MoE, híbrido Mamba, profundidad de razonamiento controlable y lo que esto significa para tu stack.

Casi descarto el Nemotron 3 Super en cuanto leí la ficha técnica.

“Modelo de 120B parámetros”. Ya me han engañado antes con eso. Modelos que necesitan ocho A100 para funcionar, producen resultados mediocres y quedan obsoletos en seis meses. El costo en GPUs es real, y honestamente, dejé de pagarlo.

Pero entonces vi un número que me hizo frenar: 12B de parámetros activos.

No es un error. NVIDIA ha construido un modelo de 120B donde solo 12 mil millones de parámetros se activan durante la inferencia. Si siguen la evolución de la eficiencia en IA, saben que esto cambia las reglas del juego por completo.

El truco del MoE que casi todos entienden mal

El Mixture-of-Experts (MoE) no es algo nuevo. La idea es simple: en lugar de una red gigante, tienes múltiples “expertos” y un sistema que decide cuál usar.

El problema es que, normalmente, el ruteo se hace a nivel de token, lo que genera una especialización muy superficial. Nemotron 3 Super hace el ruteo sobre representaciones latentes. Es decir, decide qué experto usar después de entender realmente el contexto.

El resultado:

• Tienes 120B de conocimiento, pero solo usas 12B activos por ejecución (incluso unos 3B según cómo se mida).
• El 90% del modelo está “inactivo”, pero sigue aportando calidad.
• Y lo mejor: no tienes que pagar por el costo de todo el modelo en producción.

Multi-Token Prediction: más velocidad para nosotros

NVIDIA también entrenó al modelo para generar múltiples tokens por paso. ¿En qué se traduce esto para el usuario? En mucha más velocidad de inferencia (más tokens por segundo en tu pantalla).

El problema de la atención… y cómo lo solucionaron

Los Transformers de siempre tienen un detalle: la atención escala de forma cuadrática. Si duplicas el contexto, el costo se cuadruplica. Aquí es donde entra Mamba (SSM):

• Procesa secuencias en tiempo lineal.
• Mantiene un estado comprimido en lugar de tener que revisar todo el historial una y otra vez.

¿El punto débil de Mamba? A veces le cuesta recuperar información muy lejana. La solución de NVIDIA fue crear un modelo híbrido Mamba + Transformer. Mamba aporta la eficiencia y el Transformer la precisión; el modelo decide internamente cuándo usar cada uno.

Reasoning ON vs OFF: Lo que no te están diciendo

El modelo viene con tres modos que podemos controlar:

1. Reasoning ON: Genera una cadena de pensamiento. Es ideal para lógica, código o planificación. Puede gastar entre 8k y 12k tokens solo "pensando".
2. Reasoning OFF: Te da una respuesta directa con una latencia mucho menor.
3. Low Effort: Un punto medio que reduce el razonamiento sin eliminarlo del todo.

Incluso podemos configurar un "reasoning_budget": 500. Esto es clave en producción para que los costos no se nos disparen.

Un detalle importante: Los tokens de razonamiento y la respuesta final llegan por separado en el streaming. Si solo leemos el contenido final, nos perdemos el proceso de pensamiento del modelo. Para quienes trabajamos con agentes, esto es crítico: el razonamiento te dice exactamente por qué falló algo.

Uso de herramientas en agentes

El modelo funciona con herramientas al estilo de OpenAI: planifica, llama a la herramienta, recibe el resultado y hace un razonamiento final.

Lo que me parece más interesante:

• Con Reasoning ON, el modelo verifica los resultados de las herramientas.
• Con Reasoning OFF, los acepta sin cuestionar. Esta distinción es vital para sistemas críticos donde no podemos permitirnos errores.

Por qué esto importa para tus agentes

Normalmente, estamos acostumbrados a usar un modelo caro para tareas difíciles y uno barato para las simples. El problema es la complejidad de gestión y la pérdida de calidad.

Con Nemotron, tenemos un solo modelo y múltiples modos:

• Planificación → Reasoning ON
• Llamada a herramienta → OFF
• Si hay un error → ON de nuevo para corregir.
• Respuesta final → Low Effort

Un solo despliegue. Un solo modelo. Menos fricción.

Limitaciones reales (porque no todo es color de rosa)

• Costo de razonamiento: Si lo dejas encendido, puede consumir miles de tokens por cada consulta.
• Acceso privado: Los benchmarks son prometedores, pero aún no están verificados a gran escala por toda la comunidad.

Conclusión: El futuro es "sparse"

NVIDIA nos está enviando un mensaje claro: el futuro no se trata de hacer modelos más pequeños, sino de hacer modelos grandes que sean inteligentes en cómo se usan.

La combinación de MoE latente, arquitectura híbrida y razonamiento controlable cambia el costo, el rendimiento y la viabilidad de nuestros proyectos. No es una mejora incremental; estamos entrando en otra liga.

Tip para tu stack: ¿Te gustaría que te ayude a crear una estructura de prompt o un JSON de configuración para implementar estos modos de razonamiento en tus propios agentes?

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.

El mundo del software no para, y lo que antes era "el futuro", hoy ya es nuestro día a día. Estamos en un momento increíble donde las nuevas tendencias están cambiando por completo cómo creamos tecnología. Ya seas una desarrolladora con años de experiencia, estés empezando o simplemente te apasione este mundillo, hay ciertos movimientos que no puedes ignorar.

Aquí te resumo, de forma sencilla, lo que más está sonando y por qué deberías prestarle atención:

1. IA y Machine Learning: Tus nuevos compañeros de equipo

La IA y el ML han dejado de ser conceptos de ciencia ficción para convertirse en herramientas de trabajo diarias. Ya no solo escribimos código; usamos la IA para ir más rápido, cazar errores antes de que aparezcan y automatizar lo aburrido. Herramientas como GitHub Copilot nos hacen la vida mucho más fácil a todas. Si estás empezando, entender cómo apoyarte en la IA te va a dar una ventaja competitiva brutal.

2. El boom del Low-Code y No-Code

Esto me encanta porque democratiza la creación de software. Estas plataformas permiten montar aplicaciones sin tener que picar código desde cero, usando interfaces visuales de "arrastrar y soltar". Es la opción ideal para validar ideas rápido o para empresas que necesitan soluciones ágiles sin montar un equipo de desarrollo gigante desde el primer minuto.

3. "Cloud-Native": La nube ya es el estándar

Ya no pensamos en servidores locales; la nube lo es todo. Con gigantes como AWS, Azure o Google Cloud, el enfoque ahora es crear aplicaciones cloud-native. ¿Qué significa esto? Que nacen directamente para ser rápidas, escalables y, sobre todo, mucho más eficientes en costes.

4. La ciberseguridad como prioridad (DevSecOps)

Con tantos datos circulando, la seguridad ya no puede ser algo que revisamos al final del proyecto. Ahora hablamos de DevSecOps, que básicamente es integrar la seguridad en cada paso del desarrollo. Aprender las bases de la ciberseguridad hoy en día es lo que hace que tus proyectos sean de verdad fiables.

5. Web3 y Blockchain: Más allá de las criptos

Seguro que te suena el Blockchain por el Bitcoin, pero la Web3 va mucho más allá: se trata de descentralizar internet. Estamos viendo aplicaciones súper interesantes en cadenas de suministro o sistemas de votación segura. Es un terreno lleno de oportunidades si te gusta investigar conceptos nuevos.

6. Desarrollo móvil: Una base de código, todas las plataformas

Gracias a herramientas como Flutter o React Native, ya no tenemos que elegir entre Android o iOS. Podemos desarrollar para ambos sistemas usando el mismo código, lo que ahorra muchísimo tiempo y dinero. Es, sin duda, la ruta más inteligente para el desarrollo móvil hoy en día.

7. Software sostenible: Código que cuida el planeta

Me parece precioso que la sostenibilidad también haya llegado al código. El desarrollo sostenible busca crear apps que consuman menos energía y recursos. No solo es mejor para el medio ambiente, sino que también hace que el software sea más eficiente y barato de mantener. Escribir código limpio y optimizado es tu granito de arena para el futuro.

¿Por qué deberías estar al tanto de esto?

Al final, entender hacia dónde va el barco te ayuda a decidir dónde poner tu energía y qué aprender a continuación. La tecnología cambia a una velocidad de vértigo, y mantenerte actualizada es lo que te permite seguir siendo relevante (y disfrutar del proceso).

Mi reflexión final

Estamos en un momento emocionante. La IA, el No-Code y la Web3 están abriendo puertas para que más personas formen parte de la creación tecnológica. Mi consejo es que elijas la tendencia que más te motive y empieces a explorar por ahí. ¡El futuro es ahora y hay hueco para todas! 🚀

Gracias por leer Código en Casa.
Si esto te a ayudado y te sumo algo Dale un 👏 , compártelo con tu red o dejame un comentario para saber tu opinión.