Reflexiones sobre agentes IA, automatización y sistemas que funcionan
Puse a un agente de IA a manejar Fotos, Vista Previa y Telegram en mi Mac sin ninguna API, solo con el árbol de accesibilidad. Después medí qué le enseñan 23 apps. Lo que no puede leer, y lo que puede leer pero no pulsar, es lo mismo con lo que choca un lector de pantalla.
Leer más →
Un tuit proponía sacar ideas nuevas de los puntos vacíos de un espacio de embeddings. Lo probé con juegos de Steam, artículos de arXiv y patentes: ningún texto coherente llega a esos puntos, y lo que sale de ellos es un juego normal.
Leer más →
Afiné Laya, un modelo de decisión de pesos abiertos de 322M, con los mismos puntos en movimiento en los que fallaron los modelos de frontera. Con la receta oficial no aprendió nada; entrenado lo suficiente, aprendió a leer el orden de las fotos, pero solo con algunas semillas.
Leer más →
OpenAI y Anthropic han publicado, cada una por su lado, un algoritmo verificado en Lean que resuelve 3-SAT en tiempo subexponencial y refuta una hipótesis de 27 años sobre la que descansaban cientos de artículos. He leído los dos papers. Chocan con el mismo muro, lo atraviesan de la misma manera, y uno de ellos lo hace con una identidad de hace 200 años sacada de los octoniones.
Leer más →
Los agentes de programación pasaron del editor a la terminal, y de ahí a la nube y a las apps nativas. Cada salto subió lo que mira el humano: del código al diff y del diff al resultado. El siguiente saca al humano incluso del arranque.
Leer más →
Quité el campo, el balón y las camisetas y dejé solo puntos que se mueven. Un clasificador pequeño reconoce el deporte el 83 % de las veces; de cinco modelos frontera, solo uno demuestra que usa el orden de los instantes.
Leer más →
Cuando mi agente delega, suele dar por bueno el informe del subagente aunque este supiera menos que él. Lo medí en tres familias de modelos. Con el dato que lo contradice a la vista, casi nunca se lo cree. Lo que hace es no comprobarlo: el mismo texto se verifica si lo escribió un compañero, y no si lo escribió su propio subagente.
Leer más →
Matt Pocock dice que hay que diseñar más abstracciones para los agentes de código y reforzarlas con un lint estricto. Probé si el propio agente puede ser el diseñador, con tres palancas sobre código repetido en 384 cadenas de tareas. Una regla escrita y un lint de duplicación ayudaron a un agente de tres. Pedir el refactor ayudó a los tres, y lo que compra es sobre todo búsqueda, no diseño.
Leer más →
Pools de workers, procesos huérfanos, condiciones de carrera, idempotencia, inyección: informática de manual que la mayoría de desarrolladores podía dejarle a otro. Con varios agentes en paralelo pasa a ser problema tuyo, a diario.
Leer más →
Hace dos meses supuse que decirle a un modelo que ignore un pegado accidental podía dejar más residuo que no decir nada. 480 conversaciones pareadas después: lo deja, lo multiplica por seis, y el arreglo no es pedirlo con más énfasis.
Leer más →
Contradecir al usuario no levanta sospechas: las apaga del todo. 1.920 conversaciones para averiguar qué hace que un modelo se plantee que te has equivocado de ventana, y dos fallos del juez automático que solo aparecieron etiquetando a mano.
Leer más →
Un paper de sesenta páginas donde las demostraciones escritas, los teoremas comprobados por el kernel, los certificados exactos por cajas y el muestreo a secas se imprimen todos con la misma cara. Cuatro etiquetas, una por afirmación, y el caso que me hizo insistir en ellas: un certificado que daba verde justo en la configuración de la que dependía la prueba.
Leer más →
Pegué el contenido equivocado en 24 conversaciones a propósito y leí todas las respuestas a mano. Ni un solo modelo contempló que pudiera ser un error. Lo que varía no es si lo detectan, sino cuánto trabajo hacen sobre algo que no pediste.
Leer más →
Echas aros de calamar a la sartén y dos objetivos igual de razonables — que quepan cuantos más mejor, o que se dore la mayor superficie posible — resultan ser problemas distintos con respuestas distintas. Salvo que los tamaños cumplan una condición: entonces no solo coinciden, sino que dónde colocas cada aro deja de importar por completo.
Leer más →
Un sitio pierde el 98,7 % de sus impresiones de un día para otro y se queda ahí un mes. Sin acción manual, sin desindexación, 3.180 páginas indexadas y subiendo. Qué descartaron los números, qué replantearon y qué sigo sin poder explicar.
Leer más →
Audité las 35 memorias que mi agente guarda de este proyecto. Tres estaban obsoletas, y ninguna se había equivocado al escribirse: describían un estado que caducó solo. El 70% restante no admite comprobación, y eso no es un defecto.
Leer más →
La segunda mitad de mi réplica de SKILL.state, con el modelo del propio paper y un segundo modelo, y cada celda repetida. El estado explícito aguanta justo donde el paper dice. Donde falla, falla escribiendo mal el estado, y el runtime que conserva la historia al lado apenas lo nota.
Leer más →
La capacidad de conseguir que otro pueda hacerse cargo de tu trabajo sin necesitarte para cada decisión. Cómo preparar un relevo cuando trabajas con agentes: separar el estado actual de su historial y conservar los motivos.
Leer más →
Resolver problemas abiertos puede abrir preguntas nuevas. Qué ocurre si la IA aprende también a elegirlas, qué valor conserva comprender y qué debería premiar la academia.
Leer más →
Probé Jev para detectar fraude, revisar facturas y ayudarme a trabajar con agentes. Qué me ha servido, qué no y por qué algunas mejoras no pueden llegar a producción.
Leer más →
Cuándo conviene dar a la lógica de IA un bloque propio junto al frontend y al backend de aplicación. Casos reales, antecedentes y una alternativa más sencilla.
Leer más →
Un modelo del mundo puede estar rotundamente equivocado sobre toda una región, pasar cualquier test que sepas escribir y no costarte absolutamente nada — con demostración. Mueve ese mismo error unos metros, hasta el camino por el que algo pasa de verdad, y te cuesta todo. Lo que decide no es el tamaño ni la forma del error. Es el alcance.
Leer más →
Qué está documentado sobre benchmaxing y qué reveló un pequeño piloto con Opus 5 y Fable 5: fallos compartidos, empates, una intuición que las pruebas no confirmaron y una actualización con cinco modelos más.
Leer más →
Un modelo del mundo sintetizado puede equivocarse en toda una región, pasar cualquier gate de muestreo y no costar absolutamente nada — con demostración. Después abrí una puerta de 0.1 radianes en esa región y el peligro se derrumbó; escondí la misma puerta detrás del objetivo y siguió a plena potencia. Misma topología, peligro opuesto.
Leer más →
El trabajo que nunca se automatiza no es el difícil. Es el repetitivo que además pide un juicio en cada fila, y que ya se hace a mano dentro de una ventana de chat. Cualquier forma de dejar de hacerlo a mano te obliga a montar antes un producto: una cuenta con factura por tokens, un prompt que ahora hay que probar llamada a llamada de pago, y una interfaz para quien tenga que leer los resultados.
Leer más →
Réplica de SKILL.state, un paper de EMNLP que sustituye la historia de conversación de un agente por un estado explícito y mutable. El ahorro en tokens es real y el ahorro en la factura no: 7,5x se queda en 1,4x en cuanto activas la caché. Y donde el estado explícito gana de forma aplastante confirma el experimento de recuperación del propio paper, con una métrica que él no usa: el estado explícito aplica la corrección en 70 de 72 episodios, frente a 10 de 72 con el transcript completo.
Leer más →
Cambié el modelo de lenguaje por un random forest y pasé el mismo pipeline averiado por cuarenta agentes. Diecinueve de veinte parchean el síntoma a cada lado, con el modelo y sin él. Lo que separa a los dos brazos no es que investiguen menos: es de qué acusan a la cabeza. Al modelo lo llaman aleatorio por naturaleza; al bosque, no.
Leer más →
Le di a ciento cuarenta agentes el mismo clasificador averiado y cambié una sola cosa: si podían ver su código. Lo que se movió no fue a quién culpaban, sino si buscaban la causa siquiera. Y ninguno pidió los datos que le faltaban, ni cuando se le dijo expresamente que podía.
Leer más →
Los agentes que construyen sistemas con un LLM dentro recurren siempre a la misma explicación: el modelo no es determinista. Cinco veces no lo era, y lo interesante es adónde fue la sospecha en vez de adónde estaba la causa.
Leer más →
OpenAI ha publicado una demostración verificada en Lean de que las ecuaciones de Navier–Stokes en 3D pueden desarrollar una singularidad en tiempo finito. Cinco cosas que los titulares se saltan: el modelo no era Astra, la rotura ocurre justo donde el fluido deja de ser un fluido, la solución es una patinadora girando, una estantería de teoremas condicionales acaba de cambiar de estado, y la ruta la abrieron en Madrid dos matemáticos a los que nadie va a pagar.
Leer más →
Degradé cuatro repositorios de nueve formas semánticamente equivalentes y medí 2.929 corridas de agente. En código pequeño no pasa nada medible. En código grande e interconectado, degradar cómo está escrito reduce a la mitad lo que el agente resuelve.
Leer más →
Circula un diagrama de taxonomías, ontologías y knowledge graphs para agentes de IA. Se lee como una arquitectura que adoptar. Es más útil como diagnóstico: audité un proyecto mío y encontré cuatro definiciones incompatibles de su entidad central.
Leer más →
La IA ha abaratado radicalmente construir software, pero no encontrar clientes, validar el valor ni conseguir atención. Cuando hacer otra feature es lo fácil, el trabajo incómodo empieza al salir del editor.
Leer más →
Le quité a un agente la capacidad de ejecutar comandos, después el acceso al registro, y medí lo que cuesta. Luego corrí la misma matriz con dos modelos más débiles. La restricción costó un 26% más por ejecución; el más débil no fue a mirar ni una sola vez, y firmó catorce informes dando por publicada una versión que no existía.
Leer más →
En tres estudios, todos los instrumentos de medida que construí fallaron al menos una vez — y todos los fallos apuntaban hacia el resultado que yo esperaba. Sobre por qué 'mídelo' es un consejo incompleto, y lo que cuesta de verdad construir la referencia.
Leer más →
Casi todos los equipos que prueban un agente y vuelven en silencio a lo de antes no fallaron por falta de habilidad. Estaban haciendo la fontanería a mano — copiar, pegar, devolver la respuesta — y eso cuesta lo mismo todas las veces. Qué implica conectarlo de verdad, y qué parte tendrías que construir tú.
Leer más →
Mi preprint anterior concluía que los LLM traducen reglas y no las infieren. En control continuo eso resulta falso para un muro y cierto para un círculo: el modelo repara una regla 1D omitida en 105 de 111 intentos, y no recupera ni una sola vez la versión 2D — a través de ocho intervenciones diseñadas para arreglarlo.
Leer más →
Ocho líneas en un brief llevaron la detección de una release falsa de 8/15 a 15/15. La cláusula no dice dónde mirar: solo de quién es lo publicado.
Leer más →
Todos los consejos sobre trabajar con agentes dan por hecho que elegiste la herramienta. Mucha gente no. Qué cambia cuando la elección no es tuya — y qué argumento usar si lo es en parte.
Leer más →
Un informe externo dijo que el clasificador acertaba un 54% sobre 500 empresas. El gold set lo había generado un modelo genérico con las 500 de golpe, y sus etiquetas se podían adivinar desde el nombre de la empresa. La cifra defendible estaba veinte puntos más arriba. Sobre cuándo una IA puede evaluar a otra, y cuándo no.
Leer más →
Leí 179 mensajes reales entre sesiones paralelas de Claude Code: el canal casi nunca se usa para pedir cosas, sino para decirle al otro algo verdadero sobre su propio trabajo. Luego monté el experimento, y vi a una sesión cazar a otra publicando una release que no existía.
Leer más →
Ya sabes comprobar trabajo a escala: tests, CI, pipelines. Lo único es que no estás aplicando nada de eso al agente. Estás comprobando lo que produce a ojo, justo lo que llevas toda una carrera aprendiendo que no funciona.
Leer más →
Estaba convencido de que las skills prescriptivas le estorban a un modelo puntero, así que lo medí: ~640 respuestas y 147 ejecuciones de agente. Me equivocaba sobre dónde está el daño — y en cuanto el agente tiene herramientas, el beneficio desaparece y solo queda la factura.
Leer más →
Rendericé texto en imágenes y lo fui difuminando hasta que dejé de leerlo; después se lo pasé a seis modelos con visión y a dos motores de OCR. Leen texto con un contraste de un nivel de gris sobre 255 —invisible para mí— y algunos obedecen instrucciones escondidas ahí. El margen que me sacan no resulta ser mejor vista.
Leer más →
Los agentes planifican alrededor de cosas que nunca ocurrieron e inventan dependencias entre piezas que no dependen entre sí. Parece falta de reloj, así que lo medí: 572 respuestas, seis modelos, dos dominios. La fecha no cambia nada, y uno de los fallos empeora en los modelos más potentes.
Leer más →
Describiste lo que querías, un agente lo construyó y funciona. Esto es lo que aprender primero — no la lista entera, el orden. Escrito para quien nunca ha programado y no tiene intención de empezar.
Leer más →
Hoy puedes construir software sin escribir una línea. Lo que queda no es programar: es una forma de trabajar y una lista de cosas que tienes que saber que existen o nunca se te ocurrirá preguntar. Aquí están las dos.
Leer más →
Un filtro de seguridad asignó severidad media por autolesión a una cadena en base64. En dos de los tres modelos, dos jueces puntuando las mismas respuestas cifradas coincidieron peor que el azar. Un modelo base escribió cifrado impecable sin haber entendido nada. Tres sistemas emitiendo veredictos seguros sobre texto que no saben leer — y una conclusión mía que no sobrevivió a la tanda completa.
Leer más →
Un coda de la trilogía: perseguir el punto ciego del especialista me llevó a donde no esperaba. El balón más difícil de localizar no es el que vuela por el aire — es el que está perfectamente quieto.
Leer más →
Pasé las mismas 45 comparaciones ciegas por un juez GPT, uno Grok y uno Claude. Cada uno produjo un ranking distinto, cada uno favoreció sus propias respuestas, y el efecto crece con lo subjetiva que sea la tarea.
Leer más →
Abriendo la red diminuta que batió a los modelos frontera: diez números geométricos interpretables recuperan el 92% de lo que hace, la topología elegante no aporta nada, y el modelo resulta ser sobreconfiado justo en los casos que falla.
Leer más →
Defendí que un journey conversacional aportaba poco sobre un formulario bien diseñado. La decisión fue la contraria, así que lo construí — y el feedback del cliente zanjó la discusión mejor de lo que yo habría podido.
Leer más →
Una red diminuta entrenada en mi portátil resuelve los casos del balón oculto que los VLM frontera no pueden — y un estudio de transferencia entre dos deportes revela qué aprende exactamente un modelo sobre un juego.
Leer más →
Cuando el prompt deja de ser lo difícil, ocupa su lugar otra pregunta: qué modelo, con cuánto esfuerzo de razonamiento, para qué parte del trabajo. Elegir bien se está convirtiendo en una disciplina de ingeniería propia.
Leer más →
Un supuesto contraejemplo a una conjetura abierta 30 años surgió de prompts como 'haz un breakthrough' y 'sigue'. El oficio de escribir el prompt perfecto se está muriendo, y algo más interesante ocupa su lugar.
Leer más →
Le escondí el balón a varios modelos de visión-lenguaje y les pedí encontrarlo solo a partir de los jugadores. La respuesta fue interesante — pero lo más interesante fue lo cerca que estuve de concluir algo falso.
Leer más →
El próximo cambio de paradigma en el desarrollo de aplicaciones no es meter un agente en tu app — es meter tu app en el agente que tus usuarios ya usan. MCP es solo la fontanería actual para hacerlo.
Leer más →
Los agentes de IA acaban citando feedback interno, nomenclatura de specs y notas de proceso en entregables para clientes. Por qué ocurre, una taxonomía de los tres modos de fallo y las soluciones estructurales que funcionan de verdad.
Leer más →
El proceso real detrás de un preprint asistido por IA — y por qué la frontera más difícil no es la prosa, sino planear la ciencia, donde un modelo más capaz deja de ser una comodidad y pasa a ser lo que permite que el trabajo llegue más lejos.
Leer más →
Háblale a un modelo en un cifrado del que nunca le has dado la clave y ocurre algo sorprendente antes de que descifre nada: algunos modelos se niegan a jugar. Un pequeño experimento sobre cuán rápido descifran códigos nuevos — y dónde eso choca con un muro de seguridad.
Leer más →
Quise reproducir un resultado de DeepMind y acabé encontrando una forma limpia en la que la verificación te puede engañar: un modelo del mundo en código que pasa su gate al 100% de precisión, mantiene un 98% de acierto en los estados que visita un planificador, y aun así pierde sistemáticamente al jugar.
Leer más →
Karpathy sugirió dejar que un agente atascado reinicie en vez de insistir. Construí un loop con tests visibles y lo medí: iterar sobre el feedback gana a los reinicios limpios a igual cómputo — y darle al agente un botón de reinicio con alcance revela que saber *qué* descartar es lo que separa a los tiers.
Leer más →
Dile lo mismo a un modelo de lenguaje mucho más allá de lo que cualquier humano toleraría, y los pulidos no se rompen — se rinden en silencio. Pero quítale la capa de alineamiento y el modelo crudo degenera en bucles. Un pequeño experimento sobre lo que revela la repetición.
Leer más →
Un benchmark reciente dice que los agentes de código no colaboran porque les falta inteligencia social. Pruebo otra hipótesis: les falta estructura — y encuentro que hacer de la integración el trabajo de un solo agente recupera la colaboración, mientras que los conflictos de merge sobre todo enmascaran fallos semánticos más profundos.
Leer más →
Por qué los repositorios que se ejecutan en cloud workspaces y sesiones de IA necesitan un bootstrap reproducible para dependencias de sistema, tests y builds.
Leer más →
Cuando conviertes un LLM en un 'modelo del mundo' con pre-entrenamiento continuo, olvida conocimiento general en silencio — y un poco de mezcla de datos recupera casi todo. Pero cuánto olvida depende mucho de cómo lo especializas, y el fine-tuning completo paga tres costes que un solo benchmark subestima.
Leer más →
Los agentes hicieron construir casi gratis, y eso desnudó lo que en realidad comprabas: no el software, sino el mantenimiento, el desriesgo y tu atención. El buy-vs-build reescrito en torno al único recurso que no se paraleliza.
Leer más →
Revisar solía significar leer la implementación. Cada vez más verifico lo que el modelo produjo, no el camino que tomó — y lo que significa 'verificar el resultado' cambia muchísimo según si ese resultado es un número o un comportamiento.
Leer más →
Construyo sistemas cuya lógica de negocio no sabría recitar si me despertaras a las 3 de la mañana. El modelo la sostiene por mí, y está bien. La pregunta difícil no es cuánto delegas, sino si todavía sabes distinguir cuándo la respuesta está mal.
Leer más →
Dos filosofías de la demo a cliente — espectáculo mockeado vs prueba de concepto funcional — y por qué, con IA, la más vistosa esconde justo lo que importa: latencia y no-determinismo.
Leer más →
La UI generativa permite que un agente renderice widgets interactivos — formularios, gráficos, firmas — dentro del chat en vez de texto plano. AG-UI es el protocolo que lo estandariza, y yo ya llevo meses construyéndolo a mano.
Leer más →
Antes de escribir el prompt de un juez, debes tomar tres decisiones: el contexto, la unidad y la dimensión. Este es el marco, aplicado a evaluar mi agente de DevOps en producción.
Leer más →
Cómo construí un agente IA que investiga problemas de infraestructura de forma autónoma — con guardrails read-only, compactación de output, y conocimiento de infraestructura integrado en el system prompt.
Leer más →
Cómo una pregunta simple sobre la síntesis de vitamina D se convirtió en un artefacto de Claude, y después en una PWA completa con visualizaciones D3.js, notificaciones push y 6 idiomas.
Leer más →
Lo que escribimos se está convirtiendo en skills en markdown, lo que ven los usuarios se está convirtiendo en píxeles generados, y el medio cada vez es más fino. Una mirada a hacia dónde va el software en 2026.
Leer más →
La IA ya puede construir casi cualquier cosa. La dificultad ya no está en el código — está en gestionar tus propios límites cognitivos mientras orquestas múltiples agentes en paralelo.
Leer más →
Por qué la mayoría de los tests con IA deberían ser scripts reproducibles, no exploración con CLI — y cómo usar cada enfoque eficazmente, basado en experiencia real de automatización de despliegues.
Leer más →
Lecciones de escribir un ensayo de 16 capítulos con dos herramientas de IA — por qué la prosa es más difícil que el código para la IA, y qué funcionó realmente.
Leer más →
Cómo usé Claude Code para construir un pipeline de grabación, edge-tts para la narración, ffmpeg para el ensamblaje, y Gemini para validar el resultado — sin tocar un editor de vídeo.
Leer más →
Cómo construí un prototipo RLM que procesa 71 papers de arXiv (~1M tokens) sin inyectarlos en el prompt, usando análisis de documentos out-of-core con Azure OpenAI tool calling.
Leer más →
Cómo coordinar múltiples agentes de IA trabajando en paralelo usando la nueva funcionalidad Agent Teams de Claude Code dentro de una sesión de tmux.
Leer más →
Análisis de las implicaciones legales y éticas del 'Co-Authored-By: Claude' que aparece en los commits. ¿Herramienta o autor? El futuro de la propiedad intelectual del código IA.
Leer más →TypeScript proporciona barreras de seguridad esenciales para agentes de IA que escriben código, pero genera fricción con errores de tipos. La solución no es cambiar de lenguaje—es cambiar de flujo de trabajo con sub-agentes especializados.
Leer más →
Cómo construí un skill de Claude Code que estandariza y automatiza la creación de artículos bilingües, asegurando consistencia entre contenido EN/ES.
Leer más →
Un flujo de trabajo para ejecutar múltiples agentes Claude Code simultáneamente en diferentes funcionalidades, usando git worktree para gestionar ramas y automatizando las revisiones de PRs.
Leer más →
Cómo el filtro de contenido de Azure bloquea herramientas legítimas de automatización basándose en palabras, no en riesgo real—y soluciones simples que exponen el fallo.
Leer más →
Cómo construí un servidor MCP completo con 58 herramientas para gestionar repositorios, pull requests y pipelines de Bitbucket mediante lenguaje natural.
Leer más →