Cloudflare Project Think: el cambio de arquitecturas efímeras a agentes durables con memoria relacional

Introducción

Los frameworks tradicionales para agentes de IA —como el AWS Bedrock AgentCore o Google ADK— operan bajo un modelo de orquestación stateless donde el estado de la sesión se externaliza en un KV store o JSON remoto. El problema no es la persistencia en sí, sino la granularidad: cuando un proceso serverless se interrumpe durante una tarea de larga duración (por ejemplo, un bucle de razonamiento con 2000 tokens de contexto), el sistema pierde el progreso específico dentro de ese ciclo. La recuperación solo puede volver al último snapshot guardado, reiniciando la operación completa. Esto genera latencias innecesarias y costos en tokens, especialmente en flujos no determinísticos.

Project Think de Cloudflare aborda este cuello de cuello con un diseño actor-based donde cada agente es una entidad durable que sobrevive a reinicios de plataforma. Su aporte clave es el concepto de Fibers, primitivas de ejecución que checkpointean su propio puntero de instrucción en una base de datos SQLite co-localizada. Esto permite retomar el trabajo exactamente donde se interrumpió, incluso tras un crash del Worker.

Qué ocurrió

El 21 de abril de 2026, Cloudflare anunció en modo preview Project Think, un conjunto de primitivas para su SDK de Agents que redefine el ciclo de vida de los agentes de IA:

1. Runtime tipo kernel: Un componente central que gestiona la creación, checkpointeo y recuperación de agentes como entidades durables.
2. Fibers como primitivas de ejecución: Cada fiber es una invocación duradera que puede serializar su estado interno (incluyendo el puntero de instrucción) en una base de datos SQLite local. Esto evita la dependencia exclusiva de snapshots externos y reduce la pérdida de contexto.
3. Memoria relacional: Las sesiones ya no son secuencias lineales, sino árboles donde cada mensaje tiene un parent_id. Esto permite bifurcar conversaciones para explorar alternativas sin contaminar el flujo principal.
4. Sandboxing dinámico: Los agentes pueden generar y ejecutar código en Dynamic Workers, entornos V8 aislados que arrancan en milisegundos sin privilegios de sistema.

El announcement destaca que Project Think está diseñado para agentes que requieren ejecución prolongada (por ejemplo, orquestación de microservicios, análisis de datos no determinísticos o interacción multi-turno con herramientas externas). La arquitectura anterior de Cloudflare Workers —basada en respuestas inmediatas— no estaba preparada para estos casos de uso.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de Infraestructura y Cloud

1. Reducción de costos en serverless:

– Ejemplo: Un agente que antes requería 5000 tokens por ciclo de razonamiento (por procesar datos intermedios en el LLM) ahora ejecuta la lógica en un Dynamic Worker aislado, reduciendo el payload a 1500 tokens.

1. SLA mejorados en tareas críticas:

– Con Fibers, el agente recupera su puntero de instrucción y continúa desde el último checkpoint, eliminando este overhead.

1. Compatibilidad con patrones actor-based:

Para equipos de Seguridad

1. Nuevos vectores de ataque:

– Recomendación: Usar OpenTelemetry para auditar las llamadas a Dynamic Workers y aplicar políticas de least privilege mediante policy-as-code (ejemplo: restringir el uso de eval() en el código autogenerado).

1. Logging y trazabilidad:

– trace_id (para seguir el flujo en herramientas como Jaeger).

– parent_id (para reconstruir el árbol de decisiones).

– Ejemplo de estructura de log (JSON):

     {
       "agent_id": "think_fiber_abc123",
       "message_id": "msg_xyz456",
       "parent_id": "msg_prev789",
       "checkpoint": true,
       "timestamp": "2026-04-21T14:30:00Z",
       "trace_id": "trace_5f2e1a"
     }
     

1. Gobernanza de SBOM:

– Dependencias de los Workers (versiones de V8, librerías estándar).

– Código autogenerado (aunque sea transitorio, debe ser auditado).

– Herramientas como Syft o Trivy pueden escanear los Workers en tiempo de deployment.

Para equipos de DevOps

1. Cambios en pipelines:

– Validar que los fibers tengan un estado inicial válido antes de deployar.

– Monitorear la ocupación de la SQLite interna (Cloudflare usa una base de datos embebida en el Worker).

– Ejemplo de validación en GitHub Actions:

     - name: Validar estado de Fibers
       run: |
         curl -X POST https://api.cloudflare.com/workers/think/check \
           -H "Authorization: Bearer ${{ secrets.CF_API_TOKEN }}" \
           -d '{"agent_id": "think_fiber_abc123", "checkpoint": true}'
     

1. Integración con OpenTelemetry:

     export OTEL_EXPORTER=otlp
     export OTEL_EXPORTER_ENDPOINT=https://api.cloudflare.com/otel/v1/traces
     otel-cli export --service think-agents
     

1. Escalabilidad:

– Solución: Implementar compaction automática de contextos antiguos usando los Context Blocks de Project Think.

Detalles técnicos

Componentes clave y versiones

1. Inyección de código en Dynamic Workers:

– Mitigación:

– Usar la opción restricted: true al crear un Dynamic Worker.

– Aplicar CSP (Content Security Policy) en el Worker:

       const worker = new DynamicWorker({
         code: agentGeneratedCode,
         restricted: true,
         csp: "default-src 'self'; script-src 'none';"
       });
       

1. Denegación de servicio por estado excesivo:

– Mitigación:

– Configurar un timeout para la compaction automática de contextos antiguos:

       ctx.stash({
         maxDepth: 100,
         autoCompact: true,
         compactInterval: "5m"
       });
       

1. Fugas de memoria en Fibers:

– Mitigación:

– Usar ctx.stash().setMaxMemory(5 * 1024 * 1024) (5MB) para limitar el consumo.

Comandos y APIs relevantes

1. Crear un Fiber con checkpointeo:

   import { think } from "@cloudflare/agents";

   const fiber = await think.runFiber({
     id: "agent_orchestrator",
     code: `async function main(ctx) {
       while (true) {
         const progress = ctx.stash().get("progress") || 0;
         ctx.log(`Progreso: ${progress}`);
         if (progress >= 100) break;
         await ctx.stash().set("progress", progress + 10);
         await ctx.sleep(1000);
       }
     }`,
     onFiberRecovered: (ctx) => {
       const progress = ctx.stash().get("progress");
       ctx.log(`Recuperado en progreso: ${progress}`);
     }
   });
   

1. Generar código en un Dynamic Worker:

   const toolCode = `
     function sum(a, b) {
       return a + b;
     }
   `;

   const worker = new DynamicWorker({
     code: toolCode,
     restricted: true
   });

   const result = await worker.execute({ a: 5, b: 3 });
   

1. Consultar la Session API:

   curl -X GET "https://api.cloudflare.com/think/sessions/agent_orchestrator" \
     -H "Authorization: Bearer $CF_TOKEN" \
     -H "Accept: application/vnd.api+json"
   

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar la migración a Project Think

• Auditoría inicial:

– Usar CloudWatch Logs o CloudTrail para medir el porcentaje de timeouts en los últimos 30 días.

• Prueba de concepto:

– Validar que el fiber recupere correctamente el estado tras un reinicio simulado (usar wrangler dev --local).

1. Restringir el uso de Dynamic Workers:

     [env.production]
     dynamic_workers_restricted = true
     

– Validación en CI/CD:

– Usar una política OPA (Open Policy Agent) como esta:

       package cloudflare.think.security

       deny[msg] {
         input.worker.type == "dynamic"
         input.worker.restricted != true
         msg := "Dynamic Workers deben estar en modo restricted"
       }
       

1. Monitoreo con OpenTelemetry:

     # otel-config.yaml
     receivers:
       otlp:
         protocols:
           grpc:
           http:

     exporters:
       logging:
         logLevel: debug
       jaeger:
         endpoint: "jaeger:14250"

     service:
       pipelines:
         traces:
           receivers: [otlp]
           exporters: [jaeger, logging]
     

– Dashboard recomendado:

– Métricas clave:

– think.fibers.checkpoint.duration (latencia de checkpointeo).

– think.workers.sandbox.violations (intentos de escape de sandbox).

1. Gobernanza de SBOM:

     - name: Escanear SBOM de Project Think
       uses: aquasecurity/trivy-action@master
       with:
         scan-type: 'fs'
         scan-ref: './workers/think-agents/'
         format: 'cyclonedx'
         output: 'sbom-think.json'
     

3. Optimizar la arquitectura

1. Rediseñar sesiones lineales a árboles:

     { "session": ["msg1", "msg2", ...] }
     

por:

     {
       "session": {
         "root": "msg1",
         "children": [
           { "id": "msg2", "parent_id": "msg1" },
           { "id": "msg3", "parent_id": "msg1", "branch": "alternative_solution" }
         ]
       }
     }
     

1. Implementar compaction automática:

     ctx.stash({
       maxDepth: 50,          // Profundidad máxima del árbol
       autoCompact: true,
       compactOlderThan: "7d"  // Eliminar ramas mayores a 7 días
     });
     

1. Balancear entre sandboxing y rendimiento:

     const result = await think.run({
       code: `return 42;`,
       durable: false  // No usa Fiber
     });
     

Conclusión

Project Think marca un cambio de paradigma: de agentes stateless que dependen de snapshots externos a entidades durables con memoria relacional y sandboxing local. Para equipos de DevOps, esto implica repensar pipelines, monitoreo y políticas de seguridad. Para áreas de Cloud e Infraestructura, los beneficios son claros: reducción de costos en serverless, mejoras en SLA y soporte nativo para flujos no determinísticos.

La adopción debe ser gradual:

1. Validar en entornos de preview con agentes críticos.
2. Implementar políticas de seguridad estrictas (especialmente en Dynamic Workers).
3. Integrar herramientas como OpenTelemetry y SBOM desde el inicio.

Cloudflare aún está en fase experimental, pero las primitivas de Project Think —Fibers, memoria relacional y sandboxing— son un avance hacia arquitecturas más resilientes para IA en producción.

FIN