<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Leandro Valido on Medium]]></title>
        <description><![CDATA[Stories by Leandro Valido on Medium]]></description>
        <link>https://medium.com/@LeandroValido?source=rss-ba83af0679f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*6XQjKkxwUgsB8cz2.png</url>
            <title>Stories by Leandro Valido on Medium</title>
            <link>https://medium.com/@LeandroValido?source=rss-ba83af0679f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:21:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@LeandroValido/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Tu IA no necesita guardar tus datos personales para saber quién eres]]></title>
            <link>https://medium.com/@LeandroValido/tu-ia-no-necesita-guardar-tus-datos-personales-para-saber-qui%C3%A9n-eres-cfd4020e1eae?source=rss-ba83af0679f------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfd4020e1eae</guid>
            <dc:creator><![CDATA[Leandro Valido]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 18:46:54 GMT</pubDate>
            <atom:updated>2026-09-28T18:50:47.990Z</atom:updated>
            <content:encoded><![CDATA[<p>La inteligencia artificial está convirtiendo la privacidad en un problema de arquitectura, no solo de almacenamiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8MeQ8b-Wbhif3pPOe0NDjw.png" /></figure><p>Durante años, proteger la información personal fue un problema de ingeniería difícil, pero bastante claro. La receta la conocemos todos:</p><ol><li><em>encontrar los datos sensibles</em></li><li><em>clasificarlos</em></li><li><em>cifrarlos</em></li><li><em>restringir quién puede acceder</em></li><li><em>enmascararlos donde haga falta</em></li><li><em>definir cuánto tiempo se conservan</em></li><li><em>auditar quién los consultó</em></li><li><em>borrarlos cuando ya no se necesitan</em></li></ol><p>Todo esto parte de una idea muy simple: <strong>si sabemos dónde está el dato sensible, podemos protegerlo.</strong></p><p>La inteligencia artificial pone en duda esa idea. Un sistema de IA no necesita tu nombre, tu DNI, tu email ni tu teléfono para saber mucho sobre ti. A veces le alcanza con deducirlo.</p><p>Y eso cambia cómo tenemos que diseñar la privacidad.</p><p>Tres términos que vamos a usar</p><ul><li><em>PII (Personally Identifiable Information): cualquier dato que permite identificar a una persona, como nombre, documento, email, dirección o teléfono.</em></li><li><em>RAG (Retrieval-Augmented Generation): una técnica en la que el modelo, antes de responder, busca información en fuentes de la empresa y la usa como contexto.</em></li><li><em>Embeddings: representaciones numéricas (vectores) de un texto o documento. Permiten buscar por significado y se guardan en bases de datos vectoriales.</em></li></ul><h3>1. El modelo tradicional</h3><p>La mayoría de las organizaciones pasó años construyendo controles alrededor de los datos identificables.</p><p>Una arquitectura simplificada sería algo así:</p><p>Aplicación =&gt; API / Servicio =&gt; Autorización =&gt; Base de datos =&gt;</p><p>{</p><p>ID de cliente</p><p>Nombre</p><p>Email</p><p>Teléfono</p><p>Dirección</p><p>}</p><p>Los controles tienen un lugar claro donde aplicarse:</p><ul><li><em>la columna email se marca como sensible</em></li><li><em>la tabla de clientes tiene acceso restringido en los entornos de prueba, los datos de producción se enmascaran</em></li><li><em>cada acceso a la base queda auditado</em></li><li><em>el cifrado protege los datos guardados y los que viajan por la red</em></li></ul><p>No es fácil de hacer bien, pero el problema tiene límites.</p><p>Podemos señalar con el dedo dónde está la información sensible.</p><p>Con la IA, esos límites se vuelven mucho más borrosos.</p><h3>2. ¿Y si el dato sensible todavía no existe?</h3><p>Imaginemos una empresa de retail que registra información de sus clientes que parece totalmente inofensiva:</p><ul><li><em>rango de edad</em></li><li><em>ciudad</em></li><li><em>frecuencia de compra</em></li><li><em>categorías de productos</em></li><li><em>ticket promedio</em></li><li><em>horario de compra</em></li><li><em>devoluciones</em></li><li><em>dispositivo que usa</em></li><li><em>contactos con soporte</em></li><li><em>comportamiento de navegación</em></li></ul><p>Por separado, ninguno de estos datos parece peligroso. Pero si le damos acceso a todos ellos a un sistema de IA, el sistema puede encadenar señales hasta armar un perfil:</p><p>Datos crudos</p><p>↓</p><p>Señales de comportamiento</p><p>↓</p><p>Correlación</p><p>↓</p><p>Inferencia</p><p>↓</p><p>Perfil personal</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KK439ce6wq1Rg62Zh7LDQA.png" /></figure><p>El resultado puede ser información que nunca existió en ninguna base de datos.</p><p>Nadie creó una columna llamada</p><p>probable_crisis_financiera = true</p><p>Nadie guardó</p><p>probable_mudanza = true</p><p>Nadie le preguntó al cliente</p><p>probablemente_tiene_un_recien_nacido = true</p><p>Y sin embargo, un sistema lo bastante capaz puede deducir cosas como estas a partir del comportamiento.</p><h3>3. Minimizar datos ya no alcanza</h3><p>Una estrategia de privacidad clásica diría:</p><p>“No le mandamos PII al modelo.”</p><p>Es una buena práctica, pero puede no ser suficiente.</p><p>Supongamos que quitamos nombre, email, teléfono, documento y dirección exacta, y enviamos esto:</p><p>Edad: 42</p><p>Ubicación: aproximada</p><p>Cliente desde: 2014</p><p>Historial de compras: disponible</p><p>Transacciones: disponibles</p><p>Historial de dispositivos: disponible</p><p>Historial de soporte: disponible</p><p>Sacamos los identificadores obvios, pero dejamos intacta una huella de comportamiento muy distintiva.</p><p>Ejemplo</p><p>Hace más de veinte años,se demostro que la combinación de código postal, género y fecha de nacimiento alcanza para identificar de forma única a cerca del 87% de la población de Estados Unidos. Un historial completo de compras y dispositivos es muchísimo más revelador que eso.</p><p>Entonces la pregunta cambia. Ya no alcanza con preguntarse:</p><p>¿Qué información personal le damos al modelo?</p><p>También hay que preguntarse:</p><p>¿Qué información personal puede deducir el modelo a partir de lo que le damos?</p><p>No son la misma pregunta.</p><h3>4. Declarados, observados e inferidos</h3><p>Para pensar arquitecturas de IA sirve distinguir al menos tres capas de información personal:</p><p>Datos declarados</p><p>↓</p><p>Datos observados</p><p>↓</p><p>Datos inferidos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xhh34NW4MiPrfiLkvmB9iw.png" /></figure><ul><li><em>declarados: lo que la persona entrega de forma explícita (nombre, email, teléfono, fecha de nacimiento)</em></li><li><em>observados: lo que surge de su interacción (compras, clics, ubicaciones, dispositivos, inicios de sesión)</em></li><li><em>inferidos: lo que el sistema concluye a partir de las dos capas anteriores</em></li></ul><p>La IA multiplica el poder de la tercera capa.</p><p>Y los datos inferidos tienen una particularidad incómoda: la persona nunca los reveló. En algunos casos, ni siquiera la propia organización sabe que “tiene” esa información, hasta que alguien le hace al modelo la pregunta correcta.</p><p>Para normativas como el GDPR europeo, un dato inferido sobre una persona identificable sigue siendo un dato personal. Que no esté en una tabla no lo deja fuera de la ley.</p><h3>5. RAG: cuando se caen los muros entre sistemas</h3><p>Un asistente de IA corporativo puede tener acceso a varias fuentes a la vez:</p><p>Asistente de IA =&gt; {</p><p>CRM</p><p>Pedidos</p><p>Soporte</p><p>Analytics</p><p>Pagos</p><p>} =&gt;</p><p>Cliente</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LConPWGtfyFry7mArUansw.png" /></figure><p>Cada sistema, por sí solo, conoce apenas una parte del cliente:</p><ul><li><em>el CRM sabe quién es</em></li><li><em>e-commerce sabe qué compra</em></li><li><em>soporte sabe de qué se queja</em></li><li><em>analytics sabe cómo se comporta</em></li><li><em>pagos sabe cómo y cuándo paga</em></li></ul><p>Históricamente, esa separación funcionaba como una barrera natural: nadie tenía la foto completa.</p><p>RAG puede derribar esas barreras. La IA no necesita una base de datos con el perfil completo del cliente, porque puede armarlo en el momento, consulta a consulta.</p><p>Por eso la arquitectura de privacidad no solo tiene que controlar el acceso a los datos, sino también su <strong>composición</strong>.</p><h3>6. Embeddings: no son metadatos técnicos</h3><p>Muchas organizaciones tratan los embeddings como un artefacto técnico más, algo así como un índice.</p><p>Pero los embeddings se generan a partir de información real. Si los documentos de origen contienen datos personales, comportamiento de clientes o conversaciones de soporte, el vector resultante no puede tratarse como infraestructura inofensiva.</p><p>Preguntas que conviene hacerse</p><ul><li><em>¿quién puede consultar la base vectorial?</em></li><li><em>¿qué documentos generaron esos vectores?</em></li><li><em>si se borra el documento original, ¿su información sigue representada en algún vector?</em></li><li><em>¿cómo se aplican las políticas de retención?</em></li><li><em>¿pueden dos conjuntos de datos sin relación terminar conectados por una búsqueda semántica?</em></li><li><em>¿el contexto recuperado puede mostrarle a un usuario información que no estaría autorizado a ver?</em></li></ul><p>Son preguntas de arquitectura tanto como de privacidad.</p><h3>7. Logs: el repositorio de PII que nadie está mirando</h3><p>Los sistemas de IA generan muchísima información operativa:</p><ul><li><em>prompts</em></li><li><em>respuestas</em></li><li><em>documentos recuperados</em></li><li><em>llamadas a herramientas</em></li><li><em>decisiones de agentes</em></li><li><em>trazas</em></li><li><em>datasets de evaluación</em></li><li><em>logs de depuración</em></li><li><em>historiales de conversación</em></li></ul><p>Los desarrolladores la necesitan. Sin ella, depurar un sistema de IA es casi imposible.</p><p>Pero veamos qué puede contener una sola traza de producción:</p><p>Prompt del usuario</p><p>↓</p><p>Contexto recuperado</p><p>↓</p><p>Procesamiento del modelo</p><p>↓</p><p>Llamada a herramienta</p><p>↓</p><p>Respuesta del modelo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BAB4-Wlamr9YOdjwg44tuA.png" /></figure><p>Aunque la base de datos original tenga controles de PII excelentes, la plataforma de observabilidad puede terminar guardando copias o transformaciones de esa misma información, muchas veces con controles de acceso y retención más laxos.</p><p>Tu infraestructura de logging pasó a ser parte de tu arquitectura de privacidad.</p><h3>8. La frontera de la privacidad se movió</h3><p>En los sistemas tradicionales protegíamos el lugar donde vivía el dato personal.</p><p>Con IA, tenemos que proteger los lugares donde la información personal puede reconstruirse, correlacionarse, generarse o inferirse.</p><p>Bases de datos</p><p>+</p><p>APIs</p><p>+</p><p>Bases vectoriales</p><p>+</p><p>Prompts</p><p>+</p><p>Ventanas de contexto</p><p>+</p><p>Memoria de agentes</p><p>+</p><p>Llamadas a herramientas</p><p>+</p><p>Logs</p><p>+</p><p>Respuestas del modelo</p><p>+</p><p>Inferencias</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nNPNZ9sPmgMI2uDpqiMNpw.png" /></figure><p>Es una superficie de ataque mucho más grande.</p><p>Y decir “no le mandamos PII al LLM” no alcanza para cubrirla.</p><h3>9. La privacidad como propiedad de la arquitectura</h3><p>En sistemas de IA, la privacidad no puede ser solo un checklist de cumplimiento que se aplica cuando la arquitectura ya está diseñada.</p><p>Tiene que ser una propiedad de la arquitectura.</p><p>Preguntas para cada revisión de diseño</p><ul><li><em>¿a qué información puede acceder este modelo?</em></li><li><em>¿qué información puede correlacionar?</em></li><li><em>¿qué información puede inferir?</em></li><li><em>¿qué herramientas puede invocar?</em></li><li><em>¿con la identidad de quién se ejecutan esas herramientas?</em></li><li><em>¿qué contexto se persiste?</em></li><li><em>¿qué se registra en los logs?</em></li><li><em>¿cuánto tiempo se conserva esa información?</em></li><li><em>¿se puede rastrear una inferencia hasta sus fuentes?</em></li><li><em>¿puede el sistema olvidar cuando se borra el dato original?</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C8IqBCU5fK6_QGi2WXWVUg.png" /></figure><p>Estas preguntas llevan la privacidad a las revisiones de arquitectura, al modelado de amenazas, al diseño de autorización, a la observabilidad y a la ingeniería de plataforma.</p><h3>De proteger datos a proteger conocimiento</h3><p>Durante décadas, la ingeniería de privacidad se concentró en proteger datos. La IA suma otra tarea: proteger también el conocimiento.</p><p>No es lo mismo preguntarse</p><p>¿Qué datos guarda el sistema?</p><p>que preguntarse</p><p>¿Qué puede saber el sistema?</p><p>Las arquitecturas de seguridad tradicionales se volvieron bastante buenas respondiendo la primera pregunta. La IA nos obliga a empezar a responder la segunda.</p><p>Creo que ese será uno de los grandes desafíos de privacidad de la próxima generación de software.</p><p><strong>Tu IA no necesita guardar tus datos personales para saber quién eres.</strong></p><p><strong>A veces, solo necesita la información suficiente para deducirlo.</strong></p><p><em>Si trabajas diseñando sistemas con IA, me interesa saber: ¿cuál de estas preguntas es la más difícil de responder hoy en tu organización? Te leo en los comentarios.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfd4020e1eae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tu dinero cripto dependía de un dado… y casi nadie lo sabía]]></title>
            <link>https://medium.com/@LeandroValido/tu-dinero-cripto-depend%C3%ADa-de-un-dado-y-casi-nadie-lo-sab%C3%ADa-40b6a8012336?source=rss-ba83af0679f------2</link>
            <guid isPermaLink="false">https://medium.com/p/40b6a8012336</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Leandro Valido]]></dc:creator>
            <pubDate>Sat, 01 Aug 2026 02:28:28 GMT</pubDate>
            <atom:updated>2026-08-01T02:28:28.517Z</atom:updated>
            <content:encoded><![CDATA[<ul><li><strong>Robaron 38 millones de dólares en 25 minutos: qué pasó con Coldcard (explicado desde cero)</strong></li></ul><p><em>Una historia sobre por qué la seguridad en el mundo cripto depende, literalmente, de tirar los dados.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*ZDcGsPp-UH8r52egRhwOhA.png" /></figure><p>El 31 de julio de 2026, alguien vació carteras de Bitcoin ajenas y se llevó <strong>594 bitcoins — unos 38 millones de dólares — en apenas 25 minutos</strong>. Horas después, la cifra ya trepaba por encima de los 70 millones. No hubo un hacker entrando por la fuerza, ni una contraseña robada, ni un correo con enlace falso. El problema estaba escondido, desde hace más de cinco años, dentro de uno de los dispositivos considerados <strong>más seguros</strong> para guardar criptomonedas: el <strong>Coldcard</strong>.</p><p>Si no vivís en el mundo cripto, este caso puede sonar lejano. Pero es una de las mejores historias para entender cómo funciona — y cómo se rompe — la seguridad del dinero digital. Vamos por partes.</p><h3>Primero, tres conceptos básicos</h3><p>Para entender qué falló, hace falta entender tres ideas.</p><p><strong>1. “Ser tu propio banco” (autocustodia).</strong> En el sistema tradicional, tu dinero lo guarda un banco. En Bitcoin, mucha gente prefiere guardarlo ella misma, sin nadie en el medio. La frase famosa es <em>“</em><strong><em>not your keys, not your coins</em></strong><em>”</em>: si no controlás las llaves, las monedas no son realmente tuyas. La contracara es que toda la responsabilidad recae sobre vos. No hay un 0800 para reclamar (Ni defensa al consumidor).</p><p><strong>2. La “frase semilla” (seed phrase).</strong> Tus bitcoins no están “adentro” de ningún dispositivo. Lo que realmente importa es una llave secreta, que se representa como una lista de <strong>12 o 24 palabras en orden</strong>. Quien tenga esas palabras, tiene el dinero. Es la llave maestra de toda tu bóveda.</p><p><strong>3. La “billetera de hardware” (hardware wallet).</strong> Es un aparatito físico, algo así como un “pendrive con bitcoins” parecido a un pendrive o una pequeña calculadora, armado para generar y guardar esa frase semilla <strong>sin que nunca toque internet</strong>. La idea es que, aunque tu computadora esté infectada, tus llaves siguen a salvo dentro del aparato. El Coldcard, fabricado por la empresa Coinkite, es uno de los más respetados en este rubro.</p><p>Hasta acá, todo suena muy bien. Entonces, ¿qué salió mal?</p><h3>El corazón del problema: el azar que no era azar</h3><p>Toda la seguridad de una frase semilla se apoya en una sola cosa: que sea <strong>verdaderamente impredecible</strong>.</p><p>Pensalo así. Si tu llave se genera al azar entre muchas combinaciones posibles que ni la computadora más potente del planeta podría probarlas todas ni en miles de millones de años, estás a salvo. Ese “azar de calidad” es lo que en criptografía se llama <strong>entropía</strong>. Una frase semilla segura tiene el equivalente a unos <strong>128 bits de entropía</strong>: un número tan gigante que adivinarlo es, en la práctica, imposible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*sgGwgWQWytApwfQBXBbTSQ.png" /></figure><p>El Coldcard tenía un chip especial diseñado justamente para producir azar de altísima calidad, tomando pequeñas imperfecciones físicas del mundo real para que ningún resultado fuera predecible.</p><p><strong>Acá está la falla.</strong> En una actualización de software lanzada en <strong>marzo de 2021</strong>, apareció un error. En lugar de usar ese chip de azar real, el dispositivo empezó a usar — sin avisar a nadie — un método mucho más pobre: un generador de números “pseudoaleatorios” hecho por software, que en realidad partía de datos poco secretos del propio chip. En criptografía, esto es como pensar que tirás una moneda al aire pero en realidad siempre sale más o menos lo mismo.</p><p>El resultado: la entropía real cayó de los 128 bits deseados a alrededor de <strong>40 a 72 bits</strong>, según el modelo. Para el ojo humano, las 12 palabras seguían pareciendo aleatorias. Pero para una computadora, el universo de posibilidades se había achicado tanto que <strong>probar todas las combinaciones pasó de “imposible” a “cuestión de tiempo”</strong>.</p><h3>De un error silencioso a un robo relámpago</h3><p>Durante más de cinco años, ese error estuvo dormido. Miles de personas generaron sus llaves creyendo que eran impredecibles, cuando en realidad eran <strong>adivinables</strong>.</p><p>El 31 de julio de 2026, alguien lo descubrió y lo explotó. Al reducirse tanto las combinaciones posibles, el atacante pudo <strong>calcular por fuerza bruta</strong> las llaves de carteras reales — es decir, probar candidatos hasta acertar — y barrer los fondos. Como en Bitcoin cualquiera puede ver todas las cuentas (aunque no sepa de quién son), el atacante fue directo a las carteras vulnerables y las vació. En total, <strong>más de 1.100 direcciones</strong> fueron drenadas. Todo automatizado, todo en minutos.</p><p>Un detalle que dio que hablar: varios investigadores sospechan que se usó <strong>inteligencia artificial</strong> para detectar el patrón débil dentro del código abierto del dispositivo. Sea o no así, deja una lección incómoda: hoy, herramientas automáticas pueden auditar el código de cualquier billetera del mundo buscando fallas como esta.</p><h3>¿Quiénes estaban en riesgo?</h3><p>El problema afectó a las frases semilla generadas por varios modelos de Coldcard (Mk3, Mk4, Mk5 y Q) <strong>entre finales de 2020 y la corrección de julio de 2026</strong>, siempre que la persona hubiera dejado que el aparato generara el azar por sí solo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*ZDcGsPp-UH8r52egRhwOhA.png" /></figure><p>Hay una excepción curiosa y muy reveladora. Coldcard permite una opción manual: <strong>generar tu llave tirando dados de verdad</strong> (al menos 50 tiradas). Quienes usaron ese método <strong>no estaban en riesgo</strong>, porque el azar lo pusieron ellos con la mano, no el código roto. <strong>Es casi poético</strong>: el método más “antiguo” y analógico resultó ser el más seguro.</p><h3>Qué debía hacer un usuario afectado</h3><p>La empresa y los medios especializados fueron claros y urgentes: actualizar el software <strong>no alcanza</strong>, porque la llave débil ya estaba creada. La única solución real era <strong>generar una frase semilla nueva</strong> (con el error ya corregido, o en otro dispositivo) y <strong>mover los fondos ahí cuanto antes</strong>. Coinkite publicó una corrección el mismo día.</p><h3>Las lecciones para quien mira desde afuera</h3><p>Más allá de Bitcoin, este caso deja enseñanzas que valen para cualquiera.</p><p>La seguridad digital muchas veces <strong>se rompe en el lugar más invisible</strong>. Nadie robó nada por descuido del usuario: el fallo estaba en una línea de código que casi nadie miraba. La confianza se apoyaba en un supuesto — “el azar es bueno” — que dejó de ser cierto sin que nadie lo notara.</p><p>“Ser tu propio banco” <strong>tiene una contracara real</strong>. La autocustodia te libera de intermediarios, pero también te deja sin red de contención. No hay reversa, no hay reintegro, no hay reclamo. Por eso este incidente reavivó un viejo debate: para muchos inversores, productos regulados como los <strong>ETF de Bitcoin</strong> — donde un tercero se encarga de la custodia — empiezan a verse más atractivos, justamente porque trasladan ese riesgo a otro.</p><p>Y lo más contraintuitivo: a veces <strong>lo simple es lo más seguro</strong>. Quienes desconfiaron de la automatización y tiraron los dados a mano se salvaron. No porque supieran más, sino porque no delegaron ciegamente en el código la parte más crítica.</p><p>El caso Coldcard no significa que las billeteras de hardware sean malas — siguen siendo de lo más seguro para guardar cripto — , sino que <strong>ninguna tecnología es infalible</strong>, por más buena reputación que tenga. En un mundo donde vos sos el único responsable de tu dinero, entender <em>por qué</em> algo es seguro importa tanto como confiar en que lo es.</p><h3>Fuentes</h3><p>• <a href="https://www.coindesk.com/business/2026/07/31/coldcard-s-usd38-million-so-far-exploit-shakes-faith-in-self-custody-may-push-investors-to-etfs">Coldcard exploit reignites Bitcoin self-custody debate after $38 million theft — CoinDesk</a></p><p>• <a href="https://www.coindesk.com/tech/2026/07/31/major-bitcoin-wallet-flaw-drains-594-btc-in-25-minute-sweep">Major bitcoin wallet flaw drains 594 BTC in 25-minute sweep — CoinDesk</a></p><p>• <a href="https://bitcoinmagazine.com/news/coldcard-security-risk-immediate-action-required">COLDCARD SECURITY RISK: IMMEDIATE ACTION REQUIRED — Bitcoin Magazine</a></p><p>• <a href="https://bitcoinmagazine.com/news/coldcard-wallet-exposed-after-bitcoin-hack">Coldcard Wallet Flaw Exposes Years Of Bitcoin Seeds After $70M In BTC Stolen — Bitcoin Magazine</a></p><p>• <a href="https://www.techtimes.com/articles/322392/20260731/coldcard-hardware-wallet-hacked-via-firmware-bug-that-bypassed-rng-five-years.htm">Coldcard Hardware Wallet Hacked via Firmware Bug That Bypassed RNG for Five Years — Tech Times</a></p><p>• <a href="https://cybernews.com/security/ai-suspected-coldcard-bitcoin-wallet-theft/">AI might have helped hackers steal $38M in bitcoin — Cybernews</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40b6a8012336" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Secure by Default: cuando la plataforma se vuelve el perímetro]]></title>
            <link>https://medium.com/@LeandroValido/secure-by-default-cuando-la-plataforma-se-vuelve-el-per%C3%ADmetro-6b170b8a478b?source=rss-ba83af0679f------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b170b8a478b</guid>
            <dc:creator><![CDATA[Leandro Valido]]></dc:creator>
            <pubDate>Mon, 27 Jul 2026 16:49:29 GMT</pubDate>
            <atom:updated>2026-07-27T16:49:29.999Z</atom:updated>
            <content:encoded><![CDATA[<h3>Por qué la premisa que sostuvo la seguridad durante décadas dejó de alcanzar el día que el software empezó a decidir solo.</h3><p>Llega un momento para todo aquel que trabajó en una iniciativa sería de IA que la pregunta cambia de color. Deja de ser “<em>¿esta aplicación es vulnerable?” para convertirse en otra bastante más potente “¿qué va a decidir hacer esta aplicación que yo no escribí?”. Es en ese momento, aunque cueste admitirlo, que el desafió aparece.</em></p><p>A lo largo del tiempo, crear una plataforma segura y escalable, era una tarea que se podía hacer siguiendo una receta predefinida. Una plataforma necesita autenticación, autorización, administración de secretos, auditoría, aislamiento. Las aplicaciones que hacían uso de la plataforma usaban esta capacidad y listo. Un modelo predictivo por diseño: El dev escribe código, con comportamientos que alguien ya definio. ¿Por qué algo podía salir mal? La mayoría de las veces era por algún bug. Había un log, una razón, o similar que explicaban fácilmente que paso.</p><p>Ese paradigma funcionó. Funcionó muy bien, de hecho, durante un montón de años. Pero la IA vino y rompió una premisa fundamental: <strong>una parte del comportamiento de la aplicación ya no la escribe un desarrollador. La decide, en tiempo de ejecución, una LLM.</strong> Vale la pena leerlo dos veces, porque no es un detalle menor. Cambia por completo la superficie de ataque.</p><h3>Qué prometía — y qué no — “secure by default”</h3><p>Conviene desarmar el término, porque se malinterpreta seguido. <em>Secure by default</em> nunca prometió que una aplicación fuera imposible de vulnerar. Prometió algo más concreto y más útil: que la plataforma trae la seguridad <strong>activada de fábrica</strong>, de modo que cada equipo pueda construir algo seguro sin reinventar los controles básicos cada vez.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dd4hAlO04kKbKSa6KIIDBg.png" /></figure><p>Es la misma lógica conocida de un <em>Internal Developer Platform</em>: pedís una base de datos, no instalas un motor. En seguridad es equivalente. Una plataforma moderna ofrece, sin necesidad de programarlo: autenticación centralizada, gestión de secretos, autorización, logs, auditoría, políticas de red y aislamiento de cargas de trabajo. El desarrollador los <strong>consume</strong>; no los implementa desde cero.</p><p>El corolario es el que importa: la seguridad deja de depender del equipo que escribe la aplicación y pasa a ser una capacidad provista por la plataforma. Ese mismo principio debería aplicarse a las plataformas de IA. El problema es que los controles que hacen falta ya no son exactamente los mismos.</p><h3>Por qué la IA cambia las reglas</h3><p>Un servicio tradicional se comporta de manera aburrida, y eso es una (gran) virtud. Recibe una request, ejecuta un conjunto de instrucciones conocidas, devuelve una respuesta. Siempre igual.</p><p>Un agente no juega ese juego. En una misma tarea puede decidir qué herramienta usar, generar código, consultar múltiples fuentes, ejecutar workflows, decidir cuándo volver a preguntarte algo e incluso cambiar el orden de ejecución de un proceso. Ya no solo <em>procesa</em> información: <strong>también toma decisiones.</strong> Y esas decisiones cambian en cada corrida.</p><p>Desde la seguridad, la consecuencia es incómoda: una parte importante del comportamiento de la aplicación deja de ser determinística. No hay un log de código que puedas leer de arriba a abajo para saber qué va a pasar, porque una parte se resuelve en tiempo real dentro del modelo.</p><h3>El agente es un tercer actor, no una librería</h3><p>Durante años pensamos las identidades de un sistema en dos categorías: <strong>usuarios</strong> y <strong>servicios</strong>. Los agentes fuerzan una tercera.</p><p>Y no es una categoría cosmética. Un agente no es simplemente otra API: puede actuar en nombre de un usuario, invocar herramientas, consultar documentación, tomar decisiones intermedias y ejecutar acciones sobre otros sistemas — muchas veces de forma autónoma, sin que nadie apriete un botón en el medio.</p><p>La decisión de arquitectura es tratarlo como una <strong>identidad de primera clase</strong>, con sus propios permisos, sus propios límites y su propia auditoría. No como una librería que casualmente le habla a un LLM. El día que un agente puede accionar sobre tus sistemas con autonomía, degradarlo a “detalle de implementación” es exactamente el error que después no vas a poder auditar.</p><h3>Riesgos que antes no existían</h3><p>Una plataforma tradicional rara vez tenía que preocuparse porque un servicio decidiera, espontáneamente, ejecutar una operación distinta a la pedida. Con agentes, eso ocurre. Y arrastra una familia de riesgos nueva:</p><ul><li><strong>Prompt injection:</strong> instrucciones maliciosas escondidas en el contenido que el agente lee, que terminan reescribiendo su comportamiento.</li><li><strong>Tool abuse:</strong> una herramienta legítima usada de una forma que nadie previó.</li><li><strong>Filtración vía RAG:</strong> datos sensibles que se filtran a través de las fuentes que el agente consulta.</li><li><strong>Generación y ejecución de código</strong> que nadie revisó.</li><li><strong>Uso inesperado de herramientas.</strong></li><li><strong>Escalada de privilegios entre agentes.</strong></li><li><strong>Acciones irreversibles ejecutadas sin supervisión.</strong></li></ul><p>El punto de fondo: la mayoría de estos riesgos <strong>no se resuelven con buenas prácticas de desarrollo.</strong> No alcanza con pedirle a cada equipo que “programe con cuidado”. Necesitan controles incorporados en la propia plataforma.</p><h3>La plataforma pasa a ser el perímetro</h3><p>El error más caro al empezar a construir con IA es asumir que cada equipo va a implementar sus propios mecanismos de protección. En la práctica eso siempre deriva en lo mismo: modelos de autenticación distintos, políticas de autorización diferentes, validaciones incompletas y niveles desparejos de observabilidad. Multiplicá eso por la cantidad de equipos y tenés una superficie imposible de gobernar, con cara de autonomía.</p><p><strong>La decisión:</strong> mover esa responsabilidad al nivel de infraestructura. Es la plataforma la que define cómo se autentican los agentes, qué herramientas pueden invocar, cómo se auditan sus acciones, dónde pueden ejecutar código, qué conocimiento pueden consultar y qué operaciones requieren aprobación humana.</p><p><strong>El tradeoff:</strong> alguien tiene que poseer y operar esa capa de seguridad transversal; deja de ser gratis y difuso para volverse un <em>ownership</em> explícito. <strong>La ganancia:</strong> cada agente nuevo <strong>nace</strong> con un set de controles ya incorporado, en lugar de depender de decisiones sueltas tomadas equipo por equipo. La seguridad deja de ser un acto de disciplina individual y pasa a ser una propiedad del sistema.</p><h3>Cierre</h3><p>Diseñar una plataforma de IA ya no consiste solo en abstraer el acceso a modelos de lenguaje. Consiste en definir el entorno donde los agentes operan de manera segura desde el primer día. Es el mismo movimiento que ya hizo el mundo cloud-native: la seguridad deja de ser responsabilidad exclusiva de cada aplicación y se convierte en una capacidad transversal de la plataforma.</p><p>La pregunta, entonces, deja de ser <em>“¿esta aplicación es segura?”</em>. Pasa a ser <em>“¿sobre qué plataforma corren, de forma segura, todos los agentes?”</em>.</p><p>En los próximos capítulos voy a ir desarmando esos controles uno por uno — autenticación de agentes, gobierno de herramientas, aislamiento de ejecución, human-in-the-loop — y qué cuesta incorporar cada uno desde el diseño, para construir plataformas de IA que sean, de verdad, <em>secure by default</em>.</p><p><em>Si trabajás en plataformas de IA, seguridad de agentes o arquitecturas de este tipo, me encantaría leer cómo lo están resolviendo ustedes. Dejá tu comentario o escribime por LinkedIn.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b170b8a478b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Secure by Default: cómo se le da (y se le quita) poder a un agente de IA]]></title>
            <link>https://medium.com/@LeandroValido/secure-by-default-c%C3%B3mo-se-le-da-y-se-le-quita-poder-a-un-agente-de-ia-3d69f2910591?source=rss-ba83af0679f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d69f2910591</guid>
            <dc:creator><![CDATA[Leandro Valido]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 15:37:56 GMT</pubDate>
            <atom:updated>2026-07-21T15:37:56.337Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Doce formas de responder a la misma pregunta incómoda — “¿este agente puede hacer esto?” — y cómo se combinan en una plataforma que se toma la seguridad en serio.</em></p><p>En la nota anterior recorrimos la <strong>anatomía de un Agent Development Platform</strong>: las capas que separan “tengo agentes corriendo” de “tengo una plataforma de agentes gobernable”. Había una capa que se merecía un capítulo aparte, porque es la que decide qué puede tocar cada agente y qué no: la <strong>autorización</strong>. Este es ese capítulo.</p><p>Antes de empezar, conviene separar dos palabras que solemos usar como sinónimos y no lo son. <strong>Autenticación</strong> (AuthN) responde <em>¿quién sos?</em>. <strong>Autorización</strong> (AuthZ) responde <em>¿qué podés hacer?</em>. Es la diferencia entre mostrar tu documento en la recepción de un hotel (te identificás) y la tarjeta que después te abre <em>algunas</em> puertas y no todas (te autorizan). Podés estar perfectamente identificado y aún así no tener permiso para entrar a la sala de servidores.</p><p>Con software tradicional esto ya estaba más o menos resuelto, porque en escena hay dos actores: un usuario y un servicio. Los agentes de IA rompen esa comodidad e introducen un <strong>tercer actor</strong>. Ahora hay un usuario, un agente y un recurso. Y el agente es un principal raro: no es una persona, pero tampoco es un servicio pasivo que espera órdenes exactas. Puede trabajar solo, de madrugada, a escala, y — este es el punto fino — cuando no sabe algo, <strong>lo infiere</strong>. Es un proceso probabilístico, no determinista.</p><p>Por eso “<strong>secure by default</strong>” con agentes significa algo muy concreto: no repartir poder por defecto. Dar el mínimo indispensable, que sea verificable y que se pueda revocar. La industria no inventó una sola respuesta a esto, sino toda una familia de esquemas. Vamos a recorrer los siete más importantes — cada uno con su diagrama — y después a ver cómo se apilan en una plataforma real.</p><h3>1. User Delegation — el agente usa tu identidad prestada</h3><p>Es el modelo más común hoy. El usuario se autentica (con OIDC, OAuth2, SAML, lo que sea) y el agente recibe un <strong>token delegado</strong>. Con ese token va y hace cosas <em>como si fuera vos</em>.</p><p>La analogía: le prestás tu tarjeta de acceso a un asistente para que te traiga algo del archivo. No tiene tarjeta propia; usa la tuya, y solo abre las puertas que la tuya ya abría.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*EC31WsQKsHoP4hw4DUX2Xw.png" /></figure><p>El agente nunca tiene identidad propia: usa la del usuario.</p><p><strong>Ventajas:</strong> es simple, es auditable y respeta los permisos que el usuario ya tenía — el agente no puede hacer nada que vos no pudieras hacer — . <strong>Desventajas:</strong> el agente no puede trabajar cuando el usuario no está presente, los tokens expiran y los procesos largos se vuelven un dolor de cabeza. Ejemplo típico: <em>“Buscá mis mails y resumilos”</em> — el agente llama a Gmail con el token del usuario y listo.</p><h3>2. Agent Identity — el agente como “empleado” con legajo propio</h3><p>Acá el agente <strong>tiene identidad propia</strong>, parecida a un <em>Service Account</em>. Ya no depende de que vos estés logueado: es una entidad por derecho propio, con sus credenciales.</p><p>La analogía: en vez de prestarle tu tarjeta, la empresa le da al agente su <em>propio</em> legajo y su propia tarjeta, con su propio nivel de acceso. Aparece un nuevo principal en escena.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*RPUeBk9ii--7lMCgV0KUrQ.png" /></figure><p><strong>La ganancia:</strong> puede trabajar offline, escala bien y es ideal para automatizaciones que corren sin nadie mirando. <strong>El problema que abre:</strong> si el agente tiene identidad propia, <em>¿cómo limitás lo que puede hacer?</em> Un legajo propio sin límites claros es exactamente lo que no querés. De esa pregunta nacen casi todos los esquemas que siguen.</p><h3>3. Impersonation — identidad propia, pero actuando “en nombre de”</h3><p>Muy usado en empresas. El agente tiene identidad propia (como en el punto anterior), pero ejecuta cada acción <strong>en nombre de</strong> un usuario concreto. Es una combinación elegante: no perdés al agente como actor, pero tampoco perdés la trazabilidad de por quién está trabajando.</p><p>La analogía: el asistente firma con su nombre <em>y</em> aclara “por orden de Juan Pérez”. Cuando algo llega al recurso, quedan registrados los dos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*yaMVKPekPlIL-ieCiOsN1w.png" /></figure><p><strong>La ganancia:</strong> mejora muchísimo la auditoría. Sabés que fue el agente, pero también sabés a cuenta de quién. Cuando algo sale mal a las tres de la mañana, esa doble huella es oro.</p><h3>4. Policy-Based Authorization (ABAC) — decidir por reglas, no por listas</h3><p>En vez de mantener listas de “quién puede qué”, las decisiones se toman evaluando <strong>políticas</strong> sobre atributos: quién es el usuario, qué tipo de agente es, qué recurso toca, desde dónde, a qué hora. Es <em>Attribute-Based Access Control</em>.</p><p>La analogía: en vez de tener una lista de invitados en la puerta, hay una regla — “dejá pasar a mayores de edad del área de Finanzas con entrada válida” — y el guardia la aplica caso por caso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*VYql4GZoAKqe_DH4tjTxug.png" /></figure><p>Motores típicos: Open Policy Agent (OPA) · Cedar · Casbin</p><p><strong>La ganancia:</strong> es mucho más flexible que el clásico RBAC (roles fijos). Cambiás una política y se aplica en todos lados, sin repartir permisos de a uno. <strong>El costo:</strong> alguien tiene que escribir, versionar y probar esas políticas — una política mal redactada falla en silencio.</p><h3>5. Relationship-Based Authorization (ReBAC) — el permiso sale del grafo</h3><p>Este es especialmente interesante para IA. Las decisiones no dependen de reglas ni de listas, sino de <strong>relaciones</strong>. Si Carlos <em>es dueño</em> de Project X, y el agente trabaja <em>para</em> Carlos, entonces el agente hereda acceso al repositorio de Project X. Nadie asignó ese permiso a mano: <strong>surge de un grafo</strong>.</p><p>La analogía: no hay una lista de quién entra a la casa; entrás porque sos de la familia. El permiso se deduce de tu relación, no de un papel que alguien firmó.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*3cSg6eIClKGzaTyCNEE1yg.png" /></figure><p>El permiso se deduce de la cadena de relaciones:</p><p>Owner ──► Team ──► Workspace ──► Repository</p><p>No hace falta asignar permisos manuales.</p><p>Motores conocidos: OpenFGA · SpiceDB</p><p><strong>La ganancia:</strong> escala naturalmente en organizaciones donde todo está conectado con todo, y evita el infierno de mantener miles de asignaciones sueltas. Es el modelo que popularizó Google internamente (Zanzibar) y que hoy está detrás de varios motores open source.</p><h3>6. Just-in-Time Authorization — permisos que se autodestruyen</h3><p>El agente <strong>no tiene permisos permanentes</strong>. Antes de cada acción, los pide. El motor de políticas evalúa, entrega una <strong>credencial temporal</strong>, el agente la usa y esa credencial se muere sola.</p><p>La analogía: en vez de una llave maestra que el agente lleva siempre encima, cada vez que necesita entrar a un cuarto pide una tarjeta descartable que sirve para <em>esa</em> puerta y por <em>unos segundos</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*WK59wDPIB8Nul7FTxueYXg.png" /></figure><p><strong>La ganancia:</strong> reduce drásticamente la superficie de ataque. Si una credencial se filtra, ya no sirve para nada. Muy usado para operaciones críticas, donde un permiso permanente sería una bomba de tiempo.</p><h3>7. Approval-based Authorization — el humano en el medio</h3><p>Muy importante para agentes autónomos. Para ciertas acciones sensibles, el agente <strong>no ejecuta solo</strong>: propone, y una persona aprueba antes de que pase algo irreversible. Es el patrón <em>human-in-the-loop</em>.</p><p>La analogía: el asistente puede preparar toda la transferencia bancaria, pero el botón final lo apretás vos. Decidir dónde <em>no</em> poner autonomía también es diseño de arquitectura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*2ngC2uqmSCJwL9FEqH1aew.png" /></figure><p><strong>Ideal para:</strong> pagos, cambios en producción, eliminación de datos, cambios de infraestructura. La regla práctica: cuanto más irreversible es la acción, más barato sale poner un humano en el medio.</p><h3>Y además, los que conviven en los bordes</h3><p>Curé los siete que considero estructurales, pero el archivo original lista varios más que rara vez aparecen solos: funcionan como <em>refuerzos</em> de los anteriores. Vale nombrarlos, porque en una plataforma seria están todos presentes al mismo tiempo:</p><p><strong>Capability-Based</strong>: en vez de los clásicos <em>read / write / admin</em>, el agente recibe <em>capacidades</em> explícitas y acotadas — <em>“puede leer el CRM”</em>, <em>“puede enviar mail”</em>, <em>“no puede borrar clientes”</em> — . Cada capacidad es un permiso puntual. <strong>Tool-level</strong>: cada herramienta autoriza por su cuenta; que el agente esté autenticado no alcanza, cada tool vuelve a preguntar <em>“¿este agente puede llamarme?”</em> — un patrón que aparece de lleno en plataformas basadas en MCP (Model Context Protocol). <strong>Multi-Agent</strong>: cuando varios agentes colaboran (uno planifica, otro investiga, otro escribe), cada uno tiene permisos distintos; nunca conviene que todos sean administradores — puro principio de <em>least privilege</em>. <strong>Zero Trust</strong>: cada request se vuelve a verificar — identidad, contexto, riesgo, origen — sin confianza implícita; incluso dos agentes de la misma plataforma se autentican mutuamente. Y <strong>Context-aware</strong>: la misma operación se permite o se bloquea según el contexto dinámico (hora laboral, ubicación, sensibilidad del dato, costo de la operación, modelo usado).</p><h3>Cómo se combinan en una plataforma moderna</h3><p>Acá está el esquema que de verdad importa, porque ninguno de los anteriores se usa aislado. En la práctica, las plataformas más robustas los <strong>apilan en capas</strong>, y cada capa agrega una defensa distinta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*zYoids46rf8OMRbjLURI_w.png" /></figure><p>Leído de arriba hacia abajo: primero probás <strong>quién es el usuario</strong>, después <strong>quién es el agente</strong>, después aplicás <strong>políticas dinámicas</strong>, después resolvés <strong>permisos granulares</strong> sobre recursos y herramientas, y por último, si la acción es sensible, entra la <strong>aprobación humana</strong>. Cada capa es una red distinta debajo del trapecista. Ninguna sola alcanza; juntas hacen que un agente autónomo no sea un riesgo suelto.</p><h3>La tendencia: el agente como workload identity</h3><p>Si tuviera que apostar por hacia dónde va todo esto, apuesto por acá. Una de las direcciones más interesantes es tratar a cada agente como un <strong>workload de primera clase</strong>: con identidad criptográfica propia, credenciales de corta duración y permisos mínimos. En lugar de compartir secretos o tokens de larga vida, el agente obtiene credenciales efímeras, ejecuta una tarea específica y las descarta.</p><p>Esto acerca las plataformas de IA a las prácticas modernas de seguridad en la nube, donde cada servicio tiene una identidad verificable y un alcance de permisos estrictamente limitado. Creo que va a ser uno de los pilares de las plataformas <strong>Secure by Default</strong> para IA: no solo autenticar al usuario, sino también autenticar al agente, autorizar cada herramienta y evaluar continuamente el contexto antes de permitir una acción. Esa combinación es la que deja construir agentes autónomos <em>sin</em> sacrificar la trazabilidad, la gobernanza ni el principio de mínimo privilegio.</p><h3>Cierre</h3><p>La autorización de agentes no es un feature que se activa; es un conjunto de decisiones de arquitectura, cada una con su costo y su ganancia. User Delegation te da simplicidad, Agent Identity te da autonomía, ABAC y ReBAC te dan flexibilidad, Just-in-Time y Approval te dan control sobre lo irreversible. En una plataforma seria no elegís <em>una</em>: las combinás en capas.</p><p>La pregunta deja de ser <em>“¿el agente puede hacer esto?”</em> y pasa a ser <em>“¿bajo qué identidad, con qué política, con qué credencial y con qué aprobación puede hacer esto?”</em>. Esa es, en una frase, la diferencia entre un experimento y una plataforma.</p><p><strong>En las próximas notas voy a bajar cada uno de estos esquemas a ejemplos de código reales</strong> — User Delegation, Agent Identity, ABAC con OPA/Cedar, ReBAC con OpenFGA, Just-in-Time y Human-in-the-loop — , uno por uno, para que se vea cómo se implementan de verdad y no solo en un diagrama.</p><p><em>Si trabajás en plataformas de IA, identidad de agentes o autorización, me encantaría leer cómo lo están resolviendo ustedes. Dejá tu comentario o escribime por LinkedIn.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d69f2910591" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Anatomía de un Agent Development Platform]]></title>
            <link>https://medium.com/@LeandroValido/anatom%C3%ADa-de-un-agent-development-platform-f8de7e094c98?source=rss-ba83af0679f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8de7e094c98</guid>
            <dc:creator><![CDATA[Leandro Valido]]></dc:creator>
            <pubDate>Fri, 26 Jun 2026 16:48:59 GMT</pubDate>
            <atom:updated>2026-06-27T00:53:04.757Z</atom:updated>
            <content:encoded><![CDATA[<h3>Las capas que separan “tengo agentes corriendo” de “tengo una plataforma de agentes gobernable”.</h3><p>Hay un momento, en toda organización que adopta IA en serio, en el que la pregunta deja de ser <em>“¿podemos construir un agente?”</em> y pasa a ser <em>“¿cómo evitamos que cada agente sea una isla?”</em>.</p><p>Cuando cada equipo consume modelos por su cuenta, integra herramientas a mano y despliega agentes sin un dueño claro, no tenés una capacidad de IA: tenés deuda técnica distribuida con cara de innovación. Agentes sueltos, sin inventario, sin atribución de costos, sin clasificación de riesgo y sin nadie que se haga cargo de mantenerlos.</p><p>La respuesta no es prohibir ni centralizar todo en un equipo cuello de botella. La respuesta es la misma que la industria del software ya encontró para el desarrollo tradicional: <strong>una plataforma.</strong></p><p>Así como una <em>Internal Developer Platform</em> (IDP) normaliza y gobierna el ciclo de vida de una aplicación — pedís una base de datos, no instalás un motor — , un <strong>Agent Development Platform (ADP)</strong> hace lo propio con el ciclo de vida de los agentes. Y por encima de él, un <strong>AI Control Plane</strong> unifica el gobierno de <em>todas</em> las cargas de trabajo de IA, no solo de los agentes.</p><p>Este artículo es el recorrido técnico por esas capas. Cada una resuelve un problema concreto y, como toda decisión de arquitectura, paga un costo. Lo documentamos como una serie de ADRs; acá va la versión legible, de abajo hacia arriba.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VwjRIuVUsTNdO9CYHf3xKw.png" /></figure><h3>Capa 1 — LLM Gateway: abstracción de modelos</h3><p>El error más caro es dejar que cada aplicación consuma proveedores de modelos directamente. Te garantiza <em>vendor lock-in</em>, uso inconsistente, cero gobierno centralizado y ninguna visibilidad de costos.</p><p>La decisión: <strong>un único punto de entrada a todos los foundation models.</strong> Las aplicaciones y los runtimes consumen modelos <em>exclusivamente</em> a través de esta capa, que provee:</p><ul><li><strong>Abstracción de modelo</strong> y <strong>ruteo</strong>: el consumidor no elige un modelo concreto, declara una intención (“razonamiento alto”, “tarea generativa”, “dominio logística”) y el gateway resuelve el destino.</li><li><strong>Cuotas, políticas de uso y atribución de costos</strong>: control financiero real, por área y por caso de uso.</li><li><strong>Versionado, observabilidad y enforcement de políticas.</strong></li><li><strong>Fallback</strong>: si un proveedor cae o se degrada, el tráfico se redirige.</li></ul><p><strong>El tradeoff:</strong> sumás una capa de infraestructura que alguien tiene que poseer y operar. <strong>La ganancia:</strong> desacoplás las cargas de trabajo de los proveedores y podés <em>canibalizar proveedores</em> — migrar gradualmente al que sea mejor o más barato — sin tocar una sola línea de las aplicaciones. Los modelos se vuelven intercambiables.</p><h3>Capa 2 — Tool Platform: capacidades, no integraciones</h3><p>Los agentes necesitan acceder a capacidades del negocio: Jira, Confluence, SAP, Slack, sistemas de stock, servicios de búsqueda. El problema es que cada framework de agentes expone herramientas de forma incompatible, y sin un orden terminás con cinco MCPs distintos para hablarle al mismo SAP.</p><p>La decisión: <strong>exponer las capacidades del negocio a través de interfaces normalizadas.</strong> Por debajo, una herramienta puede implementarse sobre MCP, REST, GraphQL, <em>function calling</em> o protocolos A2A. Pero el consumidor depende de la <strong>capacidad lógica</strong>, no de la implementación.</p><p>Dos piezas hacen que esto escale:</p><ul><li><strong>Un registro de herramientas (tool/MCP registry):</strong> un catálogo donde sabés qué MCPs y qué bases de conocimiento existen, y los seleccionás como quien elige de un menú. Sin duplicación silenciosa.</li><li><strong>RAG como commodity:</strong> acá va la apuesta más fuerte. Así como hoy le pedís al cloud una base de datos sin pensar en el motor, mañana le pedís un RAG. Una <strong>capa de aislación</strong> por delante permite elegir cualquier motor y absorbe la complejidad de <em>chunking</em>, embeddings y recuperación. En la práctica: productivo sobre PostgreSQL + pgvector, con la recuperación atómica y desacoplada de la ingesta — un detalle no menor, porque acoplar ingesta y backend te obliga a reprocesar todo el corpus ante cualquier cambio.</li></ul><p><strong>El tradeoff:</strong> ahora tenés que gestionar el ciclo de vida de las herramientas y mantener otro catálogo. <strong>La ganancia:</strong> reuso real y desacople del framework de agentes de turno.</p><h3>Capa 3 — Agent Registry: el agente como entidad de empresa</h3><p>Las plataformas de agentes tienden a fusionar tres cosas que deberían estar separadas: el <em>runtime</em>, la <em>experiencia</em> de usuario y la <em>definición</em> del agente. Cuando eso pasa, perdés visibilidad y propiedad sobre tus propios agentes.</p><p>La decisión: <strong>definir el Agente como una entidad de empresa, independiente de su runtime.</strong> Cada agente se registra con metadata explícita:</p><ul><li>Dueño y dominio.</li><li>Criticidad y clasificación de riesgo.</li><li>Etapa del ciclo de vida.</li><li>Mapeo a runtime — tratado como <em>detalle de implementación</em>, no como fuente de verdad.</li></ul><p><strong>El tradeoff:</strong> el proceso de registración agrega overhead operativo. <strong>La ganancia:</strong> un inventario de agentes portable, que habilita migraciones futuras y, sobre todo, gobierno.</p><h3>Capa 4 — Agent Governance: el antídoto contra los shadow agents</h3><p>La proliferación descontrolada de agentes produce un set de problemas predecibles: agentes fantasma, ausencia de dueño, riesgos de compliance, costos sin techo y duplicación de prompts.</p><p>La decisión: <strong>una capacidad de gobierno centralizada</strong>, que opera con independencia de los proveedores de runtime y se hace cargo de: catálogo, propiedad, ciclo de vida, atribución de costos, compliance, clasificación de riesgo, <em>framework de evaluación</em>, políticas de compartición y auditabilidad.</p><p>Acá conviene un patrón técnico que aparece apenas el agente toca algo crítico: <strong>human-in-the-loop</strong>. Un agente es un proceso probabilístico, no determinista — cuando no sabe, <em>infiere</em> — y en procesos sensibles (una transacción, un cálculo impositivo, una corrida nocturna) el gobierno define dónde una persona tiene que aprobar sí o sí. Decidir dónde <em>no</em> poner autonomía también es arquitectura.</p><p><strong>El tradeoff:</strong> requiere <em>ownership</em> dedicado. <strong>La ganancia:</strong> gestión de portfolio de IA, riesgo operacional acotado y visibilidad.</p><h3>Capa 5 — Golden Agents: composiciones pre-aprobadas</h3><p>Permitir creación irrestricta de agentes lleva a duplicación, calidad despareja y agujeros de seguridad. Prohibirla mata la adopción.</p><p>La decisión intermedia: <strong>Golden Agents</strong>, plantillas reutilizables que empaquetan composiciones pre-aprobadas de herramientas, prompts, políticas y configuración de memoria. Los usuarios <em>extienden</em> lo aprobado en lugar de partir de cero. Ejemplos típicos: Knowledge Agent, Incident Agent, Taxes Agent, Customer Agent.</p><p><strong>El tradeoff:</strong> alguien mantiene las plantillas. <strong>La ganancia:</strong> adopción acelerada, consistencia y gobierno más simple por construcción.</p><h3>Capa 6 — Runtimes y Experiencias: desacople en los dos extremos</h3><p>Ningún runtime va a dominar el mercado, así que se los trata como <strong>proveedores de ejecución enchufables</strong> — Gemini Enterprise, LangGraph, Copilot Studio, LibreChat, lo que venga — . La identidad del agente vive por encima del runtime. <em>Caveat</em> honesto: la portabilidad total entre runtimes no siempre se puede garantizar.</p><p>En el otro extremo, las <strong>experiencias</strong> son canales de presentación, no la fuente de verdad de la definición del agente. Un mismo agente, sobre una misma base de conocimiento, puede servirse como chat lineal o como asistente embebido (Slack, Teams, un portal web) — distintos <em>viewers</em> sobre el mismo backend.</p><p>Dos patrones técnicos que viven en esta frontera:</p><ul><li><strong>Triage / routing:</strong> un agente de entrada clasifica la intención (preventa, estado de un paquete, devolución) y deriva al agente especializado; al volver, post-procesa la respuesta. Evita el anti-patrón de un único agente intentando hacer todo.</li><li><strong>Prompt management:</strong> versionado de prompts, <em>A/B testing</em> entre variantes y medición de la tasa de conversión de cada una. Es la diferencia entre “ajustar un prompt a ojo” y operar prompts como artefactos con ciclo de vida.</li></ul><h3>La capa que las une: AI Control Plane</h3><p>Los agentes son <strong>una</strong> categoría de carga de trabajo de IA, no la única. Vienen (o ya llegaron) AI Search, agentes de coding, agentes batch, agentes de voz, AI APIs, pipelines de evaluación, workflows de RAG. Construir una solución aislada para cada una duplica gobierno y modelo operativo.</p><p>Por eso la abstracción final es un <strong>AI Control Plane</strong>, una capability de plataforma que organiza todo lo anterior por capas: <em>Foundation</em> (LLM Gateway), <em>Capability</em> (Tool Platform), <em>Portfolio</em> (Registry + Governance), <em>Reuse</em> (Golden Agents), <em>Runtime</em> y <em>Experience</em>. Los agentes pasan a ser un <em>workload</em> más dentro de un modelo de gobierno compartido. <strong>El tradeoff</strong> es una inversión inicial mayor y la necesidad de <em>ownership</em> y roadmap a largo plazo. <strong>La ganancia</strong> es una arquitectura a prueba de futuro, alineada con los principios de Internal Developer Platform.</p><h3>Lo interno y lo abierto convergen: ARD</h3><p>Mientras se define un Agent Registry puertas adentro, la industria está estandarizando la misma idea puertas afuera. Google, junto a varios partners, publicó <strong>ARD (Agentic Resource Discovery)</strong>: una especificación abierta para publicar, descubrir y <em>verificar</em> capacidades de IA entre organizaciones.</p><p>La mecánica descansa en dos primitivas:</p><ul><li><strong>Catálogos:</strong> la organización publica un ai-catalog.json en un <em>well-known path</em> bajo su propio dominio. Como el catálogo vive en tu dominio, la posesión de ese dominio se convierte en la base criptográfica de identidad y confianza. Un catálogo puede describir MCP servers, agentes A2A, herramientas OpenAPI e incluso otros catálogos anidados.</li><li><strong>Registries:</strong> funcionan como buscadores de la web agéntica. Rastrean catálogos, los indexan y, ante una consulta en lenguaje natural, devuelven las capacidades que matchean junto con la metadata para verificar al publicador <em>antes</em> de conectarse. Hecha la verificación, ARD se corre del medio y el agente establece una conexión directa con el protocolo nativo de la herramienta.</li></ul><p>El mapeo es casi uno a uno con el diseño interno: lo que el Agent Registry hace dentro de la organización — descubrir, verificar, gobernar capacidades — ARD lo lleva al plano federado de toda la web. La arquitectura que elegís puertas adentro deja de ser una apuesta aislada: es el mismo modelo hacia el que converge el ecosistema.</p><h3>Cierre</h3><p>Un ADP no es un producto que se compra; es un conjunto de decisiones de arquitectura con costos explícitos. Cada capa agrega <em>ownership</em> y disciplina, y a cambio te devuelve algo que los experimentos sueltos nunca van a dar: <strong>modelos intercambiables, capacidades reutilizables, agentes gobernables y un plano de control único sobre toda la IA de la organización.</strong></p><p>La pregunta deja de ser <em>“¿podemos construir un agente?”</em>. Pasa a ser <em>“¿sobre qué plataforma los construimos todos?”</em>.</p><p><em>Si trabajás en plataformas de IA, gobierno de agentes o arquitecturas de este tipo, me encantaría leer cómo lo están resolviendo ustedes. Dejá tu comentario o escribime por LinkedIn.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8de7e094c98" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>