Atareao con Linux

Este es el primer episodio de una serie de cuatro que voy a dedicar a herramientas que he implementado y que uso en mi día a día. Las cuatro comparten stack: Rust en el backend y React con TypeScript en el frontend. Y la primera es, sin duda, una de las que más me facilitan la vida: Popuplatrs.

¿Te suena el ritual de publicar un artículo y tener que abrir Telegram, luego Mastodon, luego X, luego LinkedIn, luego Bluesky, y encima personalizar el texto para cada plataforma? Pues eso es exactamente lo que Popuplatrs elimina de tu día a día. Le das uno o varios feeds RSS, Atom o YouTube, y él se encarga de leer las novedades y publicarlas automáticamente en las redes que le configures. Con plantillas personalizables, programación de horarios, reintentos automáticos y un panel web desde el que controlarlo todo.

En este episodio te cuento por qué me decidí a crear esta herramienta, qué alternativas existen (Buffer, Hootsuite, IFTTT, Zapier) y por qué ninguna me convencía al ser SaaS o no estar pensadas para funcionar a partir de feeds. También te explico la arquitectura técnica: Rust con Axum, SQLite en modo WAL, autenticación OIDC con Pocket ID, y un sistema de plantillas con MiniJinja que te permite personalizar el mensaje para cada red social.

Popuplatrs soporta hasta nueve publicadores diferentes: Telegram, X (Twitter), Mastodon, Bluesky, LinkedIn, Threads, Discord, Matrix y OpenObserve para logging. Cada uno con su propia configuración de autenticación y límites de caracteres. Por ejemplo, en Bluesky publica respetando el límite de 300 caracteres, en X primero lanza el título y luego un reply con el enlace para aprovechar mejor el espacio, y en Discord usa webhooks que se configuran en segundos.

El sistema de plantillas es una de las partes que más me gustan. Usa MiniJinja, un motor compatible con Jinja2, y te permite definir plantillas distintas para cada plataforma. Puedes truncar el texto a un número de caracteres, limitar las palabras, eliminar HTML, y combinar el título con la descripción como más te convenga. Todo desde el panel web, sin tocar código.

Y por supuesto, te cuento cómo tenerlo corriendo en tu servidor en cinco minutos con Docker. Porque si algo me gusta es que las herramientas sean fáciles de desplegar.

Capítulos:
0:00 - Introducción: el problema de publicar en redes sociales
1:45 - Alternativas existentes y sus limitaciones
3:00 - Qué es Popuplatrs: origen, nombre y características principales
4:15 - Arquitectura técnica: Rust, Axum, SQLite y Pocket ID
5:45 - Fuentes soportadas: RSS, Atom y YouTube
7:00 - Publicadores: hasta nueve plataformas sociales
8:30 - Panel web: dashboard, logs y republicación de errores
10:30 - Programación, reintentos y control anti-spam
12:00 - Motor de plantillas y personalización por plataforma
13:30 - Despliegue con Docker Compose, Pocket ID y despedida

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Hoy te traigo un episodio que llevaba tiempo queriendo grabar. Y es que muchos estáis usando agentes de IA, pero los tenéis desnudos. Sin skills. Y un agente sin skills es como un Linux sin comandos: técnicamente funciona, tienes el kernel, tienes la shell, pero sin ls, sin grep, sin systemctl, no puedes hacer nada útil. El mejor modelo del mundo sin herramientas solamente es texto bonito.

En este episodio te cuento qué son exactamente las skills, por qué transforman un modelo de lenguaje en un asistente que hace cosas, y cuáles son las tres skills imprescindibles que todo agente debería tener. Una skill no es ni más ni menos que un prompt. Un conjunto de instrucciones que le dice a tu agente cómo tiene que hacer algo. No es un programa ni un script, es una receta de comportamiento. Y no necesitas ser programador para crearlas.

Te hablo de skills del sistema: leer archivos, ejecutar comandos, navegar por tu equipo. Skills de búsqueda: búsqueda web con SearXNG (que tengo montado en un Slimbook One y devuelve resultados en JSON que es una maravilla), búsqueda local con RipGrep que es increíblemente rápida, y búsqueda semántica con SQLite. Y skills de automatización: tareas programadas, webhooks que responden a eventos como un git push, o scripts orquestados que pueden hacer casi cualquier cosa.

Pero no me quedo ahí. Te doy las tres reglas de oro para crear tus propias skills. Porque los mejores skills son los que escribes para ti mismo. Primera regla: no digas "revisa el sistema", sino "ejecuta systemctl status --failed". Cuanto más específico, mejor. Segunda: define los límites. Qué puede hacer y qué no. Lo que no puede hacer es casi tan importante como lo que puede hacer. Tercera: ponle ejemplos. Cómo tiene que quedar el resultado, qué formato tiene que usar. Con estas tres cosas todo rueda mucho mejor.

También te cuento cómo organizar tus skills. Cada agente guarda los skills donde le da la gana: OpenCode en .config/opencode/skills, Hermes en .hermes/skills. Yo cada vez los guardo más en .agents/skills porque la mayoría de los agentes ya saben encontrarlos ahí. Y te hablo de los hubs de skills, donde puedes instalar skills creados por la comunidad con un solo comando.

Si usas OpenCode, Hermes Agent u Open Web y sientes que tu agente responde preguntas pero no hace cosas, este episodio te va a cambiar el día a día. Vamos directos al turrón.

Capítulos del episodio:

0:00 - Introducción: tu agente está desnudo

1:45 - ¿Qué es una skill? De un prompt a un asistente que hace cosas

4:15 - Skills del sistema: leer archivos, ejecutar comandos, navegar

7:30 - Skills de búsqueda: web con SearXNG, local con RipGrep, semántica con SQLite

11:00 - Skills de automatización: tareas programadas, webhooks, scripts orquestados

13:45 - Las 3 reglas de oro para crear tus propias skills

18:30 - El ecosistema de skills: dónde guardarlas y cómo organizarlas

21:00 - Ejemplo práctico: la skill del tiempo meteorológico

23:15 - Conclusión: un agente sin skills es Linux sin comandos

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Este episodio 828 es la carta de presentación de la Temporada 9 de atareao con Linux. Treinta y cuatro episodios ya guionizados, siete etapas, y un objetivo claro: construir tu cerebro digital sobre Linux con herramientas locales, sin depender de nubes ni suscripciones.

Pero antes de mirar adelante, toca hacer balance. La T08 empezó prometiendo Docker, selfhosting y Android, y sí, hablé de todo eso. Pero en abril de 2025 la IA local irrumpió con fuerza y la temporada viró hacia Ollama, modelos locales, RAG, MCP. Fue un giro desordenado, lo reconozco. Pero también fue el germen de todo lo que viene ahora.

De eso va esta T09: de poner orden al caos. Siete etapas, de menos a más, para que sigas el hilo hagas el nivel que hagas.

Etapa 1 — Recursos básicos: los cimientos de tu laboratorio de IA. Skills para tu agente, herramientas de publicación, el botiquín del explorador.

Etapa 2 — Skills y MCPs: el pegamento. El Model Context Protocol ha madurado hasta ser un estándar abierto — lo soportan Claude, ChatGPT, VS Code, Cursor. Ya no es un experimento, es el USB-C de la IA. Y de paso, herramientas del ecosistema atareao como watchbeat (monitor de uptime en Rust) y alloy (dashboard Docker con OIDC).

Etapa 3 — GraphRAG, el gran hito: de RAG vectorial a grafos de conocimiento. Mientras el RAG clásico devuelve fragmentos sueltos y tú unes los puntos, GraphRAG construye un grafo con entidades y relaciones. Preguntas como "qué contenedores están detrás de Traefik" pasan a ser una consulta directa a tu mapa de conocimiento. Usaremos LightRAG, que con 39.000 estrellas ya superó al Microsoft GraphRAG original. Esto ocupa tres episodios.

Etapa 4 — Multimedia: Whisper para speech-to-text, TTS local, ffmpeg, visión artificial, y el pipeline de YouTube a conocimiento con yt-dlp. Rematamos con RAG multimodal.

Etapa 5 — Orquestación: systemd timers, asyncio, just, y CrewAI para montar equipos de agentes.

Etapa 6 — Proyecto final: dos episodios para construir El Asistente que te Conoce y ponerlo en producción con Quadlets.

Etapa 7 — El futuro: mantenimiento de tu cerebro digital y hacia dónde va todo esto.

Entre medias, herramientas Linux: shuul, sqlite-utils, yq + jq, Rust en el kernel, Wayland vs X11, la guerra de los filesystems.

No necesitas una GPU de 3000 euros ni un doctorado. Con 16 GB de RAM y un CPU decente ejecutas modelos de 7B a 14B. Esto es IA local, en tu máquina, con tus datos.

Capítulos del episodio:
00:00 — Introducción y bienvenida a la Temporada 9
01:47 — Balance T08: de Docker y Selfhosting al boom de la IA
04:37 — El momento adecuado para cada tecnología
06:46 — El gran objetivo: tu cerebro digital
08:44 — Roadmap T09: 30 episodios ya guionizados
11:28 — Skills y MCPs imprescindibles
12:43 — GraphRAG: de RAG a grafos de conocimiento
14:01 — RAG vs GraphRAG: el mapa de tu conocimiento
17:28 — Herramientas del ecosistema: alloy, populater, watchbeat
20:08 — ¿Para quién es esto? De veteranos a escépticos
22:08 — No es hype: es un cambio de paradigma
24:30 — El momento perfecto para el linuxero

Toda la info y el roadmap completo en atareao.es/828.

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Cerramos la octava temporada con un episodio que me apetecía grabar desde hace meses. Igual te ha pasado como a mí: empecé hablando de un laboratorio de IA para cualquiera, y terminé recomendando GPUs de 3000 euros. Me fui creciendo, pero no hace falta. Te cuento cómo montar un laboratorio de IA local con el equipo que ya tienes. Da igual si tienes 8 GB de RAM o 16, CPU modesta o sin GPU. La clave está en elegir los modelos adecuados. Muchas veces nos perdemos buscando el modelo más grande, cuando con uno pequeño y bien cuantizado tenemos de sobra para el 80% de las tareas.

Te hablo de Ollama, el gestor de modelos estándar para ejecutar modelos locales. Más de 180.000 estrellas en GitHub, API compatible con OpenAI, modelos para todos los presupuestos: desde Phi 3.5 con 3.8B parámetros hasta Qwen 1.5B que ocupa 1 GB. También la cuantización: reduces la precisión numérica de los pesos para que ocupen menos y vayan más rápido. El punto dulce es Q4_K_M, que reduce el tamaño a menos de un tercio. Para 8 GB de RAM, Q3_K_S puede ser tu salvación.

También te hablo de Open WebUI, la interfaz que le da mil vueltas a ChatGPT. No solo chateas: tiene RAG local, Whisper integrado para transcribir voz (75 MB en CPU), TTS con Kokoro-82M para que el modelo te hable en tiempo real, búsqueda web, plugins y memoria persistente. Todo en un contenedor Docker que levantas con un solo comando.

Y de SQLite Vec, extensión de SQLite sponsorizada por Mozilla para búsqueda semántica sin servidores vectoriales. Ni ChromaDB, ni Qdrant, ni Milvus. C puro que funciona hasta en Raspberry Pi. Creas tablas virtuales para vectores de 768 dimensiones, generas embeddings con nomic-embed-text, y buscas por similitud coseno en milisegundos. RAG local sin complicaciones.

Y te explico cómo organizarlo todo con Docker o Podman. Un docker-compose.yml que levanta Ollama y Open WebUI en segundos, con healthchecks, redes separadas y volúmenes persistentes. También a limitar recursos con --memory y --cpus. He preparado scripts: inicialización que comprueba requisitos, crea directorios y descarga modelos; otro para descargar por niveles según tu hardware (nivel 1 para 8 GB, nivel 2 para 16 GB, nivel 3 para 32 GB); y uno de respaldo.

Y la estrategia híbrida local + nube, que es lo que realmente tiene sentido. El enfoque Minions del Stanford Hazy Research Lab: el modelo local hace el trabajo pesado, y solo consulta al grande en la nube para tareas complejas. El 90% de las consultas se resuelven localmente. Ahorras dinero, mantienes privacidad de tus datos, y cuando necesitas potencia, la tienes.

Con 16 GB de RAM y un SSD te sobra para el 80% de las tareas: traducciones, resúmenes, código, asistentes, RAG, transcripción de audio, texto a voz... Todo en tu máquina, sin enviar datos a servidores, sin suscripciones, sin depender de internet. Con 8 GB también puedes, con modelos más pequeños. Cerramos temporada, la novena arranca en el episodio 828.

Capítulos del episodio:
0:00 - Introducción — cierre de temporada 8 y replanteamiento
2:30 - Hardware mínimo: 8-16 GB RAM + SSD obligatorio
5:00 - Software base: instalar Ollama en tu distribución
7:30 - Contenedores: Docker vs Podman para el laboratorio
10:00 - Modelos pequeños: Phi 3.5, Qwen 1.5B y cuantización
13:00 - Herramientas complementarias: SQLite Vec, Whisper, TTS
16:00 - Organización del laboratorio: script y estructura de directorios
19:00 - Demo: probando Ollama en local con modelos ligeros
22:00 - Combinación local + nube: lo mejor de ambos mundos
24:30 - Cierre, avance temporada 9 y despedida

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Si llevas años usando Bash, Zsh o Fish y piensas que los pipes de Unix son lo más parecido a la perfección, este episodio te va a hacer tambalear los cimientos. Porque existe un shell que no pasa texto entre comandos: pasa estructuras de datos. Tablas, listas, registros, fechas, tamaños de archivo con tipo real. Y encima habla con Ollama sin que tengas que escribir ni una línea de Python.

Ese shell es Nushell. Está escrito en Rust, tiene más de 40.000 estrellas en GitHub, y su filosofía es sencilla: los pipes deberían transportar datos con tipo, no texto que luego parseas con awk, sed o jq.

En este episodio te cuento mi experiencia pasando de Fish a Nushell con ejemplos reales. Cuando escribes ls no obtienes texto: obtienes una tabla con columnas tipadas. Puedes hacer ls | where size > 1mb | sort-by size sin recurrir a awk ni números mágicos. El shell entiende qué es un filesize, qué es una fecha, qué es un número.

Y luego está open, que entiende el formato por la extensión: JSON, YAML, TOML, CSV, SQLite... todo se convierte en datos estructurados. Abres un SQLite y ejecutas consultas con query db. Y todo combinable: http get a una API, filtrar con where y guardar con save — en un solo pipeline, sin archivos temporales.

La guinda es la integración con IA. Como Nushell entiende JSON y Ollama habla JSON, se entienden a la perfección. Te enseño un pipeline que lista procesos, filtra los que consumen más de 100MB de RAM, se los manda a un modelo local, y mata el que más memoria usa. Todo en una línea. También te hablo de ai.nu, un módulo que envuelve Ollama, OpenAI y DeepSeek, con function calling desde el shell.

También hago una comparativa: Bash, Zsh, Fish y Nushell cara a cara. Bash funciona en cualquier sitio pero el manejo de datos es arcaico. Zsh es Bash con esteroides pero los pipes siguen siendo texto. Fish es moderno pero no entiende de tipos. Nu es el único con estructuras de datos de verdad. PowerShell fue el primero en pasar objetos, pero Nu es lo que PowerShell debería haber sido.

Capítulos del episodio:
0:00 — Introducción: de Bash a Fish, la evolución de las shells
2:30 — El problema del texto plano: por qué Nushell es diferente
5:00 — La trifecta: ls, where y select, SQL en tu terminal
7:30 — Tipos reales: la shell entiende fechas, tamaños y números
10:00 — Open: abrir JSON, CSV, YAML y SQLite sin herramientas externas
13:00 — Procesamiento avanzado: $in, save, append y par-each
15:30 — HTTP GET: APIs de GitHub y meteorología desde la shell
18:00 — Comparativa de shells: Bash vs ZSH vs Fish vs Nushell
21:00 — Nushell e IA: integración nativa con Ollama sin Python
24:00 — Instalación, casos de uso y conclusiones finales

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Hoy te voy a contar una historia que empieza con una idea brillante y termina con una buena dosis de frustración. Resulta que se me ocurrió construir mi propio agente de inteligencia artificial. Lo llamé Anacleto, está escrito en Rust, y la idea era tener un coordinador de agentes que delegara tareas según lo que le pidieras. El tiempo, el tiempo, y un puñado de bugs después, me he encontrado con que estoy aprendiendo mucho más de lo que pasa entre bambalinas que de lo que el agente realmente llega a hacer.

Y es que cuando le das una instrucción a un agente de IA —ya sea OpenCode, Claude, Hermes o el que tú quieras— no hay magia. Lo que hay es una coreografía compleja de mensajes que van y vienen, eventos que se disparan, herramientas que se invocan y un modelo de lenguaje que procesa todo después de que el agente lo haya pretratado. En este episodio abro la caja negra y te cuento exactamente qué hay dentro.

Te explico el viaje completo de un mensaje: desde que escribes el prompt hasta que obtienes la respuesta. Cómo funciona el streaming, cómo el modelo "piensa en voz alta" con los reasoning events, cómo decide qué herramientas usar con las tool calls, y cómo todo se monta en una batidora que reconstruye la información antes de enviarla al modelo. Y sí, el modelo no razona, simplemente predice. Pero la gracia está en que ahora no solo habla, también actúa. El modelo recibe una lista de herramientas disponibles y decide por sí mismo cuál usar según el contexto. No es programación tradicional de "si pasa A, usa la herramienta A". Es el modelo el que, basándose en su entrenamiento, predice qué herramienta le dará la mejor respuesta.

Y luego está el problema. El bucle. El modelo devuelve tool calls, el agente ejecuta las herramientas, vuelve a llamar al modelo, y así una y otra vez hasta que se alcanza el máximo de pasos y todo se para. No sé si es un problema de cómo he definido las llamadas, del motor o de las skills. Llevo días toqueteando, probando, cambiando cosas, y todavía no tengo claro dónde está el fallo. Lo que sí tengo claro es que unas skills bien preparadas dan mejores resultados que un modelo más potente. Y esa lección, por sí sola, ya ha valido la pena. Porque al final, la calidad de las instrucciones que le das al agente importa más que el modelo que uses por debajo.

Te cuento también por qué elegí Rust y Ratatui para la interfaz, en lugar de lo típico en Python o TypeScript. Spoiler: me lié más con el lenguaje que con el objetivo final, como suele pasar. Y te presento a los subagentes de Anacleto: uno para el tiempo, otro para noticias, otro para chistes, otro para investigar... cada uno con su propia personalidad y herramientas.

Capítulos del episodio:

Capítulos del episodio:

0:00 - Introducción: abriendo la caja negra de los agentes de IA
2:19 - El viaje de un mensaje: del prompt al modelo de lenguaje
3:49 - Arquitectura de agentes: coordinador, subagentes y la TUI en Rust
6:11 - El motor como director de orquesta: roles system, user, assistant y tool
8:27 - System prompt y optimización: delegación en subagentes especializados
11:13 - Streaming y server-sent events: cómo se construye la respuesta token a token
14:20 - Razonamiento y tool calls: el modelo predice, no piensa, pero actúa
17:59 - El bucle de herramientas: el problema de la delegación infinita en Anacleto
20:56 - Skills, subagentes desechables y sistema de permisos
25:16 - Demostración práctica de Anacleto: tiempo, chistes y noticias
29:22 - Conclusiones, redes y despedida

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¿Sigues usando find y grep como en los 90? Hace unas semanas me puse a buscar un archivo en un repositorio con git, lancé el find de toda la vida, y cuando volví de tomarme un café —literalmente— todavía seguía buscando. El problema es que find se mete en el .git, en los binarios, en sitios donde no debería. Y grep, pues lo mismo, sobre todo si trabajas con Unicode o con repositorios grandes. Así que llevo un tiempo usando fd y ripgrep, dos herramientas escritas en Rust que son órdenes de magnitud más rápidas. Pero lo mejor no es solo la velocidad: es que puedes combinarlas para crear pipelines que alimenten directamente a tu IA local.

fd (44.1k estrellas en GitHub) es un reemplazo directo de find. En los benchmarks oficiales, buscar archivos con fd -u tarda 0.8 segundos donde find necesita 11 segundos con -iname y casi 20 segundos con -iregex. 23 veces más rápido. Y no solo es velocidad: fd respeta .gitignore por defecto, soporta expresiones regulares directamente, y tiene placeholders como {}, {.}, {/} y {//} que te permiten ejecutar comandos sobre cada resultado con -x o pasarlos en lote con -X.

ripgrep (67.4k estrellas) es lo mismo pero para buscar texto. En el kernel de Linux, rg tarda 0.08 segundos donde grep tarda 2.67 segundos. 32 veces más rápido. Y tiene superpoderes que grep ni sueña: salida en JSON con --json, búsqueda en archivos comprimidos con -z, soporte PCRE2 con -P para lookaheads, y un flag --passthru que te muestra también las líneas que no coinciden. Desde la versión 15 también soporta hyperlinks OSC 8 y respeta repositorios de Jujutsu.

Pero lo que realmente me tiene enganchado es combinarlos. El patrón es sencillo: fd encuentra los archivos que te interesan, ripgrep extrae el contexto relevante, y todo eso se lo pasas a Ollama para que lo procese. Te enseño la función aresumen que me he montado en Bash, y su equivalente en Fish, para preguntarle a mi documentación local sin salir de la terminal. Cosas como "resume todo lo que he escrito sobre Ollama en el último mes" se resuelven con un pipeline de tres comandos. Sin RAG, sin bases de datos vectoriales, sin complicaciones. Solo con un pipe bien puesto y el modelo adecuado.

También te cuento cómo usar jq para procesar la salida JSON de ripgrep, cómo montar un buscador interactivo con fzf y bat, y los errores más comunes al construir estos pipelines. Si alguna vez has pensado "ojalá pudiera preguntarle a mis propias notas desde la terminal", este episodio te va a gustar. Y si todavía usas find y grep, te aseguro que después de oír los benchmarks no vuelves atrás.

Capítulos del episodio:
0:00 — Introducción: fd y ripgrep para alimentar a tu IA
2:30 — El problema con find y grep tradicionales
5:00 — fd: el find que siempre quisiste tener
8:00 — Placeholders y expresiones regulares en fd
11:00 — ripgrep: el grep con superpoderes
14:00 — Salidas estructuradas con JSON y jq
16:30 — La combinación estrella: fd + ripgrep con -x
19:00 — Pipelines avanzados para filtrar archivos
21:30 — Integración con IA local: fd + rg + Ollama
24:30 — Alias, funciones y trucos del día a día
27:00 — Despedida y conclusiones

Recursos mencionados:
- fd (sharkdp/fd): https://github.com/sharkdp/fd
- ripgrep (BurntSushi/ripgrep): https://github.com/BurntSushi/ripgrep
- Ollama: https://ollama.com
- jq: https://jqlang.github.io/jq/
- fzf: https://github.com/junegunn/fzf
- bat: https://github.com/sharkdp/bat

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Hoy toca dar un paso más. Hasta ahora usabas OpenCode como un asistente personal, le pedías algo y lo hacía. Pero, ¿y si necesitas algo más potente? ¿Alguien que investigue, alguien que escriba, alguien que lo optimice para SEO y alguien que lo revise todo? La respuesta no es un agente, es un equipo de agentes. En este episodio te cuento cómo he montado un sistema multi agente con OpenCode usando el patrón supervisor, y cómo coordino cinco agentes especializados sin que se pisen.

Te explico el pipeline completo de cinco fases. Primero la planificación, donde el coordinador define la estructura y los pasos a seguir. Luego la investigación, que corre a cargo del bibliotecario, un agente que solo busca información, no escribe, no opina, solo trae datos con sus fuentes. Después viene el redactor, que coge esos datos y escribe el artículo en Markdown con el tono de la casa. La cuarta fase es el SEO, donde un agente especializado pone el título, la meta descripción y las etiquetas sin tocar el fondo del artículo. Y por último la revisión, donde el editor verifica que todo está correcto y, si algo falla, lo devuelve al coordinador para que repita la fase que haya fallado. Todo esto forma un bucle de retroalimentación que diferencia un sistema multi agente bien hecho de cualquier otro.

Cada agente tiene su propio modelo, su propia temperatura y sus propios permisos. El investigador usa un modelo pequeño y barato porque solo necesita buscar. El redactor necesita un modelo más grande porque tiene que escribir con calidad. El revisor usa temperatura muy baja para ser lo más objetivo posible.

También te cuento los errores que me he encontrado. El más común es que el coordinador no delega. Le pides algo y en lugar de llamar al investigador, investiga él. En lugar de llamar al redactor, escribe él. Y el resultado es lo peor, porque el coordinador no es especialista en nada. La solución pasa por describirlo muy claro, con exclusiones en mayúscula: NO PUEDES HACER NADA, SOLO PUEDES DELEGAR. Otro error es dar permisos de más. Si todos pueden invocar Task, el investigador llama al revisor, este al SEO y se monta un follón.

Además hago una demo en vivo creando un artículo sobre FD, una herramienta en Rust que sustituye a find. Ves cómo el coordinador recibe la petición, planifica, lanza al investigador, luego al redactor, luego al SEO, luego al revisor, y en una sola iteración el artículo está aprobado. Con su título SEO, su meta descripción, sus etiquetas y su estructura en Markdown. Y todo esto no es programación. Es escribir artículos, preparar presentaciones o lo que se te ocurra. OpenCode no es solo un asistente para programar, es mucho más que eso. Y al final te cuento cuándo merece la pena usar multi agente y cuándo no. Porque para cambiar una bombilla no necesitas un equipo de cinco personas, necesitas un electricista.

Capítulos del episodio:

0:00 - Introducción: de ChatGPT a los agentes multi-propósito

2:28 - De asistente personal a equipo de agentes especializados

3:52 - Patrón supervisor: el jefe de obra que coordina sin ejecutar

4:50 - Pipeline de 5 fases: planificación, investigación, redacción, SEO y revisión

6:37 - La herramienta Task: delegación, contexto aislado y ventajas9:17 - Demo en vivo: creando un artículo sobre FD con subagentes

13:07 - Agentes especializados: investigador, redactor y SEO

18:56 - Control de calidad: el revisor y el bucle de retroalimentación

23:22 - El coordinador: la no ejecución como clave del éxito

24:58 - Errores comunes, cuándo usar multi-agente y despedida

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

Hace unos meses empecé a usar presentaciones para grabar el podcast, y enseguida me di cuenta de que el verdadero problema no es pensar el contenido, sino maquetarlo. Pasaba más tiempo ajustando fuentes, colores y transiciones que preparando lo que realmente quería contar. Así que me puse a buscar una solución, y lo que encontré me ha cambiado el flujo de trabajo por completo.

En este episodio te cuento cómo he montado typst-ia, un script en Python que genera presentaciones completas en segundos. Le dices un tema, la inteligencia artificial se encarga del contenido, y Typst lo convierte en un PDF impecable. Todo desde la terminal, sin abrir PowerPoint ni Google Slides, sin suscripciones mensuales, y con un control total sobre el resultado.

Typst es un sistema de composición moderno escrito en Rust que compila en milisegundos. Sí, has leído bien, milisegundos. Comparado con LaTeX Beamer, que tarda 5 o 10 segundos en compilar, Typst es un antes y un después. Además, su sintaxis es mucho más limpia y fácil de aprender. En el episodio lo comparo con LaTeX y con Markdown, y te cuento por qué creo que Typst se está convirtiendo en el estándar para presentaciones técnicas.

La clave del proceso está en el system prompt. Incrusto el template real de la presentación dentro del prompt que le envío a OpenRouter, y la IA genera código Typst válido sin necesidad de retoques. Uso DeepSeek Chat por defecto —cuesta unos 14 céntimos por millón de tokens de entrada, que vienen a ser cientos de presentaciones por menos de un euro—, pero también puedes usar Claude Sonnet, Gemini Flash o Llama 3.3 si necesitas más calidad o prefieres un modelo concreto.

El script completo son unas 200 líneas de Python sin frameworks, solo con la librería requests. Te explico paso a paso cómo funciona el pipeline: lee el template, construye el prompt, llama a OpenRouter, limpia la respuesta, escribe el archivo .typ, lo compila a PDF y lo abre en el visor. Y todo con flags para personalizar el número de diapositivas, el modelo, el nombre del archivo y hasta los reintentos si la compilación falla.

Para rematar, hago una demo en vivo generando una presentación desde cero. Ves cómo en cuestión de segundos pasamos de una idea a un PDF listo para proyectar. Y lo mejor es que el resultado es texto plano, versionable con Git, editable con cualquier editor, y sin ningún tipo de lock-in. Si mañana quieres cambiar algo, abres el .typ y lo tocas.

Si eres de los que hacen presentaciones técnicas, charlas, workshops, o simplemente quieres automatizar una tarea tediosa, este episodio te va a gustar. Y si nunca has oído hablar de Typst, te vas a llevar una sorpresa.

Capítulos del episodio:
0:00 - Introducción: presentaciones con Typst e IA
2:52 - El problema de las presentaciones tradicionales
5:20 - Typst: el sistema de composición moderno
7:34 - Typst vs LaTeX vs Markdown
8:31 - Instalación de Typst
9:28 - Plantillas para presentaciones con Typst
12:52 - OpenRouter y el prompt para la IA
15:28 - El script Python: el pipeline completo
17:41 - Demo en vivo: generando una presentación
24:17 - Conclusiones y despedida

¿Alguna vez te has dado cuenta de que la búsqueda exacta se queda corta cuando tu base de conocimiento crece? Buscar por palabras exactas con grep o FTS5 es rápido y preciso, pero es literal y no entiende contexto ni sinónimos. Por otro lado, la búsqueda semántica pura con embeddings a veces falla con términos muy específicos como rutas de archivos o comandos exactos.

En este episodio te muestro cómo solucionar este problema combinando lo mejor de ambos mundos mediante tres técnicas avanzadas de RAG:

• Búsqueda Híbrida (Hybrid Search): Cómo combinar FTS5 y embeddings semánticos utilizando un equilibrio ponderado (parámetro alpha).

• Re-ranking con Cross-Encoder: Refinamiento de resultados pasando de un bi-encoder rápido a un cross-encoder preciso para priorizar la máxima relevancia.

• HyDE (Hypothetical Document Embeddings): La técnica de generar un documento hipotético con un LLM local (Ollama) para encontrar notas mediante conceptos abstractos.

Además, repasamos cómo integrar todo esto en tu flujo de trabajo diario mediante herramientas CLI creadas en Python y Rust, así como la integración en Neovim con sqlite.lua.

Enlaces y recursos del episodio:

• Gist con los scripts en Python (Hybrid Search, Reranker y HyDE)

• Gist con la implementación del CLI en Rust (cerebro-cli)

• Notas completas del episodio en: atareao.es