<?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 Ezequiel Dicosmo on Medium]]></title>
        <description><![CDATA[Stories by Ezequiel Dicosmo on Medium]]></description>
        <link>https://medium.com/@ezequiel.dicosmo?source=rss-19fc2500834------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*46x9gjqB5KQ0yGdt</url>
            <title>Stories by Ezequiel Dicosmo on Medium</title>
            <link>https://medium.com/@ezequiel.dicosmo?source=rss-19fc2500834------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 06:57:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ezequiel.dicosmo/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[El agente más barato puede ser el más caro]]></title>
            <link>https://medium.com/@ezequiel.dicosmo/el-agente-m%C3%A1s-barato-puede-ser-el-m%C3%A1s-caro-095a6c8d661a?source=rss-19fc2500834------2</link>
            <guid isPermaLink="false">https://medium.com/p/095a6c8d661a</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Ezequiel Dicosmo]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:32:38 GMT</pubDate>
            <atom:updated>2026-09-10T16:32:38.865Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cómo conectar agentes, IDP y DevEx para medir algo más útil que tokens</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HCRVsxCs4_b_1EMyjIA4vg.png" /></figure><p>El agente que cuesta menos puede ser el más caro de todos.</p><p>Imaginemos un sistema de pagos con un error en su lógica de reintentos. Ante determinados timeouts, una operación podría procesarse dos veces. Tenemos tres agentes capaces de proponer una corrección:</p><ul><li>Uno es rápido y económico.</li><li>Otro tiene mejores resultados históricos.</li><li>El tercero utiliza el modelo más potente disponible.</li></ul><p>¿Cuál debería ejecutar la tarea?</p><p>Si miramos solamente el consumo de tokens, elegimos el primero. Si asociamos potencia con calidad, probablemente elegimos el tercero. Pero ninguna de esas decisiones considera cuánto costará revisar el cambio, cuántos intentos necesitará, qué controles deberá superar o cuánto podría perder la empresa si introduce un nuevo error.</p><blockquote>La pregunta, entonces, no es qué agente escribe más código.</blockquote><p>La pregunta es qué agente ofrece el mejor equilibrio entre valor, costo y riesgo para esa tarea concreta.</p><p>No estoy proponiendo una fórmula económica universal. Es una hipótesis de plataforma nacida de un problema bastante práctico: si vamos a delegar tareas de desarrollo en agentes, también necesitamos decidir cuánto estamos dispuestos a delegar, bajo qué condiciones y con qué evidencia.</p><h4>De controlar el gasto a entender el retorno</h4><p>En <a href="https://medium.com/@ezequiel.dicosmo/ia-propone-idp-dispone-824d0ae534d8">“IA propone, IDP dispone”</a> planteé que un LLM puede interpretar una intención y proponer una acción, pero la autoridad para validarla y ejecutarla debe seguir estando en la plataforma.</p><p>Después llevé una parte de esa idea a <a href="https://medium.com/@ezequiel.dicosmo/dise%C3%B1ando-una-plataforma-de-agentes-con-control-de-presupuesto-sobre-kubernetes-2cddcd6eb989">“Diseñando una plataforma de agentes con control de presupuesto sobre Kubernetes”</a> y a su mock funcional, <a href="https://github.com/dicosmode/agent-platform">agent-platform</a>.</p><p>En ese proyecto, una tarea solicita una skill, el scheduler busca agentes capaces de resolverla y los recorre según la prioridad de sus pools: team, shared y global. Si un agente no tiene presupuesto, la tarea pasa al siguiente.</p><p>Ese modelo responde una primera pregunta:</p><blockquote>¿Quién puede ejecutar esta tarea sin superar el presupuesto?</blockquote><p>Pero todavía no responde otras dos:</p><blockquote>¿Conviene ejecutarla con un agente?</blockquote><blockquote>¿La opción más barata es realmente la que produce el cambio menos costoso?</blockquote><p>Para responderlas, tenemos que dejar de mirar solamente la factura del modelo y observar lo que sucede durante todo el ciclo de entrega.</p><h4>Más actividad no siempre significa más valor</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9iT2d0P0priviEEmagvwzg.png" /><figcaption>Del código al valor: síntesis conceptual basada en DORA 2025 y Bhati (2026).</figcaption></figure><p>Los primeros datos sobre herramientas de IA para desarrollo son prometedores, pero también muestran por qué conviene medir con cuidado.</p><p>Un working paper de <a href="https://www.nber.org/papers/w35275">Mert Demirer, Leon Musolff y Liyuan Yang</a>, basado en telemetría de más de 100.000 desarrolladores de GitHub, estimó un aumento mucho mayor en commits que en proyectos y releases. La actividad creció, pero el efecto se redujo a medida que la métrica se acercó al software efectivamente entregado.</p><p>DORA 2025 llega a una conclusión compatible: la IA funciona como un amplificador. Potencia las fortalezas de una organización, pero también sus problemas de plataforma, procesos, calidad y coordinación.</p><p>También existen resultados que invitan a desconfiar de la percepción individual. En un experimento acotado realizado a comienzos de 2025, <a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR observó que 16 desarrolladores experimentados tardaron un 19% más</a> al utilizar herramientas de IA sobre sus propios repositorios open source, aunque ellos creían haber trabajado más rápido. Los autores delimitaron el alcance del estudio y luego publicaron una <a href="https://metr.org/blog/2026-02-24-uplift-update/">actualización metodológica</a> sobre las dificultades de medir herramientas más nuevas.</p><p>Estos trabajos no permiten calcular el retorno de una empresa particular. Sí dejan una advertencia útil: generar más código, más rápido, no garantiza entregar más valor.</p><h4>¿Qué debería contar una empresa?</h4><p>Tokens, líneas generadas, commits y pull requests son datos útiles. El problema aparece cuando los tratamos como resultados.</p><p>Un <a href="https://arxiv.org/abs/2609.04681">trabajo reciente de Happy Bhati</a> propone hablar de un cambio calificado para producción — Production-Qualified Change — : un cambio cuenta cuando supera todos los controles requeridos para su clase de riesgo.</p><p>La idea es sencilla: Una actualización de documentación podría necesitar lint y revisión. Una modificación sobre el camino crítico de pagos podría exigir:</p><ul><li>Pruebas unitarias, de contrato e integración.</li><li>Pruebas de idempotencia y concurrencia.</li><li>Escaneos de seguridad y secretos.</li><li>Aprobación de un owner.</li><li>Despliegue progresivo.</li><li>Observación de métricas funcionales.</li></ul><p>Ambos cambios pueden terminar en un pull request, pero no representan el mismo nivel de autonomía ni requieren la misma evidencia.</p><p>Con el costo sucede algo parecido. La factura del modelo es apenas la parte más visible. También intervienen el contexto enviado, las herramientas, el sandbox, los runners de CI, la revisión humana, los reintentos, el retrabajo y los posibles incidentes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kutKCVZmoK2KCp4MLnPs1g.png" /><figcaption>El consumo del modelo es solo la parte visible del costo. Elaboración propia basada en la taxonomía de Bhati (2026).</figcaption></figure><p>Un agente puede costar USD 20 en tokens y terminar siendo caro si necesita cinco intentos y dos horas de revisión. Otro puede consumir más modelo, pero entregar una propuesta que pasa los controles en el primer intento.</p><p>Bhati denomina <strong>Verification Tax</strong> a esa relación entre el costo de generar y el costo de verificar. No necesitamos convertirla en una ciencia exacta para hacer una pregunta útil:</p><blockquote>¿La verificación aporta evidencia necesaria o está compensando una mala elección de agente, modelo o contexto?</blockquote><h4>Una regla sencilla para decidir</h4><p>Podemos traducir el problema a una regla entendible sin pretender que conoce el futuro:</p><blockquote>Valor esperado = valor probable del cambio − costo completo de ejecutarlo y verificarlo − pérdida probable por un error.</blockquote><p>Para aplicar esa regla necesitamos estimar cuatro cosas:</p><ul><li>La probabilidad de que el agente entregue un cambio que supere los controles.</li><li>El valor de resolver la tarea.</li><li>El costo de generar, verificar y corregir la propuesta.</li><li>La probabilidad y el impacto de que un error alcance producción.</li></ul><p>Después aparecen las restricciones que no deberían negociarse:</p><ul><li>Un presupuesto máximo.</li><li>Un riesgo máximo tolerado.</li><li>Una política de evidencias y permisos obligatorios.</li></ul><p>El score puede ayudar a ordenar candidatos, pero nunca debería permitir que un agente se saltee seguridad, compliance o una aprobación requerida.</p><p>Tampoco deberíamos inventar decimales para que la decisión parezca más precisa. Cuando no existe suficiente historia, una empresa puede comenzar con rangos o categorías como riesgo bajo, medio, alto y crítico. Hacer explícita una estimación imperfecta es mejor que esconder la decisión detrás de “usemos el modelo más potente”.</p><h4>Un ejemplo: corregir reintentos que pueden duplicar un cobro</h4><p>Supongamos la siguiente tarea:</p><blockquote>Corregir la lógica de reintentos porque, bajo determinadas condiciones de timeout, una operación podría procesarse dos veces.</blockquote><p>Para poder comparar alternativas, definimos un horizonte de 30 días y valores completamente simulados:</p><ul><li>Valor de resolver el problema: USD 10.000.</li><li>Pérdida potencial ante una regresión: USD 50.000.</li><li>Costo máximo de ejecución y verificación: USD 1.000.</li><li>Riesgo máximo tolerado de error escapado: 1%.</li></ul><p>En una empresa, esos valores podrían aproximarse utilizando cobros duplicados evitados, devoluciones, compensaciones, horas de soporte, pérdida de clientes e impacto operativo. No serían verdades exactas: serían supuestos acordados para tomar una decisión y luego contrastarla con resultados.</p><p>El scheduler dispone de tres opciones.</p><p><strong>Agent Fast</strong></p><ul><li>Probabilidad de entregar un cambio calificado: 70%.</li><li>Costo esperado: USD 250.</li><li>Probabilidad de error escapado: 4%.</li></ul><p>El 70% del valor equivale a USD 7.000. Restamos los USD 250 de ejecución y una pérdida probable de USD 2.000, correspondiente al 4% de USD 50.000.</p><p><strong>Valor esperado: USD 4.750.</strong></p><p>Es el agente más barato, pero queda descartado porque supera el riesgo máximo permitido.</p><p><strong>Agent Balanced</strong></p><ul><li>Probabilidad de entregar un cambio calificado: 90%.</li><li>Costo esperado: USD 700.</li><li>Probabilidad de error escapado: 1%.</li></ul><p>El valor probable es de USD 9.000. Restamos USD 700 de ejecución y USD 500 de pérdida probable.</p><p><strong>Valor esperado: USD 7.800.</strong></p><p>Cumple el presupuesto y se mantiene dentro del límite de riesgo.</p><p><strong>Agent Premium</strong></p><ul><li>Probabilidad de entregar un cambio calificado: 96%.</li><li>Costo esperado: USD 1.800.</li><li>Probabilidad de error escapado: 0,3%.</li></ul><p>El valor probable es de USD 9.600. Restamos USD 1.800 de ejecución y USD 150 de pérdida probable.</p><p><strong>Valor esperado: USD 7.650.</strong></p><p>Es el más confiable, pero excede el presupuesto definido para la tarea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TQPgaJEYbHFEp9JUjlfcaQ.png" /><figcaption>Comparación de valor esperado. Elaboración propia con valores completamente simulados.</figcaption></figure><p><strong>Agent Balanced</strong> no gana por ser el más barato ni por utilizar el modelo más potente. Gana porque ofrece <strong>el mejor equilibrio permitido entre valor, costo y riesgo.</strong></p><p>También existe una cuarta opción: <strong>no ejecutar con un agente</strong>. Si ningún candidato cumple las políticas o todos ofrecen un resultado desfavorable, la plataforma debería pedir más contexto, escalar la tarea a una persona o rechazar la ejecución.</p><h4>¿Esto sirve en una empresa de verdad?</h4><p>Sí, siempre que se lo entienda como un sistema gradual de decisión y no como una calculadora infalible.</p><p>Algunas variables son relativamente sencillas de observar:</p><ul><li>El consumo del modelo, los tokens y la latencia.</li><li>El costo de herramientas, sandbox y CI.</li><li>El tiempo de revisión y la cantidad de reintentos.</li><li>Los resultados de tests, seguridad y aprobaciones.</li></ul><p><a href="https://opentelemetry.io/blog/2026/genai-observability/">OpenTelemetry</a> ya trabaja sobre convenciones para observar ejecuciones de IA generativa, incluyendo uso de tokens y comportamiento por operación. Es una base posible para capturar parte de ese costo.</p><p>Otras variables necesitan historia y contexto de negocio:</p><ul><li>Qué clases de cambio suele resolver bien cada agente.</li><li>Cuántas propuestas necesitan retrabajo.</li><li>Qué cambios terminan en rollback o incidentes.</li><li>Cuánto cuesta realmente un error en cada producto.</li></ul><p>Para obtener esa evidencia, la empresa debería poder relacionar una tarea con el agente y modelo utilizados, el pull request generado, sus pipelines, el despliegue y cualquier incidente posterior.</p><p>No hace falta comenzar diciendo que un agente tiene exactamente 1% de riesgo. Se puede empezar con clases de cambio y reglas conservadoras:</p><ul><li>Documentación: ejecución automática con controles básicos.</li><li>Cambio reversible: ejecución automática y revisión posterior.</li><li>Cambio sensible: revisión obligatoria antes de desplegar.</li><li>Cambio crítico de pagos: revisión humana, pruebas específicas y despliegue progresivo.</li></ul><p>Esta lógica no es ajena a la ingeniería de software. Los <a href="https://sre.google/workbook/implementing-slos/">error budgets de SRE</a> ya convierten objetivos de confiabilidad en políticas que pueden limitar o detener cambios. El <a href="https://www.nist.gov/itl/ai-risk-management-framework">AI Risk Management Framework de NIST</a> también propone incorporar riesgo y confianza durante el diseño, uso y evaluación de sistemas de IA.</p><p>Ninguna de esas fuentes valida esta regla concreta de selección. Lo que muestran es que costos, riesgo, evidencia y políticas ya pueden formar parte de decisiones operativas.</p><h4>La IDP instrumenta. DevEx muestra el efecto</h4><p>Acá es donde una Internal Developer Platform deja de ser solamente un portal.</p><p>La IDP puede ofrecer el punto de entrada para la tarea, recuperar contexto mediante RAG, seleccionar el agente, limitar herramientas y reintentos, ejecutar los controles y registrar el resultado. También puede propagar una identidad común desde la solicitud hasta el despliegue para construir trazabilidad de punta a punta.</p><p>Pero instrumentar no alcanza.</p><p>Developer Experience permite observar qué efecto tuvo esa automatización sobre las personas y el sistema de entrega:</p><ul><li>¿Bajó el tiempo hasta tener un cambio calificado?</li><li>¿Se redujo o aumentó el tiempo de revisión?</li><li>¿Hubo menos retrabajo?</li><li>¿Disminuyeron las interrupciones?</li><li>¿Los desarrolladores confían en la evidencia producida?</li><li>¿La plataforma eliminó carga cognitiva o simplemente la desplazó?</li></ul><p>Si un agente escribe una solución en treinta segundos, pero obliga a un desarrollador a dedicar dos horas a entenderla y corregirla, no aceleramos el delivery. Solo movimos el costo a una parte menos visible.</p><p>Por eso separaría claramente las responsabilidades:</p><ul><li><strong>RAG aporta contexto: </strong>documentación, código, ownership, incidentes y políticas.</li><li><strong>El LLM propone:</strong> genera un plan o un cambio dentro del alcance autorizado.</li><li><strong>El control plane decide:</strong> selecciona agente y modelo, asigna presupuesto y exige evidencia.</li><li><strong>La plataforma valida:</strong> ejecuta CI, seguridad, aprobaciones y despliegue.</li><li><strong>Producción devuelve evidencia:</strong> costos, rechazos, rollbacks e incidentes realimentan la política.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LKGIIYgxvrQBRnjdkORKug.png" /><figcaption>La IDP gobierna y las señales operativas y de DevEx realimentan la política. Elaboración propia.</figcaption></figure><p>La plataforma no necesita acertar desde el primer día. Necesita registrar qué decidió, por qué lo decidió y qué ocurrió después.</p><h4>Cómo lo llevaría a agent-platform</h4><p>La versión actual de agent-platform resuelve scheduling por capacidad, prioridad de pool y presupuesto. La siguiente iteración podría incorporar:</p><ul><li>Una clase de riesgo para cada tarea.</li><li>Un presupuesto máximo.</li><li>Una política de evidencia requerida.</li><li>Métricas históricas por agente, skill y tipo de cambio.</li><li>Una razón explícita para seleccionar, descartar o escalar.</li></ul><p>Primero ejecutaría la nueva política en shadow mode: calcularía qué agente habría elegido sin modificar la asignación real. Después compararía dos estrategias sobre el mismo conjunto de tareas:</p><ul><li>El scheduler actual, basado en pool y presupuesto.</li><li>Un scheduler que también considere evidencia, costo completo y riesgo.</li></ul><p>Las métricas no necesitan ser exóticas:</p><ul><li>Cambios calificados por dólar.</li><li>Costo por cambio calificado.</li><li>Tiempo de revisión.</li><li>Cantidad de reintentos.</li><li>Tareas escaladas a personas.</li><li>Errores escapados y rollbacks.</li></ul><p>Ese experimento no demostraría el ROI universal de los agentes. Sí permitiría comprobar si una política más explícita toma mejores decisiones que elegir únicamente por capacidad y presupuesto.</p><p>La implementación y los CRDs pueden quedar para una segunda publicación. Primero conviene dejar clara la pregunta que el código intentará responder.</p><h4>Del token al resultado</h4><p>En tu empresa, el retorno de los agentes no tiene por qué reducirse a tokens consumidos o líneas de código generadas.</p><p>Podés empezar a medirlo observando cuántos cambios califican para producción, cuánto cuesta generarlos y verificarlos, cuánto retrabajo provocan y qué riesgo residual introducen.</p><p>Una Internal Developer Platform puede correlacionar esa evidencia de punta a punta y convertir presupuesto, riesgo y compliance en políticas ejecutables. Las métricas de DevEx, a su vez, permiten comprobar si la automatización reduce el tiempo de entrega y la carga cognitiva o si simplemente desplaza el trabajo hacia la revisión.</p><p>El objetivo no es utilizar más IA. Es entregar más valor confiable por cada unidad de costo y atención humana.</p><blockquote><strong>La IA propone. La plataforma dispone. DevEx demuestra si realmente valió la pena.</strong></blockquote><h3>Fuentes</h3><ul><li>Happy Bhati, <a href="https://arxiv.org/abs/2609.04681">“Beyond Code Generation: Reliability, Verification, and Cost Economics in the Agentic Software Development Lifecycle”</a>, arXiv, septiembre de 2026. Preprint teórico utilizado como base para los conceptos de Production-Qualified Change, costo total y Verification Tax.</li><li>Mert Demirer, Leon Musolff y Liyuan Yang, <a href="https://www.nber.org/papers/w35275">“Productivity Effects Across Generations of AI Coding Tools”</a>, NBER Working Paper 35275, 2026.</li><li>DORA / Google Cloud, <a href="https://dora.dev/research/2025/dora-report/">“State of AI-assisted Software Development 2025”</a>.</li><li>DORA / Google Cloud,<a href="https://dora.dev/ai/roi/report/"> “ROI of AI-assisted Software Development”</a>, actualizado en abril de 2026.</li><li>Joel Becker et al., METR, <a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">“Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity” y actualización metodológica de febrero de 2026.</a></li><li>NIST,<a href="https://www.nist.gov/itl/ai-risk-management-framework"> “AI Risk Management Framework”</a>.</li><li>Google, <a href="https://sre.google/workbook/implementing-slos/">“Implementing SLOs”</a>, Site Reliability Engineering Workbook.</li><li>OpenTelemetry, <a href="https://opentelemetry.io/blog/2026/genai-observability/">“Inside the LLM Call: GenAI Observability with OpenTelemetry”</a>, mayo de 2026.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=095a6c8d661a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cómo exprimir al máximo GitHub Copilot con Claude Opus y Sonnet en VS Code]]></title>
            <link>https://medium.com/@ezequiel.dicosmo/c%C3%B3mo-exprimir-al-m%C3%A1ximo-github-copilot-con-claude-opus-y-sonnet-en-vs-code-5fbe11a28b5e?source=rss-19fc2500834------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fbe11a28b5e</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Ezequiel Dicosmo]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 14:02:18 GMT</pubDate>
            <atom:updated>2026-04-13T14:02:18.174Z</atom:updated>
            <content:encoded><![CDATA[<p><em>La era del “autocomplete” terminó. Hoy Copilot coordina agentes, sub-agentes y revisión cruzada entre modelos.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*o-5hRmsW-gYYtrwM9yBZeQ.png" /></figure><p>En 2022 GitHub Copilot era una herramienta de autocompletado. En 2026 es una plataforma multi-modelo con agentes autónomos que editan múltiples archivos, corren tests y se auto-corrigen. Si todavía lo usás como un glorificado IntelliSense, estás dejando el 90% del valor sobre la mesa.</p><h3>El contexto que necesitás antes de empezar</h3><p>Copilot hoy tiene tres capas: inline suggestions (el autocompletado clásico, ilimitado), Chat messages (chat básico, ilimitado) y Premium requests (modelos de alto rendimiento, con cuota mensual). Claude Opus 4.6 consume 3x premium requests por interacción; Sonnet 4.6 consume 1x. Con un plan Pro a $10/mes tenés acceso a ambos.</p><blockquote><strong><em>Regla de oro de presupuesto:</em></strong><em> Usá Sonnet 4.6 para el 80% de las tareas de codificación diaria. Reservá Opus 4.6 para las decisiones arquitectónicas, los bugs más difíciles y los code reviews de seguridad. Esta distribución te da el mejor balance performance/costo.</em></blockquote><h3>Los dos modelos y cuándo usar cada uno</h3><p><strong>Claude Opus 4.6 (3x premium) — El arquitecto</strong> Diseño de sistemas, refactoring a gran escala, auditorías de seguridad. Usalo cuando la calidad del razonamiento es más crítica que la velocidad.</p><p><strong>Claude Sonnet 4.6 (1x premium) — El implementador</strong> Nueva funcionalidad, debugging, tests, documentación. El punto óptimo entre capacidad y costo. Preferido por el 70% de los usuarios de Claude Code.</p><p>Hay una estrategia que pocos conocen: en VS Code 1.104+ podés cambiar de modelo <em>a mitad de conversación</em> sin perder contexto. La táctica ganadora es pedirle a Opus que trace el plan y descomponga las subtareas, y luego cambiar a Sonnet para ejecutar la implementación.</p><h3>Agent Mode: el verdadero poder</h3><p>Activalo desde el selector de modo en Copilot Chat (Agent, no Ask ni Edit). En este modo el modelo no solo sugiere código: edita múltiples archivos en secuencia, reconoce errores de compilación o runtime, los corrige automáticamente y propone comandos de terminal. Es un bucle autónomo.</p><h3>El flujo de cuatro pasos</h3><p><strong>1. Explore Agent — entendé el codebase</strong> Análisis rápido de estructura, dependencias y patrones existentes antes de tocar una línea.</p><p><strong>2. Plan Agent — diseñá con Opus</strong> Opus 4.6 descompone el feature en subtareas con dependencias claras. Aquí vale el costo 3x.</p><p><strong>3. Task Agent — implementá con Sonnet</strong> Sonnet 4.6 ejecuta cada subtarea: escribe código, corre tests, itera hasta el verde.</p><p><strong>4. Rubber Duck — revisión cruzada</strong> GPT-5.4 revisa el output de Claude buscando errores que el propio modelo no puede ver en sí mismo.</p><h3>🦆 Rubber Duck: la novedad que cambia todo</h3><blockquote>“Sonnet + Rubber Duck cubre el 74.7% de la brecha de performance entre Sonnet y Opus solo, logrando mejores resultados en tareas multi-archivo de larga duración.”<em> — </em><a href="https://github.blog/ai-and-ml/github-copilot/github-copilot-cli-combines-model-families-for-a-second-opinion/"><em>Nick McKenna &amp; Bartek Perz, GitHub Research (abril 2026)</em></a></blockquote><p>Rubber Duck es un agente de revisión cruzada: cuando usás Claude como orquestador, un segundo agente basado en GPT-5.4 revisa el output buscando errores que el modelo original no puede detectar por sus propios sesgos de entrenamiento. Activalo con /experimental en Copilot CLI.</p><p>En las pruebas de GitHub, Rubber Duck detectó en un proyecto de OpenLibrary que un scheduler propuesto saldría inmediatamente al inicio sin ejecutar ningún job, y que una de las tareas programadas era en sí misma un loop infinito. Ese tipo de bug sistémico es exactamente lo que un modelo revisando su propio output no encuentra.</p><h3>Los archivos MD que multiplican tu contexto</h3><p>Los agentes de Copilot leen estos archivos automáticamente al iniciar una sesión. Sin ellos trabajás con contexto genérico; con ellos el modelo conoce tu stack, tus convenciones y tus restricciones desde el primer mensaje.</p><p>Archivo Propósito Impacto .github/copilot-instructions.md Comportamiento global del agente, stack, convenciones Alto — leído en cada sesión .agent.md Agente custom con herramientas y servidores MCP propios Alto — define capacidades CLAUDE.md Contexto del repo para Claude Code en paralelo Medio — sesiones largas .vscode/settings.json Activar instruction files, auto-fix, next edit suggestions Medio — calidad inline</p><blockquote><strong><em>El dato menos conocido:</em></strong><em> podés crear agentes completamente custom con archivos </em><em>.agent.md donde especificás qué herramientas tiene habilitadas, qué servidores MCP conecta y qué instrucciones sigue. Esto te permite tener un agente &quot;database specialist&quot; distinto de uno &quot;frontend specialist&quot; dentro del mismo proyecto.</em></blockquote><h3>Background delegation: trabajá mientras el agente trabaja</h3><p>Una de las features más subutilizadas de Copilot en 2026: prefijá cualquier prompt con &amp; para delegar la tarea a un cloud coding agent que trabaja en segundo plano. Tu terminal queda libre. Podés continuar con otro feature mientras el agente implementa el anterior. Cuando volvés, usás /resume para retomar la sesión.</p><p>Esto habilita un flujo que hace seis meses era impensable: tener tres features en paralelo siendo implementados simultáneamente por distintas instancias de agentes, con vos como arquitecto que revisa y aprueba diffs en lugar de escribir cada línea.</p><h3>La estrategia que más cambia los resultados</h3><p>Más que el modelo elegido o las features activadas, lo que más impacta la calidad del output es el nivel de detalle en tus archivos de instrucciones. Un copilot-instructions.md bien escrito que describe tu arquitectura, patrones preferidos y restricciones conocidas produce resultados radicalmente mejores que la misma sesión sin contexto.</p><p>La segunda variable crítica es la descomposición de tareas. Los agentes funcionan mejor con instrucciones atómicas y bien delimitadas. En lugar de “refactorizá el módulo de auth”, pedile a Opus que primero liste todos los sub-problemas, luego atacá cada uno con Sonnet por separado.</p><h3>El takeaway</h3><p>GitHub Copilot con Claude Opus 4.6 y Sonnet 4.6 en VS Code 1.114.0 no es una herramienta de autocompletado más rápida. Es una plataforma de agentes que puede gestionar features completos de forma autónoma. La adopción que vale no es encender el plugin, sino invertir 30 minutos en construir los archivos de contexto y entender cuándo usar cada modelo. Ese setup inicial devuelve horas cada semana.</p><p><em>¿Te resultó útil? Aplaudí en Medium y compartilo con tu equipo de desarrollo.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fbe11a28b5e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Diseñando una plataforma de agentes con control de presupuesto sobre Kubernetes]]></title>
            <link>https://medium.com/@ezequiel.dicosmo/dise%C3%B1ando-una-plataforma-de-agentes-con-control-de-presupuesto-sobre-kubernetes-2cddcd6eb989?source=rss-19fc2500834------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cddcd6eb989</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[platform]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ezequiel Dicosmo]]></dc:creator>
            <pubDate>Wed, 11 Mar 2026 04:28:20 GMT</pubDate>
            <atom:updated>2026-03-11T04:28:20.075Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Un MVP para explorar cómo modelar agentes, capacidades, presupuesto y fallback usando Kubernetes como control plane.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0XEifiqis8bWPtgRqIwmVQ.jpeg" /></figure><p>Hay un momento bastante común en cualquier conversación sobre agentes de IA: alguien muestra una demo, los agentes colaboran, llaman tools, encadenan pasos, responden bien… y durante unos minutos todo parece bastante resuelto.</p><p>Pero apenas baja un poco la espuma aparecen otra clase de preguntas. Preguntas más incómodas, menos “demo-friendly”, pero mucho más cercanas a la realidad.</p><p>¿Quién decide qué agente atiende cada tarea? ¿Qué pasa cuando una capacidad compartida se empieza a saturar? ¿Cómo se evita que un equipo consuma más de lo que debería? ¿Qué ocurre cuando el agente ideal existe, pero ya no tiene presupuesto? ¿Dónde vive esa lógica? En cada aplicación, en un servicio central, en una planilla, en una convención informal?</p><p>Hace un tiempo empecé a analizar las posibles respuestas a estas preguntas. No tanto en cuanto a cómo lograr que los agentes realicen las tareas, sino a cómo se los podría <strong>operar como plataforma</strong>.</p><p>Porque una cosa es hacer una demo donde varios agentes colaboran. Pero otra bastante distinta es pensar qué pasa cuando eso empieza a ser usado por distintos equipos, con costos reales, capacidades diferentes, límites de consumo y necesidad de fallback cuando una ruta deja de estar disponible.</p><p>Partiendo de estos escenarios creé un MVP llamado <strong>Agent Platform</strong>, un operador de Kubernetes que modela agentes, skills, budgets y tasks como CRDs, y que toma decisiones de scheduling en función de capacidad y presupuesto disponible.</p><p>El repositorio es este:</p><p><a href="https://github.com/dicosmode/agent-platform"><strong>github.com/dicosmode/agent-platform</strong></a></p><p>No lo construí como un producto terminado, sino como una forma concreta de perseguir una pregunta que me sigue pareciendo muy vigente: ¿C<strong>ómo podría verse una plataforma interna de agentes gobernada por costo, capacidad y políticas de fallback?</strong></p><h2>El problema que me interesaba explorar</h2><p>En la práctica, la adopción de IA dentro de una organización suele empezar bastante fragmentada.</p><p>Un equipo integra un LLM directamente. Otro arma un servicio con prompts y herramientas. Otro construye una automatización interna. Otro empieza a encapsular capacidades como “agentes”.</p><p>Al principio, esa diversidad no molesta demasiado. De hecho, suele ser parte natural de la etapa exploratoria. Cada equipo prueba rápido, aprende algo, descarta cosas, encuentra casos de uso.</p><p>El problema suele aparecer después, cuando el uso empieza a dejar de ser anecdótico y empieza a convertirse en capacidad operativa. Ahí es donde emergen preguntas más estructurales:</p><ul><li>¿Qué agente debería atender cada tarea?</li><li>¿Cómo se controla el gasto por equipo?</li><li>¿Qué pasa si una capacidad dedicada se queda sin presupuesto?</li><li>¿Cuándo debería entrar un pool compartido?</li><li>¿Cómo se evita que esa lógica quede duplicada en cada aplicación?</li></ul><p>Ese tipo de decisiones normalmente terminan repartidas entre servicios, configuraciones locales o lógica ad hoc. Y cuando eso pasa, la complejidad no desaparece, solo queda dispersa.</p><p>Ahora bien.. ¿Qué pasaría si esa responsabilidad se trasladara a una capa común de plataforma, donde el routing, el control de presupuesto y el fallback no fueran comportamientos implícitos, sino reglas explícitas del sistema?</p><h2>La idea</h2><p>La idea del proyecto es simple en su forma, aunque no tanto en sus implicancias: usar Kubernetes como plano de control para modelar el dominio y dejar que controladores reconcilien el estado del sistema.</p><p>Los cuatro conceptos principales son:</p><ul><li><strong>Agent</strong>: un ejecutor con un pool, skills y una referencia a un budget</li><li><strong>Skill</strong>: una capacidad que puede tener un costo asociado</li><li><strong>Budget</strong>: un límite con consumo actual</li><li><strong>Task</strong>: una unidad de trabajo que necesita una skill y tiene un costo</li></ul><p>A partir de eso, el scheduler toma una decisión bastante concreta:</p><ol><li>Busca agentes compatibles con la skill pedida,</li><li>Los ordena por prioridad de pool,</li><li>Valida si el budget asociado alcanza,</li><li>Asigna el primer agente elegible,</li><li>Y si no alcanza, hace fallback al siguiente pool.</li></ol><p>La prioridad actual es:</p><ul><li>team</li><li>shared</li><li>global</li></ul><p>Es decir: primero se intenta usar capacidad dedicada del equipo, después capacidad compartida y finalmente capacidad global.</p><p>Esta regla no parece ser demasiado compleja. Muchas veces las políticas que más impacto tienen operativamente no son las más sofisticadas, sino las que logran volver explícito algo que en la práctica suele resolverse “como se puede”.</p><p>Mi objetivo era capturar una política operativa realista con un modelo simple, entendible y suficientemente explícito como para poder probarla, discutirla y evolucionarla.</p><h2>¿Por qué Kubernetes?</h2><p>Porque Kubernetes resuelve muy bien el problema del control plane.</p><p>Tiene:</p><ul><li>Modelo declarativo,</li><li>Reconciliación,</li><li>CRDs,</li><li>Status,</li><li>Eventos,</li><li>RBAC,</li><li>Y una semántica operativa conocida por equipos de plataforma.</li></ul><p>En vez de inventar una capa de control desde cero, creí más interesante aprovechar ese modelo para representar el sistema con recursos nativos del clúster.</p><p>Así aparecen CRDs para:</p><ul><li>Agent</li><li>Skill</li><li>Budget</li><li>Task</li></ul><p>Y luego los controladores hacen el trabajo de sincronizar estado, registrar agentes, actualizar presupuestos y resolver tareas.</p><p>Lo desafiante para mí no era solo “correr agentes”, sino <strong>pensar a los agentes como recursos gobernables dentro de una plataforma</strong>. Kubernetes encaja bien ahí porque ya trae consigo una gramática de operación: desired state, reconciliation, status, observabilidad básica y separación entre especificación y estado observado.</p><p>En otras palabras: no estaba detrás del mejor runtime posible para agentes, sino de un buen lugar donde pudiera modelar el problema de gobernarlos.</p><h2>Qué construí concretamente</h2><p>El proyecto está implementado con:</p><ul><li><strong>Go</strong></li><li><strong>kubebuilder</strong></li><li><strong>controller-runtime</strong></li><li><strong>kind</strong> para testing local</li></ul><p>Incluye:</p><ul><li>CRDs para Agent, Skill, Budget y Task</li><li>Controladores para Agent, Budget y Task</li><li>Un scheduler con lógica de budget-aware scheduling</li><li>Fallback entre pools team -&gt; shared -&gt; global</li><li>Manifiestos de ejemplo</li><li>Unit tests del scheduler</li><li>Controller tests</li><li>Linting y CI</li></ul><p>A nivel de flujo, el sistema hace esto:</p><ol><li>Se crea un Task,</li><li>El TaskController lo reconcilia,</li><li>Consulta al scheduler,</li><li>El scheduler filtra agentes por skill,</li><li>Ordena por prioridad,</li><li>Valida presupuesto,</li><li>Asigna un agente o falla,</li><li>Actualiza el estado del Task y del Budget.</li></ol><p>No hay demasiada sofisticación en la implementación. Y eso es una virtud.</p><p>Lo importante es que esa lógica queda centralizada, declarativa y testeable. En vez de esconder la decisión de routing detrás de un conjunto de ifs repartidos entre servicios, el comportamiento queda modelado como una capacidad explícita de la plataforma.</p><h2>El punto clave: presupuesto y fallback</h2><p>Teniendo como objetivo validar la combinación entre control de presupuesto y fallback entre pools. Supuse este escenario:</p><ul><li>Existe un agente dedicado para el equipo de marketing,</li><li>existe además un agente compartido con la misma skill,</li><li>ambos pueden resolver summarize,</li><li>pero el budget del equipo de marketing ya se agotó.</li></ul><p>Cuando entra una nueva task, el scheduler hace esto:</p><ul><li>intenta primero con el agente del pool team,</li><li>detecta que su budget no alcanza,</li><li>continúa con el pool shared,</li><li>encuentra un agente elegible,</li><li>y asigna la tarea ahí.</li></ul><p>Lo importante es que la tarea no falla inmediatamente. El sistema <strong>degrada de forma controlada</strong>.</p><p>Ese comportamiento parece sencillo, pero me parece muy representativo de lo que una plataforma real necesitaría: no solo enrutar, sino enrutar bajo restricciones.</p><p>Cuando una plataforma empieza a servir a más de un equipo, la pregunta no es solo ¿Quién puede resolver esto?, sino también ¿Quién debería resolverlo dadas las restricciones actuales? Es ahí donde el presupuesto deja de ser un dato administrativo y pasa a ser una variable activa del scheduling.</p><h2>Modelando el dominio con CRDs</h2><p>El dominio encaja bastante bien en Kubernetes.</p><p>No solo porque técnicamente se pueda representar con CRDs, sino porque el modelo gana claridad cuando cada concepto tiene una forma explícita. En vez de tener estructuras internas invisibles para el resto del sistema, cada pieza del dominio existe como recurso, con un spec, un status y una responsabilidad bastante clara.</p><p>Eso vuelve más fácil razonar sobre el estado del sistema, inspeccionarlo con kubectl, testearlo y, sobre todo, discutirlo con otros sin depender de que conozcan toda la implementación.</p><h3>Agent</h3><p>Agent representa una capacidad ejecutora dentro de la plataforma. No es solamente “una instancia que procesa algo”, sino una unidad de capacidad con identidad, alcance y restricciones.</p><p>Tiene:</p><ul><li>pool</li><li>skills</li><li>budgetRef</li><li>endpoint</li></ul><p>El pool define su lugar dentro de la estrategia de fallback. Las skills expresan qué tipo de trabajo puede resolver. budgetRef lo vincula con la fuente de presupuesto desde la que consume, y endpoint deja abierta la posibilidad de apuntar a un backend real de ejecución.</p><p>Además mantiene estado operativo, por ejemplo si está listo o agotado. Eso permite que el recurso no solo describa capacidad teórica, sino también su condición actual dentro del sistema.</p><h3>Budget</h3><p>Budget representa una cuota de consumo disponible para una parte de la plataforma. En este MVP lo usé como una forma simple de modelar restricción económica y transformarla en criterio operativo.</p><p>Tiene:</p><ul><li>limit</li><li>pool</li><li>used</li><li>remaining</li></ul><p>limit marca el techo, used refleja lo consumido, y remaining expone de forma directa cuánto margen queda. En la práctica, este recurso es lo que convierte al scheduler en algo más que un selector por capacidad: lo obliga a decidir también en función de restricción.</p><h3>Task</h3><p>Task representa trabajo a asignar. Es, de alguna forma, el punto de entrada del sistema: la demanda que la plataforma tiene que resolver.</p><p>Tiene:</p><ul><li>skill</li><li>cost</li><li>team</li></ul><p>skill describe la capacidad requerida, cost expresa el costo esperado de ejecución y team permite contextualizar la tarea dentro de una unidad organizacional.</p><p>Su estado evoluciona a cosas como pending, scheduled, completed o failed, lo cual vuelve visible el ciclo de vida de la asignación y hace mucho más fácil observar si el sistema está resolviendo correctamente o degradando hacia error.</p><h3>Skill</h3><p>Skill modela una capacidad reusable dentro del sistema. En esta versión todavía es un recurso relativamente simple, pero me resultó útil como forma de separar “qué sabe hacer un agente” de “qué agente puntual está disponible”.</p><p>Eso deja abierta una evolución a futuro: enriquecer las skills con metadatos, costos, backends o incluso restricciones más finas de ejecución.</p><p>Lo que más me gusta de este esquema es que separa bastante bien dos cosas:</p><ul><li>el <strong>control plane</strong>,</li><li>y el runtime real de ejecución.</li></ul><p>Este proyecto trabaja sobre la primera capa. Y creo que ahí está una de sus ideas más útiles: antes de resolver el runtime perfecto, vale la pena diseñar con cuidado el modelo de control.</p><h2>Algunas decisiones de diseño</h2><p>Como era un MVP, varias decisiones fueron deliberadamente simples. No por falta de ambición, sino porque me interesaba preservar foco.</p><p>Quería validar primero si el modelo cerraba y si la interacción entre recursos, scheduler y controladores tenía sentido antes de sumar piezas de infraestructura más pesadas.</p><h3>Estado in-memory para budgets</h3><p>Hoy el scheduler mantiene el estado de presupuestos en memoria. No hay Redis ni persistencia externa.</p><p>Eso obviamente no es lo ideal para una versión productiva, pero me permitió validar antes la lógica central del sistema sin meter complejidad de infraestructura demasiado temprano.</p><h3>Scheduler compartido en el mismo proceso</h3><p>En vez de separar el scheduler como un servicio, lo dejé como una instancia compartida entre controladores dentro del manager.</p><p>Menos moving parts, menos fricción, más foco en el modelo.</p><h3>Sin cola de tareas real</h3><p>No integré NATS ni ningún broker todavía. Las tasks se procesan dentro del loop de reconciliación.</p><p>De nuevo, la prioridad era validar el control plane antes que la arquitectura completa de ejecución.</p><h2>Qué demuestra este MVP</h2><p>Aunque sea una versión chica, ya prueba varias cosas que me parecen valiosas.</p><h3>1. El routing puede expresarse como política de plataforma</h3><p>No tiene por qué quedar enterrado en cada aplicación.</p><h3>2. El costo puede formar parte del scheduling</h3><p>No como una planilla externa o una revisión manual, sino como una restricción propia del sistema.</p><h3>3. El fallback puede ser explícito y testeable</h3><p>En vez de depender de comportamientos implícitos o soluciones locales.</p><h3>4. Kubernetes funciona bien como control plane para este problema</h3><p>No necesariamente para toda la ejecución, pero sí para modelar recursos, estado y decisiones.</p><h2>Lo que todavía no es</h2><p>También me parece importante marcar el límite del proyecto.</p><p>Esto <strong>no</strong> es todavía una plataforma productiva completa.</p><p>No tiene:</p><ul><li>Persistencia real de budget,</li><li>Dispatch asíncrono,</li><li>Observabilidad fuerte,</li><li>Soporte multi-cluster,</li><li>Backends reales de ejecución,</li><li>Estrategias avanzadas de scheduling.</li></ul><p>Hoy es, sobre todo, un <strong>reference implementation</strong> o un MVP técnico para explorar la arquitectura con algo concreto funcionando.</p><p>Y, honestamente, eso ya justifica el proyecto. Hay ideas que solo se vuelven realmente discutibles cuando dejan de ser una intuición y pasan a tener una forma ejecutable.</p><h2>Por qué creo que esta línea tiene potencial</h2><p>Creo que tiene potencial porque el problema es real.</p><p>Hoy hay muchísima conversación sobre agentes como abstracción de aplicación, pero bastante menos sobre agentes como <strong>capacidad compartida de plataforma</strong>.</p><p>Y si esa transición efectivamente ocurre, hay un conjunto de temas que van a aparecer sí o sí:</p><ul><li>ownership,</li><li>multi-tenancy,</li><li>budget controls,</li><li>policy,</li><li>observabilidad,</li><li>fallback,</li><li>priorización,</li><li>optimización de costo.</li></ul><p>Este proyecto no resuelve todo eso, pero sí toca un punto que me parece central: <strong>cómo enrutar trabajo entre capacidades distintas respetando límites de consumo</strong>.</p><p>Sospecho que a medida que más organizaciones pasen de “experimentos con agentes” a “capacidades compartidas de IA”, este tipo de preocupación va a dejar de ser una curiosidad arquitectónica para convertirse en una necesidad práctica.</p><h2>Qué me gustaría explorar después</h2><p>Si lo siguiera evolucionando, los siguientes pasos naturales serían:</p><ul><li>Persistencia real de budget con Redis,</li><li>Cola de tareas con NATS,</li><li>Métricas con Prometheus,</li><li>Políticas más ricas de routing,</li><li>Awareness de costo/latencia/calidad,</li><li>Integración con runtimes reales de agentes,</li><li>Quizás una capa más inteligente de selección según capacidad efectiva.</li></ul><p>También me interesa la idea de pasar de “¿hay presupuesto?” a una pregunta más interesante:</p><p><strong>¿qué agente conviene usar para esta tarea según costo, saturación, prioridad y capacidad?</strong></p><p>Ahí ya empieza a aparecer una plataforma bastante más rica.</p><h2>Qué aprendí construyéndolo</h2><p>Si tuviera que resumir los aprendizajes más importantes, diría estos:</p><h3>1. La gobernanza aparece antes de lo que parece</h3><p>Es muy fácil construir demos de agentes. Es bastante más difícil pensar cómo se operan de forma consistente cuando dejan de ser un experimento aislado.</p><h3>2. Kubernetes encaja bien para problemas de control plane</h3><p>Especialmente cuando el foco está en recursos, reconciliación y políticas.</p><h3>3. El fallback no es solo una decisión técnica</h3><p>Muchas veces también es una política operativa o incluso de negocio.</p><h3>4. Un MVP vale mucho si ataca la pregunta correcta</h3><p>Este proyecto no intenta resolver “todo sobre agentes”. Intenta responder una pregunta más acotada, pero útil:</p><p><strong>¿cómo debería enrutar una plataforma trabajo entre agentes cuando existen skills, pools y presupuestos?</strong></p><h2>Reflexión final</h2><p>Este proyecto empezó como una exploración técnica y terminó siendo, sobre todo, una forma de pensar infraestructura para agentes desde una mirada más de plataforma.</p><p>No tanto “cómo hacer que varios agentes hablen entre sí”, sino:</p><ul><li>cómo modelarlos,</li><li>cómo gobernarlos,</li><li>cómo asignarles trabajo,</li><li>y cómo controlar el costo de uso.</li></ul><p>Si esa línea te resulta interesante, el repositorio está abierto:</p><p><a href="https://github.com/dicosmode/agent-platform"><strong>github.com/dicosmode/agent-platform</strong></a></p><p>Me interesa especialmente cualquier feedback sobre:</p><ul><li>estrategia de scheduling,</li><li>persistencia de budgets,</li><li>colas de tareas,</li><li>observabilidad,</li><li>y evolución general del control plane.</li></ul><p>Porque, en el fondo, la pregunta que me quedó dando vueltas después de construirlo sigue siendo la misma con la que empecé: cuando los agentes dejen de ser solo demos y empiecen a convertirse en capacidad compartida dentro de una organización, <strong>¿qué tipo de plataforma vamos a necesitar para gobernarlos de verdad?</strong></p><p>Si te interesa ese problema, si venís pensando en plataformas internas de IA o si te parece que esta idea podría empujarse un poco más hacia algo productivo, me encantaría leer tu mirada.</p><p>Y si hay algo que me gustaría que este proyecto habilite, más allá del código en sí, es conversación: cómo diseñar una capa común para agentes que no solo los orqueste, sino que también los gobierne.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cddcd6eb989" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IA propone, IDP dispone]]></title>
            <link>https://medium.com/@ezequiel.dicosmo/ia-propone-idp-dispone-824d0ae534d8?source=rss-19fc2500834------2</link>
            <guid isPermaLink="false">https://medium.com/p/824d0ae534d8</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ezequiel Dicosmo]]></dc:creator>
            <pubDate>Sat, 20 Dec 2025 02:47:51 GMT</pubDate>
            <atom:updated>2025-12-20T02:47:51.967Z</atom:updated>
            <content:encoded><![CDATA[<h4>Gobernanza Automatizada: El rol crítico del IDP para validar y desplegar el código generado por IA.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rml8kGmO-1KPpBS3M4rkZg.jpeg" /></figure><p>Estaba trabajando en algunas cosas sobre adopción de IDPs, entre ellas sumar IA a los IDP, y siempre se me pasa por la cabeza ¿Cómo hacemos para que la IA cree servicios, despliegue a producción o gestiones nuestra infraestructura?</p><p>La pregunta parece razonable. Los LLMs entienden lenguaje natural, contexto y patrones mucho mejor que cualquier formulario o CLI.</p><p>Pero hay una pregunta mas incómoda — y bastante mas importante — que rara vez se hace:</p><blockquote>¿Debería una IA tener permiso para ejecutar acciones dentro de nuestra plataforma?</blockquote><p>Porque en el momento en que una IA deja de <em>sugerir</em> y empieza a <em>disponer</em>, ya no estamos hablando de DevEx.<br>Estamos hablando de <strong>gobernanza, seguridad y control del sistema</strong>.</p><p>Y ahí es donde muchas iniciativas <em>AI-first</em> empiezan a romperse.</p><h4>El problema: confundir inteligencia con autoridad</h4><p>Los LLMs son motores de inferencia brillantes. Son excepcionales para:</p><ul><li><strong>Interpretar la intención</strong> detrás de una petición ambigua.</li><li><strong>Inferencia contextual</strong> sobre requerimientos con información incompleta.</li><li><strong>Mapear lenguaje natural</strong> a contratos y acciones estructuradas.</li></ul><p>Pero son inherentemente malos para:</p><ul><li><strong>Garantizar invariantes</strong> arquitectónicas y determinismo.</li><li><strong>Asegurar el cumplimiento (Compliance)</strong> de políticas duras de seguridad.</li><li><strong>Gestionar efectos secundarios</strong> en sistemas distribuidos complejos.</li></ul><p>No porque estén “mal”, sino porque <strong>no fueron diseñados para eso</strong>.</p><p>Una <strong>Internal Developer Platform</strong> no es una interfaz simpática. Es un <strong>sistema de gobierno</strong>.</p><p>Y delegar ejecución directa a una IA no es innovación. Es perder control con estilo.</p><h4>Un principio simple (pero no negociable)</h4><blockquote><strong><em>La IA puede proponer. La plataforma dispone.</em></strong></blockquote><p>Ese principio, aplicado con rigor, resuelve más problemas de los que parece.</p><h3>Separar responsabilidades: el modelo correcto</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q8neBAkLHtyUDqj99fyc6w.png" /></figure><p>La integración sana entre inteligencia artificial y una Internal Developer Platform no depende de una tecnología puntual, ni de un framework de moda. Depende de algo mucho más básico: <strong>entender qué responsabilidad tiene cada pieza del sistema</strong> y respetar ese límite sin excepciones.</p><p>Cuando esos límites se difuminan, aparecen los problemas. La IA empieza a tomar decisiones que no le corresponden, la plataforma pierde autoridad y el sistema se vuelve difícil de razonar. Por eso, antes de hablar de modelos, prompts o proveedores, conviene aclarar el modelo mental.</p><h4>1. LLM — Razona, no actúa</h4><p>En esta arquitectura, el modelo no es un ejecutor ni un orquestador. Es una herramienta de razonamiento. Recibe lenguaje natural, contexto y restricciones, y devuelve una propuesta estructurada. Nada más. No valida políticas, no conoce el estado real del sistema y no debería tener forma de hacerlo. Su valor está en interpretar intención, no en tomar decisiones finales.</p><h4>2. MCP — Describe capacidades, no decisiones</h4><p>El MCP no decide y no ejecuta. Lo que hace es <strong><em>explicitar</em></strong> el contrato de la plataforma: qué acciones existen, qué parámetros aceptan y bajo qué forma pueden ser invocadas. Es la forma que tiene la plataforma de decirle a la IA “esto es lo que está permitido”, sin ambigüedades ni heurísticas implícitas.</p><blockquote>¿Qué acciones existen y cómo se usan?</blockquote><p>Ejemplos:</p><pre>create_service(name, runtime, environment)<br>deploy_service(service, version)<br>request_database(type, size)</pre><p>El MCP no ejecuta nada. No tiene lógica de negocio. No guarda estado.</p><p>Es el <strong>menú</strong>, no la cocina.</p><h4>3. IDP — Ejecuta, valida y gobierna</h4><p>Sigue siendo el centro del sistema. Es la única que tiene autoridad para validar, aplicar políticas, exigir aprobaciones y ejecutar workflows. La IA no la reemplaza ni la simplifica. La IA solo llega hasta la puerta. A partir de ahí, las reglas son las mismas de siempre.</p><p>Cuando estas responsabilidades están bien separadas, la arquitectura se vuelve más fácil de entender, de auditar y de evolucionar. Cada componente hace menos cosas, pero las hace mejor. Y, sobre todo, el sistema deja de depender de la “inteligencia” para seguir siendo confiable.</p><p>Ese es el modelo correcto. No porque sea más moderno, sino porque es el único que escala sin perder control.</p><h3>Manos a la obra…</h3><p>Bueno, ya hablamos de responsabilidades pero estaría bueno poner un ejemplo practico para ver sobre lo que estamos hablando. Así que — Ruidito de mate — y empezamos:</p><p>El caso mas simple suele ser el mas revelador</p><h4>Paso 1 — El usuario habla en natural</h4><blockquote><em>“</em>Quiero una aplicación en Go que implemente una DB Postgres en el entorno DEV<em>”</em></blockquote><h4>Paso 2 — El agente consulta al MCP</h4><p>El IDP expone sus capacidades a través de un servidor MCP. El LLM ya no adivina; ahora sabe exactamente qué “herramientas” tiene disponibles.</p><pre>[<br>  {<br>    &quot;name&quot;: &quot;provision_infra&quot;,<br>    &quot;description&quot;: &quot;Crea un servicio con su infraestructura asociada&quot;,<br>    &quot;params&quot;: {<br>      &quot;runtime&quot;: [&quot;go&quot;, &quot;v1.21&quot;, &quot;v1.22&quot;],<br>      &quot;database&quot;: [&quot;postgres&quot;, &quot;none&quot;],<br>      &quot;env&quot;: [&quot;dev&quot;, &quot;stg&quot;, &quot;prod&quot;]<br>    }<br>  }<br>]</pre><p>Nada mágico. Nada implícito.</p><h4>Paso 3 — El LLM propone</h4><p>Gracias al contexto del MCP, el LLM genera un JSON perfectamente alineado con las políticas del IDP y la intención del usuario. No hay alucinaciones; hay precisión.</p><pre>{<br>  &quot;action&quot;: &quot;provision_infra&quot;,<br>  &quot;params&quot;: {<br>    &quot;runtime&quot;: &quot;go&quot;,<br>    &quot;database&quot;: &quot;postgres&quot;,<br>    &quot;env&quot;: &quot;dev&quot; <br>  }<br>}</pre><p>No inventó acciones. No ejecutó nada. Solo propuso.</p><h4>Paso 4 — El IDP dispone</h4><p>A partir de acá, el control vuelve completamente al <strong>Internal Developer Platform</strong>.</p><p>El IDP recibe la propuesta y la trata como cualquier otra solicitud: la somete a validaciones, contrasta contra políticas internas y, si el contexto lo requiere, exige una aprobación humana antes de avanzar. No hay atajos por venir “desde la IA”. Las reglas son las mismas para todos los caminos.</p><p>Una vez superados esos controles, el workflow se ejecuta y el evento queda registrado. Hay trazabilidad, hay auditoría y hay responsables claros. El sistema sabe qué se pidió, quién lo pidió y bajo qué condiciones se ejecutó.</p><p>La IA, mientras tanto, queda afuera de esa decisión final.<br> No sabe si la acción fue aprobada, rechazada o postergada. Y no necesita saberlo.</p><p>Ese límite no es una carencia del sistema. Es exactamente lo que lo hace confiable.</p><p>Un ejemplo de validación seria este:</p><pre>package domain<br><br>// Intent representa el contrato estructurado generado por el LLM.<br>type Intent struct {<br> Action string `json:&quot;action&quot;`<br> Params struct {<br>  Runtime  string `json:&quot;runtime&quot;`<br>  Database string `json:&quot;database&quot;`<br>  Env      string `json:&quot;env&quot;`<br> } `json:&quot;params&quot;`<br>}</pre><pre>package platform<br><br>import (<br> &quot;fmt&quot;<br> &quot;time&quot;<br> &quot;idp-validator/domain&quot; // Importamos el contrato<br>)<br><br>type IDPOrchestrator struct {<br> AllowedRuntimes map[string]bool<br>}<br><br>func (o *IDPOrchestrator) Process(intent domain.Intent) {<br> fmt.Printf(&quot;IDP: Validando propuesta para &#39;%s&#39;...\n&quot;, intent.Params.Env)<br> <br> if err := o.validate(intent); err != nil {<br>  fmt.Printf(&quot;Validación Fallida: %v\n&quot;, err)<br>  return<br> }<br><br> o.execute(intent)<br>}<br><br>func (o *IDPOrchestrator) validate(intent domain.Intent) error {<br> // Validación de Runtime<br> if !o.AllowedRuntimes[intent.Params.Runtime] {<br>  return fmt.Errorf(&quot;runtime &#39;%s&#39; no autorizado&quot;, intent.Params.Runtime)<br> }<br><br> // Validación de Base de Datos (Reglas deterministas)<br> switch intent.Params.Database {<br> case &quot;postgres&quot;:<br>  if intent.Params.Env != &quot;dev&quot; {<br>   return fmt.Errorf(&quot;Postgres solo permitido en &#39;dev&#39;&quot;)<br>  }<br> case &quot;none&quot;, &quot;&quot;:<br>  return nil<br> default:<br>  return fmt.Errorf(&quot;DB &#39;%s&#39; no soportada&quot;, intent.Params.Database)<br> }<br> return nil<br>}<br><br>func (o *IDPOrchestrator) execute(intent domain.Intent) {<br> fmt.Println(&quot;Provisionando infraestructura validada...&quot;)<br>}</pre><pre>package main<br><br>import (<br> &quot;idp-validator/domain&quot;<br> &quot;idp-validator/platform&quot;<br>)<br><br>func main() {<br> // Inyectamos la configuración de gobernanza<br> idp := &amp;platform.IDPOrchestrator{<br>  AllowedRuntimes: map[string]bool{&quot;go&quot;: true, &quot;node&quot;: true},<br> }<br><br> // Caso de uso: El LLM propone vía MCP<br> proposal := domain.Intent{<br>  Action: &quot;provision_infra&quot;,<br> }<br> proposal.Params.Runtime = &quot;go&quot;<br> proposal.Params.Database = &quot;postgres&quot;<br> proposal.Params.Env = &quot;dev&quot;<br><br> idp.Process(proposal)<br>}</pre><h4>¿Por qué considero que este enfoque escala?</h4><p>Cuando la IA no ejecuta directamente, el sistema se vuelve más predecible. No hay credenciales implícitas circulando, no hay decisiones opacas, no hay “bueno, la IA decidió esto”. Cada acción pasa por los mismos controles que pasarían sin IA: validaciones, políticas, aprobaciones, auditoría. La diferencia es que la interfaz es mejor, no que las reglas son más laxas.</p><p>También es un enfoque que escala <strong>organizacionalmente</strong>. Porque cuando aparecen los equipos de seguridad, compliance o auditoria — y siempre aparecen — , no tenés que explicar por qué un modelo probabilístico tiene permisos de producción. La plataforma sigue siendo el punto de control, y la IA es solo una capa de interpretación.</p><p>Hay otro punto que suele subestimarse: la evolución. Los LLM cambian, mejoran, se reemplazan. Hoy es uno, mañana es otro, pasado mañana corre on-prem. En este modelo, cambiar el LLM no implica rediseñar la plataforma. El contrato sigue siendo el mismo. Las acciones siguen siendo las mismas. La IA es intercambiable, y eso es una señal clara de una arquitectura sana.</p><p>Esto es lo que hace que el enfoque sea realmente <em>enterprise-ready</em>. Funciona en cloud, funciona on-prem, funciona con o sin GPU, funciona incluso si mañana decidís apagar la IA. Porque la plataforma nunca dejó de ser la plataforma.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=824d0ae534d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dos clientes, un propósito: lo que aprendí entre usar y construir plataformas]]></title>
            <link>https://medium.com/@ezequiel.dicosmo/dos-clientes-un-prop%C3%B3sito-lo-que-aprend%C3%AD-entre-usar-y-construir-plataformas-47acd3e6edce?source=rss-19fc2500834------2</link>
            <guid isPermaLink="false">https://medium.com/p/47acd3e6edce</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[developer-experience]]></category>
            <dc:creator><![CDATA[Ezequiel Dicosmo]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 03:08:54 GMT</pubDate>
            <atom:updated>2025-11-13T03:08:54.951Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*e9VGaPAQMAL1fcyOlIKNCA.png" /><figcaption>Propiedad de ArchitectElevator.com (Gregor Hohpe)</figcaption></figure><p>Hace unos días me encontré con un <a href="https://www.linkedin.com/posts/ghohpe_platform-activity-7393206381266419712-dxne?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAAAHp-48BCpkv4rFaQcPiozPVBtQDggMOevc">Post</a> de <strong>Gregor Hohpe</strong> donde habla del trade-off que se realiza entre la velocidad de los equipos de desarrollo y los requerimientos legacy del negocio. Y me di cuenta que en estos años tuve la suerte de ver ambos lados del mostrador.</p><p>Primero, como desarrollador usuario de una plataforma interna madura, donde todo estaba orquestado: pipelines estandarizados, despliegues seguros, guardrails automáticos.</p><p>Después, como parte del equipo que debía construir una plataforma propia, con una hoja en blanco, muchas necesidades y aún más expectativas.</p><p>Y aprendí algo importante:</p><blockquote><strong>Una plataforma no es un sistema técnico, es una negociación permanente entre velocidad y control.</strong></blockquote><h4>Dos clientes, un mismo objetivo</h4><p>Todo equipo de plataforma sirve a dos clientes distintos:</p><p>Los equipos de desarrollo, que valoran la autonomía, el feedback rápido y la capacidad de mover producto.</p><p>Los líderes de IT, operaciones y compliance, que necesitan seguridad, trazabilidad y economías de escala.</p><p>Ambos buscan lo mismo —que el negocio avance—, pero desde prioridades diferentes.<br>Y en el medio está el equipo de plataforma, que traduce esas tensiones en decisiones técnicas.</p><h4>La interfaz como contrato de confianza</h4><p>El punto de equilibrio se encuentra en la interfaz de la plataforma:<br>esa capa que abstrae la complejidad sin quitar autonomía.</p><p>Una buena interfaz:</p><ul><li>Automatiza políticas sin frenar el flujo de trabajo.</li><li>Ofrece defaults seguros, pero configurables.</li><li>Expone capacidades técnicas con límites claros.</li><li>Comunica valor sin exigir aprendizaje extra.</li></ul><p>Ahí está el verdadero diseño arquitectónico: en cómo curamos la experiencia, no sólo en cómo desplegamos infraestructura.</p><h4>Pensar la plataforma como producto</h4><p>Cuando estuve del lado del usuario, lo que más valoraba era que “todo simplemente funcionara”.<br>Pero al construirla, entendí que eso ocurre sólo cuando hay una visión de producto detrás.</p><p>Los equipos de plataforma más exitosos que conozco:</p><ul><li>Publican roadmaps y recogen feedback.</li><li>Miden tiempo de onboard y adopción.</li><li>Automatizan compliance y despliegue.</li><li>Comunican mejoras y casos de éxito.</li></ul><p>No son equipos de soporte ni de infraestructura.<br>Son equipos de producto técnico, con clientes internos reales.</p><h4>El arquitecto como mediador</h4><p>El arquitecto de plataforma tiene que ser algo más que un diseñador de sistemas:<br>es quien media entre culturas.</p><p>Debe entender la presión del negocio por moverse rápido y la necesidad de control que sostiene la operación a largo plazo.<br>Su rol es traducir eso en decisiones concretas: contratos, abstracciones, automatismos.</p><p>Y hacerlo con empatía técnica.</p><h3>Reflexión final</h3><p>Una plataforma exitosa no se mide por cuántos servicios despliega, sino por cuánto reduce la fricción entre crear y controlar. Cuando el desarrollador avanza más rápido y el líder de IT duerme tranquilo, la arquitectura está haciendo su trabajo.</p><p>Lo viví como usuario y lo vivo ahora como constructor.<br>Y sigo convencido de que la verdadera innovación está en ese punto medio:<br>donde la tecnología habilita acuerdos, no los impone.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47acd3e6edce" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>