惯性聚合 高效追踪和阅读你感兴趣的博客、新闻、科技资讯
阅读原文 在惯性聚合中打开

推荐订阅源

I
InfoQ
Hugging Face - Blog
Hugging Face - Blog
月光博客
月光博客
量子位
freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
S
SegmentFault 最新的问题
罗磊的独立博客
Exploit-DB.com RSS Feed
Exploit-DB.com RSS Feed
L
LINUX DO - 最新话题
T
Threatpost
Cisco Talos Blog
Cisco Talos Blog
The GitHub Blog
The GitHub Blog
V
V2EX
SecWiki News
SecWiki News
P
Privacy & Cybersecurity Law Blog
Forbes - Security
Forbes - Security
T
Troy Hunt's Blog
S
Security @ Cisco Blogs
Martin Fowler
Martin Fowler
Attack and Defense Labs
Attack and Defense Labs
A
Arctic Wolf
C
CXSECURITY Database RSS Feed - CXSecurity.com
The Register - Security
The Register - Security
Blog — PlanetScale
Blog — PlanetScale
The Last Watchdog
The Last Watchdog
T
Tor Project blog
cs.CL updates on arXiv.org
cs.CL updates on arXiv.org
C
Cisco Blogs
P
Proofpoint News Feed
O
OpenAI News
Hacker News - Newest:
Hacker News - Newest: "LLM"
小众软件
小众软件
雷峰网
雷峰网
H
Heimdal Security Blog
酷 壳 – CoolShell
酷 壳 – CoolShell
Stack Overflow Blog
Stack Overflow Blog
Engineering at Meta
Engineering at Meta
云风的 BLOG
云风的 BLOG
Last Week in AI
Last Week in AI
C
Cyber Attacks, Cyber Crime and Cyber Security
Webroot Blog
Webroot Blog
C
Check Point Blog
Threat Intelligence Blog | Flashpoint
Threat Intelligence Blog | Flashpoint
W
WeLiveSecurity
T
Threat Research - Cisco Blogs
人人都是产品经理
人人都是产品经理
Hacker News: Ask HN
Hacker News: Ask HN
The Hacker News
The Hacker News
V
Vulnerabilities – Threatpost
Microsoft Security Blog
Microsoft Security Blog

DEV Community

Authentication Security Deep Dive: From Brute Force to Salted Hashing (With Java Examples) Why AI Systems Don’t Fail — They Drift Spilling beans for how i learn for exam😁"Reinforcement Learning Cheat Sheet" I Replaced Chrome with Safari for AI Browser Automation. Here's What Broke (and What Finally Worked) How Python Borrows Other People's Work The $40 Architecture: Processing 1 Billion API Requests with 99.99% Uptime Vibe Coding: A Workflow Guide (From Zero to SaaS) Most webhook security guides protect the wrong side. The scary part is delivery. Headless CMS for TanStack Start: Build a Blog with Cosmic EU Age Verification App "Hacked in 2 Minutes" — What Actually Happened Comfy Cloud’s delete function does not actually remove files Running AI Models on GPU Cloud Servers: A Beginner Guide Event-driven media intelligence with AWS Step Functions and Bedrock I scored 500 AI prompts across 8 quality dimensions — here's what broke How to Call Google Gemini API from Next.js (Free Tier, No Backend Needed) The Portal Protocol: Reclaiming Human Connection in the Age of AI How to Fix Your Team's Scattered Knowledge Problem With a Self-Hosted Forum Intro to tc Cloud Functors: A Graph-First Mental Model for the Modern Cloud Designing Multi-Tenant Backends With Both Ownership and Team Access I Built a Neumorphic CSS Library with 77+ Components — Here's What I Learned PostgreSQL Performance Optimization: Why Connection Pooling Is Critical at Scale Cómo construí un SaaS multi-rubro para gestionar expensas en Argentina con FastAPI + Vue 3 🚀 I Built an Ethical Hacking Scanner Tool – Open Source Project I Replaced /usage and /context in Claude Code With a Single Statusline A Pythonic Way to Handle Emails (IMAP/SMTP) with Auto-Discovery and AI-Ready Design I Collected 8.9 Million Polymarket Price Points — Here's What I Found About How Markets Really Move EcoTrack AI — Carbon Footprint Tracker & Dashboard Everyone's Using AI. No One Agrees How. 5 self-hosted ebook managers worth trying in 2026 Building Your First AI Agent with LangChain: From Chatbot to Autonomous Assistant Common SOC 2 Failures (Real World) Stop Vibe-Checking Your AI App: A Practical Guide to Evals How to Use SonarQube and SonarScanner Locally to Level Up Your Code Quality Your Next To-Do App Is Dead — I Replaced Mine with an OpenClaw AI Sign a Nostr event in 60 lines of Python using coincurve — no nostr-sdk, no nbxplorer, no rust toolchain ITGC Audit Explained Like You’re in Big 4 Patch Tuesday abril 2026: Microsoft parcha 163 vulnerabilidades y un zero-day en SharePoint Stop scraping everything: a better way to track competitor price changes Listing on MCPize + the Official MCP Registry while routing payments OUTSIDE the marketplace — how I kept 100% of my x402 revenue Building an AI-Powered Risk Intelligence System Using Serverless Architecture Why We Ripped Function Overloading Out of Our AI Toolchain Testing AI-Generated Code: How to Actually Know If It Works SaaS Churn Is Killing Your Business. Here Is What to Do About It (Without a Support Team) The Speed of AI Is No Longer Linear - And Self-Improving Models Are Why How to Implement RBAC for MCP Tools: A Practical Guide for Engineering Teams From Standard Quote to Persuasive Proposal: AI Automation for Arborists I built a CLI that scaffolds complete multi-tenant SaaS apps Axios CVE-2025–62718: The Silent SSRF Bug That Could Be Hiding in Your Node.js App Right Now The dashboard that ended our friendship Data Pipelines Explained Simply (and How to Build Them with Python) The Hidden Cost of AI Systems Nobody Talks About. undefined vs undeclared, and how typeof behaves Switching from file-based jobs to NATS/Kafka in Rust without changing code io_uring Adventures: Rust Servers That Love Syscalls Why Agentic AI is Killing the Traditional Database The POUR principles of web accessibility for developers and designers Quantum Neural Network 3D — A Deep Dive into Interactive WebGL Visualization How To Install Caveman In Codex On macOS And Windows Automation Pipeline Reliability: Why Your Workflow Breaks When Nobody Is Watching I Built an 'Open World' AI Coding Agent — It Works From ANY Folder From Freelancing to Product: A Tech Service Company's SaaS Transformation China's AI Giants: Adding Tencent Hunyuan & ByteDance Doubao to AI University (74 Providers) On the Vibe Coders and Their Lies clerk: Auto-Summarize Your Claude Code Sessions AI Weekly — 2026/04/10–04/17 | The Model Lockdown Is Here, but the Toolchain Is the Real Battleground AI 週報 — 2026/04/10–2026/04/17 模型封鎖潮來了,但工具鏈才是真戰場 Maybe this is how Open-Source apps are born... 🚀 Fine-Tune LLMs with LoRA and QLoRA: 2026 Guide tRPC v11 + Next.js App Router: End-to-End Type Safety Without the Boilerplate ShadCN UI in 2026: Why I Stopped Installing Component Libraries and Started Owning My Components SaaS Billing in React Server Components: Stripe + Supabase Without a Single `useEffect` Join our DEV Weekend Challenge — $1,000 in Prizes Across TEN winners! Submissions Due April 20 at 6:59 AM UTC. Implementing FSRS Spaced Repetition in Flutter + Supabase — Adding Memory Science to an AI Learning App "I Texted My Localhost From the Train — Claude Code Fixed the Bug Before I Got Home" I Built a Sales Prep AI and It Went Deeper Than Expected Design to Code #2: One JSON, Eleven Outputs Solving the 100M-Row Problem: A Summary Table Pattern for High-Volume Push Notification Logs Flutter Web With Wasm: What Actually Changes For Developers I Built 50 Royalty-Free Soundtracks for My Side Project in a Weekend Using AI Music Generation The Vibe Coding Security Checklist: 7 Things to Check Before You Ship Stop Letting Googlebot Guess Fix Your React App's SEO Right Desconstruindo o Streaming do LinkedIn: Como Criar um Engine de Extração de Vídeo de Alta Performance com HLS e FFmpeg (EDA Part-1) EDA (Exploratory Data Analysis) Explained With Real Life — Why Looking at Your Data Is the Most Important Step in Machine Learning Brand Relationship Management at Scale: Our 4-Touch Outreach System for 200+ Brands Why String.fromEnvironment() Might Return an Empty String in Dart JGuardrails 1.0.0 — Hardening Java LLM Apps Against Jailbreaks, Toxicity, and Prompt Injection Plan and Schedule a Full Week of Threads Content From One Claude Conversation Coding Cat Oran Ep3, Five Tables Changed Everything Updated: BFF Pattern I'm done watching freelancers get buried by 200 proposals. So I'm building the alternative. This is my first post BFS Algorithm in Java Step by Step Tutorial with Examples Tracking LLM Pricing Monthly: An Open Dataset for 22 AI Models How We Measure Content ROI on a Comparison Site: Revenue Attribution Without Perfect Data Introducing Nova AI Ops: The AI-Native Operating System for SRE Teams I built a free desktop video downloader for Windows — Grabbit How Talkie OCR Helps Vision-Impaired & Dyslexic Users Read the World Around Them VRCFaceTracking安装和iPhone面捕配置教程,有bug Even CrowdStrike Can't See Your Agents The Automation Gold Rush: What n8n Workflows and Claude Are Opening Up for Developers Right Now
Después del guardrail que me salvó la infra: así quedó mi arquitectura de agentes autónomos en producción
Juan Torchia · 2026-05-08 · via DEV Community

Después del guardrail que me salvó la infra: así quedó mi arquitectura de agentes autónomos en producción

¿Por qué asumimos que los agentes autónomos van a fallar de forma contenida? Hace un tiempo que me hago esa pregunta, pero no fue académica hasta que uno de mis agentes estuvo a punto de destruir mi infra en Railway. Lo que vino después —el rediseño, la arquitectura de permisos, la capa de observabilidad que agregué desde cero— es lo que no suele aparecer en los threads de Twitter que celebran "el agente que hizo todo solo".

Esto es el día después. La resaca del incidente. Lo que queda cuando el guardrail frena el caos y vos tenés que construir algo que no vuelva a fallar de la misma manera.


Arquitectura de agentes autónomos en producción: qué rompí y qué reconstruí

El incidente original lo documenté en el post de guardrails. No voy a repetir el relato completo, pero el resumen operativo es este: un agente con acceso write a mi API de Railway ejecutó una secuencia de pasos válidos individualmente que, en combinación, casi vacía un volumen de Postgres en producción. El guardrail lo frenó. Me quedé mirando el log con el corazón en la boca.

Lo que me molestó no fue que fallara. Es que yo había asumido que el scope de permisos era suficiente. Tenía el agente limitado a ciertos endpoints. Lo que no había modelado es que la combinación de endpoints válidos podía producir efectos destructivos.

Eso me obligó a pensar diferente. No en permisos planos —"este agente puede hacer X"— sino en grafos de permisos con contexto temporal y secuencia.

Mi arquitectura antes del incidente se parecía a esto:

Agente → API Gateway → Servicios
          (auth token)   (sin contexto de secuencia)

Enter fullscreen mode Exit fullscreen mode

Limpia. Simple. Equivocada.


El grafo de permisos que construí post-incidente

Lo primero que hice después de respirar fue dibujar el grafo real de lo que el agente podía hacer. No lo que yo creía que podía hacer: lo que efectivamente podía ejecutar dado el token y los endpoints expuestos.

El resultado fue incómodo. Había 14 caminos posibles desde "listar volúmenes" hasta "operación destructiva irreversible", y yo solo había bloqueado 3.

Rediseñé con tres capas:

Capa 1: Permisos atómicos con intención declarada

// Antes: el agente tenía un token con scope "read:volumes write:volumes"
// Después: cada acción declara intención y contexto

interface AccionAgente {
  tipo: 'lectura' | 'escritura' | 'eliminacion';
  recurso: string;
  intencion: string; // descripción legible de por qué
  reversible: boolean;
  requiereConfirmacion: boolean;
}

const accionPermitida = (accion: AccionAgente, contexto: ContextoEjecucion): boolean => {
  // Una acción de escritura después de dos lecturas sobre el mismo recurso
  // en la misma sesión dispara revisión manual obligatoria
  if (accion.tipo === 'escritura' && contexto.lecturasRecientes.includes(accion.recurso)) {
    if (contexto.accionesEnSesion > 3) return false; // corte duro
  }

  // Eliminaciones nunca son automáticas, sin excepción
  if (accion.tipo === 'eliminacion' && !accion.requiereConfirmacion) return false;

  return true;
};

Enter fullscreen mode Exit fullscreen mode

Capa 2: Estado de sesión con ventana deslizante

// El agente no solo tiene permisos: tiene un presupuesto de acciones por ventana
interface PresupuestoSesion {
  accionesTotales: number;       // máx 20 por sesión
  escrituras: number;            // máx 5 por sesión
  accionesCriticas: number;      // máx 1 por sesión (requieren aprobación)
  ventanaMinutos: number;        // 30 minutos por defecto
  ultimaAccion: Date;
}

// Si el agente llega a 80% del presupuesto, entra en modo solo-lectura
// Si llega al 100%, la sesión se cierra y loguea para revisión

Enter fullscreen mode Exit fullscreen mode

Capa 3: Grafo de transiciones prohibidas

Esto es lo que más tardé en modelar y lo que más me cambió la forma de pensar. No alcanza con bloquear acciones individuales: hay que bloquear secuencias.

// Transiciones que nunca pueden ocurrir en secuencia directa
const TRANSICIONES_PROHIBIDAS = [
  ['listar_volumenes', 'desmontar_volumen'],       // demasiado directo
  ['escalar_servicio', 'modificar_env_produccion'], // combinación destructiva
  ['rotar_secretos', 'reiniciar_servicio'],         // sin pausa de verificación
] as const;

const validarSecuencia = (historial: string[], accionSiguiente: string): boolean => {
  const ultimaAccion = historial[historial.length - 1];
  const estaProhibida = TRANSICIONES_PROHIBIDAS.some(
    ([desde, hacia]) => desde === ultimaAccion && hacia === accionSiguiente
  );
  if (estaProhibida) {
    logger.warn(`Transición prohibida detectada: ${ultimaAccion}${accionSiguiente}`);
    return false;
  }
  return true;
};

Enter fullscreen mode Exit fullscreen mode

Este patrón de transiciones prohibidas es lo que hubiera frenado el incidente original antes de que llegara al guardrail de último recurso. El guardrail es una red de seguridad; esto es el andamio que debería haber estado desde el principio.


La capa de observabilidad que agregué desde cero

Antes del incidente tenía logs. Después del incidente tengo trazabilidad de intención.

La diferencia es sutil pero fundamental. Un log dice "el agente ejecutó DELETE /volumes/xyz a las 23:47". La trazabilidad de intención dice "el agente declaró que iba a 'limpiar volúmenes huérfanos', ejecutó estas 7 acciones en secuencia, y la acción 5 desvió de la intención declarada en un 40%".

Eso es lo que implementé:

interface TraceAgente {
  sesionId: string;
  intencionDeclarada: string;         // lo que el agente dijo que iba a hacer
  accionesEjecutadas: AccionTrace[];
  desviacionDeIntencion: number;      // 0-100, calculado por similitud semántica
  alertasGeneradas: string[];
  tiempoTotal: number;
  estadoFinal: 'completado' | 'bloqueado' | 'cancelado' | 'error';
}

interface AccionTrace {
  timestamp: Date;
  accion: string;
  parametros: Record<string, unknown>;
  resultado: 'exito' | 'bloqueado' | 'error';
  tokensCosto?: number;               // si la acción involucra llamada a LLM
  latenciaMs: number;
}

Enter fullscreen mode Exit fullscreen mode

Esto corre en Postgres (el mismo stack que ya tenía documentado en el post de Docker Compose en producción) y me da una tabla de sesiones de agentes que puedo auditar. No es glamoroso. Es una tabla SQL con índices. Pero en las dos semanas que lleva corriendo, ya me detectó tres sesiones donde el agente se desvió de la intención declarada antes de que llegara a hacer algo dañino.

Los números concretos de esas dos semanas:

  • 47 sesiones de agente ejecutadas
  • 3 sesiones bloqueadas por desviación de intención > 60%
  • 1 sesión cancelada por presupuesto agotado
  • 0 incidentes en producción

Ese 0 me importa. Pero también me importa que el sistema generó 11 alertas que revisé manualmente y en 4 casos el agente tenía razón y yo estaba siendo demasiado conservador. Afinar esos umbrales es trabajo de semanas.


Los errores que cometí al rediseñar (para que no los repitas)

Error 1: Modelé los permisos como si el agente fuera un humano

Cuando diseñé los permisos, pensé en términos de "qué haría un dev humano con estos accesos". El agente no es un humano. Puede ejecutar 20 acciones en 8 segundos sin fatiga, sin duda, sin el freno intuitivo de "espera, esto no se siente bien". El modelo mental tiene que cambiar.

Error 2: Confundí observabilidad con logging

Tenía Datadog, tenía logs estructurados. Pensé que eso era observabilidad. No lo es, al menos no para agentes. Observabilidad de agentes requiere entender la intención y medir la distancia entre lo que el agente dijo que haría y lo que efectivamente hizo. Sin esa dimensión, los logs son un registro de daño, no una herramienta de prevención.

Este tema conecta con algo que ya exploré al diagnosticar deadlocks en producción: el problema no era que no tuviera datos. Era que los datos que tenía no me mostraban el estado del sistema en el momento relevante. Con agentes es igual.

Error 3: Asumí que el contexto del agente era estable

Un agente que ejecuta 15 pasos no tiene el mismo "entendimiento" en el paso 1 que en el paso 15. El contexto acumulado cambia su comportamiento. Yo diseñé los permisos para el agente en el paso 1, no para el agente que ya procesó 14 acciones y tiene el contexto completo de la sesión. Esa asimetría es peligrosa.

Ahora tengo ventanas de contexto con decay: las acciones más viejas de la sesión pierden peso en el cálculo de "qué tan alineado está el agente con su intención declarada". No es perfecto, pero es más honesto que asumir que el contexto es lineal.

Error 4: No modelé el costo de los falsos positivos

El primer sistema que desplegué era tan conservador que bloqueaba al agente cada tres acciones. Terminé apagándolo después de un día porque generaba más fricción que valor. La seguridad que genera fricción excesiva se desactiva. Eso también es un fallo de seguridad, solo que más lento.

Relacionado con lo que encontré al simular supply chain attacks sobre dependencias: la protección que duele demasiado se saca. Hay que calibrar para que el costo del guardrail sea menor que el costo del incidente que previene.


FAQ: Arquitectura de agentes autónomos en producción

¿Qué es un grafo de permisos para agentes y por qué es mejor que permisos planos?

Un grafo de permisos modela no solo qué puede hacer un agente, sino en qué secuencia y bajo qué condiciones de contexto. Los permisos planos dicen "puede leer y escribir". El grafo dice "puede escribir, pero solo si no leyó el mismo recurso más de dos veces en la última ventana, y solo si la intención declarada incluye una operación de escritura". La diferencia es la dimensión temporal y secuencial. Para agentes autónomos que ejecutan cadenas largas de acciones, es la diferencia entre un sistema contenible y uno que falla de formas que no anticipaste.

¿Cuánto agrega esto en latencia por acción del agente?

En mi stack, la validación de permisos + chequeo de secuencia + actualización de estado de sesión agrega entre 8 y 23ms por acción, dependiendo de si hay que consultar el historial completo de la sesión. Para la mayoría de los casos de uso, es aceptable. Si el agente está haciendo acciones que tardan segundos (llamadas a APIs externas, generación con LLM), 20ms es ruido. Si está haciendo operaciones de lectura en memoria que tardan microsegundos, ahí sí tenés que pensar si el overhead vale la pena.

¿Qué hago si el agente necesita hacer una transición que tengo prohibida pero por una razón legítima?

En mi arquitectura, las transiciones prohibidas se pueden desbloquear con aprobación explícita fuera de banda. El agente no puede auto-aprobarse; tiene que emitir una solicitud de desbloqueo que llega a una cola que yo reviso. En la práctica, pasó tres veces en dos semanas y las tres veces el agente tenía razón. Eso me dice que algunas de mis transiciones prohibidas son demasiado restrictivas. Estoy iterando. La alternativa —que el agente se auto-apruebe— no la considero.

¿Cómo medís la "desviación de intención" del agente?

Calculo similitud semántica entre la intención declarada al inicio de la sesión y una descripción textual de las acciones ejecutadas hasta el momento. Uso embeddings con un modelo liviano (no Claude para esto, el costo no escala). Si la similitud baja de un umbral, entra en modo de revisión. El umbral lo calibré empíricamente durante las primeras dos semanas: empecé en 70%, lo bajé a 55% después de demasiados falsos positivos. Sigue siendo una heurística; no es una garantía matemática.

¿Esto funciona con cualquier framework de agentes o es específico de tu stack?

Las tres capas —permisos atómicos con intención, presupuesto de sesión, grafo de transiciones prohibidas— son conceptualmente agnósticas al framework. Implementé esto a mano sobre mi API Gateway porque ningún framework que evalué tenía estas primitivas nativas en 2025. Si usás LangGraph o AutoGen, podés implementar el mismo patrón como middleware entre los nodos del grafo. El código específico cambia; el modelo mental no.

¿Qué pasa con los agentes que crean sub-agentes? ¿Los permisos se heredan?

Esta es la pregunta que más me preocupa y la que todavía no tengo bien resuelta. En mi stack actual, los sub-agentes heredan un subconjunto del presupuesto del padre, nunca el presupuesto completo. Si el agente padre tiene 20 acciones disponibles y crea un sub-agente, ese sub-agente arranca con máximo 5. El grafo de transiciones prohibidas se hereda completo. Pero la intención declarada no se propaga automáticamente: el sub-agente tiene que declarar su propia intención, que luego valido contra la del padre. Es imperfecto. Lo que sí tengo claro es que la herencia total de permisos —que es lo que hacen la mayoría de los frameworks por default— es una bomba de tiempo. También lo exploré en el post sobre agentes que crean cuentas y despliegan solos, aunque desde otro ángulo.


Lo que aprendí y lo que todavía no me cierra

Mi tesis, después de todo esto: los agentes autónomos no fallan por falta de capacidad, fallan por exceso de confianza en el modelo de permisos. Y el modelo de permisos que heredamos viene de sistemas donde el actor tiene estado emocional, fatiga y juicio situacional. Los agentes no tienen ninguno de los tres.

El rediseño que hice no es elegante. Es capas sobre capas de desconfianza formalizada. Validación de secuencias, presupuestos de sesión, trazabilidad de intención. Todo junto suma una arquitectura que es más lenta, más compleja y más difícil de mantener que lo que tenía antes.

Y aun así: cero incidentes en dos semanas. Tres desviaciones detectadas antes de que llegaran a hacer daño. Una infra que sigo confiándole trabajo real.

Lo que no me cierra todavía es la escala. Este sistema funciona para un agente, para tres agentes corriendo en paralelo. No sé cómo se comporta con veinte. El presupuesto de sesión se vuelve un recurso compartido que hay que coordinar, el grafo de transiciones se complejiza, la trazabilidad empieza a pesar en Postgres. Ese es el próximo problema. Por ahora, estoy resolviendo el que tengo.

Si venís del post de async Rust con edge cases en producción, sabés que mi tendencia es validar primero en mi codebase real antes de adoptar un patrón. Con esto no fue diferente. Dos semanas de datos reales valen más que cualquier arquitectura en una whiteboard.

El sistema está parado. Está fallando de formas que puedo ver. Por ahora, eso es suficiente.


Este artículo fue publicado originalmente en juanchi.dev