OWASP Top 10 para aplicaciones agentes: lo que los desarrolladores de API deben cambiar

Ejemplo: Un agente de integración de Stripe tiene acceso a GET /api/customers/:id y POST /api/refunds. El agente lee el historial de pagos de un cliente, identifica el transacción de mayor valor y se emite un reembolso a sí mismo. Cada llamada individual pasa la autorización. La cadena es la hazaña.

Solución: límites de tarifas por agente y seguimiento de la profundidad de la cadena

La limitación de velocidad estándar cuenta las solicitudes por IP o por clave API. La limitación de tasa agente añade dos dimensiones:

• Límites por herramienta: Limitar cuántas veces un solo agente puede llamar a un punto final específico dentro de una ventana
• Límites de profundidad de la cadena: Realice un seguimiento de cuántas llamadas API secuenciales realiza un agente en una sola sesión y córtelas en un umbral definido

Requerir agentes para enviar una X-Agent-Session encabezamiento. Realice un seguimiento del recuento de llamadas por sesión. cuando el el recuento supera su umbral, devuelva un 429 con un mensaje de error claro.

3. Registro insuficiente: no hay visibilidad de las llamadas API del agente

El 48,9% de las organizaciones no ven el tráfico de máquina a máquina. Cuando un agente explota su API, usted Necesito responder: ¿qué agente? ¿Qué puntos finales? ¿En qué orden? ¿Durante qué ventana de tiempo? Registros de acceso estándar mostrar direcciones IP y marcas de tiempo. No muestran la identidad del agente ni las secuencias de llamadas.

La lista de agentes de OWASP señala el registro insuficiente como un riesgo principal porque los ataques de agentes parecen tráfico autorizado. Cada solicitud individual pasa la autenticación. El exploit vive en el patrón a lo largo de múltiples solicitudes.

Solución: requerir encabezados de atribución y registrar cadenas de llamadas

Agregue tres encabezados obligatorios para los consumidores de agentes:

• X-Agent-ID: identificador único para el agente (vinculado a su clave API)
• X-Agent-Session: identificador de la tarea o conversación actual
• User-Agent: marco y versión del agente (p. ej., LangChain/0.3.1)

// Middleware: log every agent request with attribution
function agentAuditLog(req, res, next) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    agentId: req.headers["x-agent-id"] || "unknown",
    apiKey: req.headers["x-api-key"]?.slice(-8) || "none",
    method: req.method,
    path: req.path,
    sessionId: req.headers["x-agent-session"] || "none",
    ip: req.ip,
    userAgent: req.headers["user-agent"]
  };

  // Structured JSON log for your SIEM
  console.log(JSON.stringify(logEntry));

  // Track chain depth per session
  const session = req.headers["x-agent-session"];
  if (session) {
    const depth = chainTracker.increment(session);
    if (depth > MAX_CHAIN_DEPTH) {
      return res.status(429).json({
        error: "Agent chain depth exceeded",
        maxDepth: MAX_CHAIN_DEPTH,
        currentDepth: depth
      });
    }
  }

  next();
}

Este middleware registra cada solicitud como JSON estructurado, que alimenta cualquier SIEM o agregador de registros. También refuerza la profundidad de la cadena mediante el seguimiento de llamadas secuenciales por sesión. Cuando investigas un incidente, puedes reconstruir la cadena completa filtrando por sessionId.

4. Manejo de resultados inseguro: agentes que confían en las respuestas de la API sin validación

Un agente llama a su API, recibe una respuesta JSON y la pasa al siguiente paso de su cadena. si el La respuesta contiene campos inesperados, tipos incorrectos o contenido inyectado, el agente propaga el problema. aguas abajo. Este es el equivalente agente de OWASP API10 (consumo inseguro de API), amplificado por el hecho de que los agentes procesan las respuestas automáticamente sin revisión humana.

Ejemplo: Un competidor compromete una API de precios de terceros. El agente busca el producto. precios, recibe una respuesta con un mensaje manipulado price campo establecido en 0.01 y realiza un pedido a ese precio. Ningún humano vio jamás la respuesta.

Solución: valide cada respuesta con un esquema JSON

Comience generando un esquema a partir de una buena respuesta conocida. El /v1/schema/json-to-jsonschema El punto final produce un esquema JSON a partir de cualquier JSON de muestra:

curl -s -X POST https://api.botoi.com/v1/schema/json-to-jsonschema \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "json": {
      "orderId": "ord_12345",
      "status": "shipped",
      "total": 49.99,
      "items": [
        { "sku": "WIDGET-A", "quantity": 2 }
      ]
    }
  }'

Respuesta:

{
  "success": true,
  "data": {
    "schema": {
      "type": "object",
      "properties": {
        "orderId": { "type": "string" },
        "status": { "type": "string" },
        "total": { "type": "number" },
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "sku": { "type": "string" },
              "quantity": { "type": "integer" }
            }
          }
        }
      }
    }
  }
}

Luego valide cada respuesta que reciba su agente con ese esquema. El /v1/schema/validate El punto final compara un objeto JSON con cualquier esquema JSON y devuelve errores específicos:

curl -s -X POST https://api.botoi.com/v1/schema/validate \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "schema": {
      "type": "object",
      "required": ["orderId", "status", "total"],
      "properties": {
        "orderId": { "type": "string" },
        "status": { "type": "string", "enum": ["pending", "shipped", "delivered"] },
        "total": { "type": "number", "minimum": 0 }
      },
      "additionalProperties": false
    },
    "data": {
      "orderId": "ord_12345",
      "status": "shipped",
      "total": 49.99,
      "internalNote": "rush order"
    }
  }'

Respuesta:

{
  "success": true,
  "data": {
    "valid": false,
    "errors": [
      {
        "path": "",
        "message": "must NOT have additional properties: internalNote"
      }
    ]
  }
}

La validación atrapada internalNote, un campo que no pertenece a la respuesta. Si una API comienza a devolver campos inesperados, su agente deja de procesar en lugar de pasar datos contaminados.

Aquí está el patrón completo usando el SDK de Botoi Node.js:

import Botoi from "botoi";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

// Step 1: generate a schema from a known-good response
const schemaResult = await botoi.schema.jsonToJsonschema({
  json: knownGoodResponse
});
const responseSchema = schemaResult.data.schema;

// Step 2: validate every agent-received response against that schema
async function validateAgentResponse(response) {
  const validation = await botoi.schema.validate({
    schema: responseSchema,
    data: response
  });

  if (!validation.data.valid) {
    console.error("Response failed validation:", validation.data.errors);
    throw new Error("Untrusted response rejected by schema validation");
  }

  return response;
}

5. Vulnerabilidades de la cadena de suministro: definiciones de herramientas comprometidas

Los agentes de IA descubren herramientas a través de servidores MCP, especificaciones de OpenAPI y manifiestos de herramientas. Si un atacante modifica una definición de herramienta, el agente llama a un punto final diferente, envía datos a un servidor diferente o ejecuta con parámetros diferentes a los previstos por el desarrollador.

Ejemplo: Utiliza un servidor MCP de código abierto que define 30 herramientas. Un atacante presenta una solicitud de extracción que cambia la URL API de una herramienta de api.stripe.com a api.str1pe.com. El cambio pasa la revisión del código porque es un solo carácter. tu agente ahora envía datos de pago al servidor del atacante.

Solución: definiciones de herramientas hash y verificación en tiempo de ejecución

Haga un hash de cada definición de herramienta en el momento de la implementación. Antes de que su agente registre una herramienta en tiempo de ejecución, vuelva a aplicar hash y comparar. El /v1/hash El punto final genera un hash SHA-256 de cualquier cadena:

curl -s -X POST https://api.botoi.com/v1/hash \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "text": "{\\"name\\":\\"get_order_status\\",\\"description\\":\\"Retrieve current order status by order ID\\",\\"parameters\\":{\\"orderId\\":\\"string\\"}}",
    "algorithm": "sha256"
  }'

Respuesta:

{
  "success": true,
  "data": {
    "hash": "a3f2b8c1d4e5f67890abcdef1234567890abcdef1234567890abcdef12345678",
    "algorithm": "sha256"
  }
}

Aquí está el flujo de trabajo de verificación de integridad completo utilizando el SDK de Botoi:

import Botoi from "botoi";
import fs from "fs";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

// Hash every tool definition at deploy time
const toolDefs = JSON.parse(fs.readFileSync("./mcp-tools.json", "utf-8"));
const hashes = {};

for (const tool of toolDefs) {
  const result = await botoi.hash.sha256({
    text: JSON.stringify(tool)
  });
  hashes[tool.name] = result.data.hash;
}

fs.writeFileSync("./tool-hashes.json", JSON.stringify(hashes, null, 2));

// At runtime, verify before registering any tool
async function verifyToolIntegrity(tool) {
  const result = await botoi.hash.sha256({
    text: JSON.stringify(tool)
  });
  const expected = hashes[tool.name];

  if (result.data.hash !== expected) {
    throw new Error(
      \`Tool "\${tool.name}" failed integrity check. \\n\` +
      \`Expected: \${expected}\\n\` +
      \`Got: \${result.data.hash}\`
    );
  }
}

Ejecute el paso de generación de hash en su canalización de CI. Almacene el archivo hashes junto con su implementación artefacto. En tiempo de ejecución, cada herramienta se verifica antes del registro. Un solo carácter cambiado en cualquier La definición de la herramienta provoca un fallo grave.

OWASP agentic top 10 vs API Security top 10: comparación

Las dos listas se complementan. Así es como los cinco riesgos agentes se relacionan con su API más cercana. contrapartes y qué cambios:

Lista de verificación de envío: cinco soluciones para la seguridad de API agente

Cada solución es independiente. Elija uno, envíelo y pase al siguiente.

¿Qué viene después?

El Top 10 completo de OWASP para aplicaciones agentes se encuentra en owasp.org. Cisco, Microsoft y Google anunciaron iniciativas de seguridad agente en RSAC 2026, así que espere herramientas y estándares para avanzar rápidamente durante el resto del año.

Los cinco riesgos restantes en la lista (inyección rápida, envenenamiento de la memoria, fallas en cascada, pérdida de datos) Fugas y Sandboxing inadecuado) requieren correcciones en la capa de marco del agente, no en la capa de API. si Si ejecuta un marco de agente, lea el documento completo de OWASP. Si ejecuta API, las cinco correcciones anteriores son tu punto de partida.

Comience con claves API con alcance. Ese único cambio bloquea la mayoría del uso excesivo de agencia y herramientas. escenarios. Luego agregue encabezados de atribución para que pueda ver lo que están haciendo sus agentes. El resto se desprende de visibilidad.