Agentes de IA en Fastly Compute: cómo funciona y qué lo hace seguro

Gestionar cargas de trabajo de IA en Fastly Compute no solo es posible; es altamente efectivo porque aprovecha de manera inherente la baja latencia del edge y el aislamiento estricto de nuestro entorno. En esta publicación, desglosaremos varios patrones para agregar funciones de agente a tus servicios de Fastly Compute usando API de LLM, y explicaremos cómo nuestra plataforma Compute, al ejecutar código en entornos aislados de WebAssembly, garantiza que tu agente se ejecute con una velocidad óptima y seguridad de nivel empresarial.

Diseño de bucles de retroalimentación para un agente de IA

Este gif animado muestra un asistente de IA lanzado recientemente ejecutándose en el Panel de control de Fastly. Cuando le envías un prompt a un chat basado en IA como este, probablemente estás acostumbrado a esperar mientras el agente de IA está "pensando". En lugar del cálculo en tiempo de prueba (TTC) del modelo en sí, donde el modelo "piensa" más a fondo antes de dar una respuesta, puedes implementar este tipo de proceso de pensamiento construyendo un agente que use los resultados de las llamadas API de LLM como retroalimentación para alcanzar un objetivo. A este método a menudo se le conoce como bucle de agente. Este proceso repite continuamente una secuencia de pasos —como razonar, planificar, actuar con herramientas y observar los resultados— hasta que el objetivo se completa con éxito. 

El flujo de ejecución de este bucle de retroalimentación se ilustra a continuación. Si bien suele ser el caso de que un solo intercambio en el que un LLM genera de inmediato una respuesta a una instrucción no puede producir la respuesta deseada, este mecanismo permite que el agente continúe de forma autónoma el bucle de ejecutar y evaluar repetidamente los pasos (1) a (3), lo que mejora la precisión y entrega el resultado final.

Este bucle se puede desplegar en varios entornos, desde la infraestructura local hasta servidores remotos. Veamos el flujo de procesamiento dentro de un entorno remoto mediante Fastly Compute a través de una implementación mínima. Por ejemplo, el SDK de JavaScript de Fastly Compute permite esta implementación como se muestra a continuación. Ten en cuenta que este código se puede validar al inicializar un Starter Kit de TypeScript con $npx fastly compute init, reemplazando src/index.ts con el siguiente código;

addEventListener("fetch", (event) => event.respondWith(handleRequest(event)));

async function handleRequest(event: FetchEvent) {
 let payload = {
   model: 'gpt-5.2',
   messages: [{role: "user", content: "what's the weather today?"}],
   tools: [{ "type": "function", "function": {
               "name": "get_weather",
               "description": "retrieve weather forecast",
               "parameters": {}}}]}
 while(true){ // Agent loop begins
   let res = await (await fetch("https://<LLM_API_ENDPOINT>/chat/completion", {
     method: "POST",
     headers: new Headers({
       "Content-Type": "application/json",
       "Authorization" : "Bearer <YOUR_ACCESS_TOKEN>",
     }),
     body: JSON.stringify(payload)
   })).json();
   if (res.choices[0].finish_reason != "tool_calls") {
     return new Response(JSON.parse(res.choices[0].message.content))
   }
   if (res.choices[0].message.tool_calls != undefined) {
     for (const toolCall of res.choices[0].message.tool_calls ) {
       if (toolCall.type === "function") {
         payload.messages.push({
           role: "user",
           content: "{\"weather\":\"windy and rainy\"}" // pseudo result
         });
       }
     }
   }
 }
}

La ejecución de este código sigue este flujo de alto nivel:

1. Envía el prompt "¿cómo está el clima hoy?" a la API de LLM.

2. La API de LLM devuelve una instrucción para ejecutar la herramienta get_weather.

3. Agrega un valor ficticio "ventoso y lluvioso" como resultado provisional al prompt y vuelve a invocar la API de LLM (Agent Loop).

4. Recibe una señal de finalización de la API de LLM (es decir, se devuelve stop como finish_reason) y muestra el resultado final.

La ejecución de este programa en mi entorno de pruebas utilizando el modelo gpt-5.2 arrojó el siguiente resultado para el paso 4: 

"Hoy hay viento y lluvia. Si vas a salir, lleva una chamarra impermeable y un paraguas, y ten cuidado con los caminos resbalosos y las ráfagas fuertes. ¿Quieres un desglose por hora o consejos para tus traslados o planes al aire libre?".

El resultado derivado de este bucle iterativo del agente ejemplifica el bucle de retroalimentación analizado anteriormente —una técnica de procesamiento utilizada con frecuencia detrás del indicador "Pensando..." en las interfaces de chat modernas—.

El bucle del agente en constante evolución

Los Agent Loops han llamado la atención desde hace un tiempo, pero este año, la aparición de interfaces con herramientas externas como MCP (p. ej., servidor MCP de Fastly) y las llamadas a herramientas los han potenciado. Esta evolución se simplifica en el siguiente diagrama.

Se proporciona aquí un ejemplo concreto de código de Compute que gestiona el procesamiento e incluye llamadas a herramientas remotas. En este ejemplo, usamos OpenAI's Responses API (anunciada en mayo) como ejemplo que permite llamadas a herramientas remotas, aunque son posibles operaciones similares con Anthropic's Messages API y otras. Puedes ejecutar este código siguiendo los pasos a continuación. En unas 60 líneas de código JavaScript, resumimos las mejores prácticas para migrar los servicios VCL de Fastly a Compute en función de los resultados de búsqueda de documentos, para finalmente generar un archivo de PowerPoint editable (no un archivo PDF).

$ mkdir compute-agent-demo && cd compute-agent-demo
$ npx fastly compute init -l javascript -i
$ npm install pptxgenjs openai hono @fastly/hono-fastly-compute abortcontroller-polyfill
$ curl -s "https://gist.githubusercontent.com/remore/25a1638a3a2183daa609044cfa1ce6f9/raw/818322d634d59c10950878932517c4173b746dd3/index.js" > src/index.js
$ vi src/index.js # Put your API Token and rmeote MCP server address
$ fastly compute serve

Un ejemplo del resultado real del archivo de PowerPoint se ve de la siguiente manera. Aprovechando la capacidad del LLM para resumir información y generar código, ahora podemos generar un archivo binario editable de PowerPoint (.pptx) con contenido persuasivo que cumpla con el objetivo.

Una diferencia importante entre este ejemplo de código y el anterior es que no hay ninguna sentencia while() en el programa. Dado que esta vez el bucle de IA del agente se ejecuta del lado de la API de LLM, el código de Compute (que actúa como el agente) no implementa un bucle while(). Esto mejora la legibilidad del programa y demuestra cómo los avances recientes han impulsado un entorno en el que los flujos de trabajo de IA son significativamente más fáciles de implementar.

const bestPractices = await callLLM(
    'What are the best practices to migrate a fastly vcl service to compute? Outline ten practices and give each a summary of at least 300 characters.',
    [{
      "type": "mcp",
      "server_label": "fastly-doc-search",
      "server_url": "https://xxxxxxx.edgecompute.app/mcp",
      "require_approval": "never",
    }]
  )

Como nota al margen, implementamos esta demostración integrando un servidor MCP remoto que se ejecuta en Compute bajo el dominio edgecompute.app al invocar la función callLLM(), como se muestra en el código anterior. Aunque cualquier servidor MCP remoto es compatible, utilicé un servidor MCP implementado en Fastly Compute para aprovechar la plataforma sin servidor en el edge, la cual siempre se invoca desde el centro de datos más cercano a la API de LLM. Esto minimiza la latencia en las llamadas a herramientas, lo que contribuye a la optimización del tiempo hasta el primer token (TTFT). Las capacidades de Fastly Compute, que incluyen la ejecución en el edge de baja latencia y el soporte para respuestas en streaming, proporcionan un respaldo potente para el desarrollo de tus agentes de IA. Para obtener más detalles sobre la implementación de un servidor MCP mediante Compute, consulta mi publicación del blog anterior.

Cómo la plataforma de Fastly y el aislamiento en sandbox de Wasm protegen tu carga de trabajo de IA

Por último, hablemos de la seguridad, que es clave para una IA confiable. Determinar qué permisos conceder a los agentes de IA y cómo gestionarlos ha sido una preocupación importante para los desarrolladores. Aunque las discusiones suelen centrarse en diseñar modelos permisivos para acelerar el desarrollo al usar agentes de código como Claude Code, Gemini CLI y Codex, diseñar flujos de trabajo de IA empresariales requiere una perspectiva de diseño de permisos restrictivos.

Al utilizar Fastly Compute, los programas se benefician fácilmente del aislamiento del sandbox del tiempo de ejecución de WebAssembly y de las funciones de seguridad de la memoria, como la comprobación de límites de memoria lineal dentro de límites de seguridad claros. Por ejemplo, la ejecución de código dinámico mediante el constructor AsyncFunction(), tal como se implementa en el ejemplo anterior, generalmente se considera un riesgo de vulnerabilidad y un antipatrón en muchos tiempos de ejecución de JavaScript. Aunque requiere un uso cuidadoso incluso en Fastly Compute, la plataforma se ejecuta en un entorno aislado de WebAssembly que carece de forma inherente de acceso al sistema de archivos, E/S de red o capacidades de ejecución de comandos externos, lo que permite que el agente realice un procesamiento autónomo con una superficie de ataque minimizada.

Eso no es todo: las diversas Hostcalls que proporciona la plataforma Fastly Compute también incluyen varias consideraciones de seguridad. Por ejemplo, los límites en el número de llamadas de obtención y envío (fetch/send) del backend ayudan a evitar la emisión de solicitudes externas excesivas. Además, nuestro mecanismo de "Static Backend" puede restringir el tráfico a servidores externos predefinidos, lo que evita que el agente realice solicitudes HTTP a servidores externos no deseados o desconocidos.

 // example of dynamic backend
 fetch("https://example.com/some-path") 

 // example of static backend, restricting traffic to pre-defined external servers
 fetch("https://example.com/some-path", {backend: "example-com"})

Este mecanismo no solo protege los flujos de trabajo de IA contra la ejecución maliciosa, sino que también permite la autorización selectiva de comportamientos más amplios a través de una función llamada “Backends dinámicos”. Al permitir la asignación granular de capacidades a los programas que se ejecutan como módulos Wasm dentro de una infraestructura segura, Fastly Compute facilita la implementación perfecta de la seguridad en los flujos de trabajo de IA.

Garantizar el control mediante el uso de tecnologías y especificaciones estandarizadas

En esta publicación, presentamos varios métodos para implementar eficazmente agentes de IA en Fastly Compute. Los agentes de IA se han vuelto indispensables para impulsar mejoras significativas en la productividad y la eficiencia operacional. Al utilizar Fastly Compute —un entorno de nivel empresarial que equilibra el rendimiento y la seguridad—, puedes desarrollar agentes que aprovechen al máximo el poder de la IA. Espero que esta publicación te ayude a desarrollar agentes de IA con una mejor experiencia. Únete a la conversación en nuestro foro y cuéntanos qué estás construyendo.