Un agente de IA que aprende solo con n8n: el Learning Loop

La mayoría de tutoriales de automatización con IA te enseñan a conectar un trigger con una llamada API. Eso es útil, pero no es inteligente. ¿Y si tu automatización pudiera aprender de sus propios fallos, detectar patrones en cientos de ejecuciones y generar recomendaciones priorizadas sin intervención humana?

Eso es exactamente lo que hace el workflow Agent Learning Loop. En Vorlux AI lo construimos para monitorizar nuestra propia flota de agentes IA. Cada 24 horas analiza las trazas de ejecución, identifica patrones de fallo recurrentes, guarda los aprendizajes en una API de memoria y notifica a nuestro canal de operaciones en Discord. En este tutorial lo construirás desde cero.

Lo que vas a construir

Un workflow de n8n con 5 nodos que:

1. Se ejecuta diariamente con un trigger programado
2. Obtiene las trazas de ejecución de tu API de orquestación
3. Analiza patrones de éxito y fallo con código JavaScript
4. Guarda los aprendizajes en un endpoint de memoria persistente
5. Envía un resumen a Discord (o Slack, email, etc.)

Tiempo estimado: 30-45 minutos Versión de n8n: 1.30+ (self-hosted o cloud) Dificultad: Intermedia

flowchart LR
    CRON["⏰ Trigger<br/>Programado (24h)"] --> FETCH["📥 Obtener<br/>Trazas"]
    FETCH --> ANALYZE["🔍 Analizar<br/>Patrones (JS)"]
    ANALYZE --> MEMORY["💾 Guardar<br/>Aprendizajes"]
    MEMORY --> NOTIFY["📣 Notificación<br/>Discord"]
    
    style CRON fill:#F5A623,color:#0B1628
    style FETCH fill:#1E293B,color:#FAFAFA
    style ANALYZE fill:#1E293B,color:#FAFAFA
    style MEMORY fill:#059669,color:#FAFAFA
    style NOTIFY fill:#1E293B,color:#FAFAFA

Requisitos previos

• Una instancia de n8n en funcionamiento (recomendamos self-hosted para privacidad, visita nuestra página de herramientas para opciones de despliegue local)
• Un endpoint API que exponga trazas de ejecución (nosotros usamos nuestro orquestador interno en localhost:3010, pero cualquier API de logging sirve)
• Una URL de webhook de Discord (o sustituye por cualquier canal de notificación)

Paso 1: Trigger programado

Crea un nuevo workflow en n8n y añade un nodo Schedule Trigger.

Configuración:

• Intervalo: Cada 1 día
• Campo: days

Este nodo se dispara cada 24 horas. Para desarrollo, puedes configurarlo temporalmente a cada 5 minutos y probar con el botón “Execute Workflow”.

Consejo: En producción, programa esto en horas de baja actividad (ej. 03:00 UTC) para analizar un día completo de actividad de agentes.

Paso 2: Obtener trazas recientes

Añade un nodo HTTP Request conectado al trigger.

Configuración:

• Método: GET
• URL: http://tu-api:3010/api/orchestrator/traces
• Parámetros de consulta:
  • period: 24h
  • status: all
• Timeout: 15000 ms

Esto obtiene todas las ejecuciones de agentes de las últimas 24 horas, tanto exitosas como fallidas. La respuesta debe ser un array de objetos de traza con al menos los campos: status, agent_id, error_type y error_message.

Si no tienes una API de orquestación, puedes usar los datos de ejecución propios de n8n. Usa el endpoint GET /api/v1/executions con los parámetros ?status=error&limit=100.

Paso 3: Analizar patrones de éxito y fallo

Este es el corazón inteligente del workflow. Añade un nodo Code con el siguiente JavaScript:

const traces = $input.first().json.data
  || $input.first().json.traces
  || [];

const successes = traces.filter(
  t => t.status === 'completed' || t.status === 'success'
);
const failures = traces.filter(
  t => t.status === 'failed' || t.status === 'error'
);

// Agrupar fallos por agente + tipo de error
const patterns = {};
failures.forEach(f => {
  const key = f.agent_id + ':' + (f.error_type || 'unknown');
  if (!patterns[key]) {
    patterns[key] = {
      agent_id: f.agent_id,
      error_type: f.error_type || 'unknown',
      count: 0,
      examples: []
    };
  }
  patterns[key].count++;
  if (patterns[key].examples.length < 3) {
    patterns[key].examples.push(f.error_message || f.message);
  }
});

// Generar recomendaciones para fallos recurrentes
const recommendations = Object.values(patterns)
  .filter(p => p.count >= 2)
  .map(p => ({
    agent_id: p.agent_id,
    recommendation: `Agente ${p.agent_id} falló ${p.count} veces `
      + `con ${p.error_type}. Considerar actualizar prompt o añadir fallback.`,
    priority: p.count >= 5 ? 'high' : 'medium'
  }));

return [{
  json: {
    totalTraces: traces.length,
    successes: successes.length,
    failures: failures.length,
    failurePatterns: Object.values(patterns),
    recommendations,
    generatedAt: new Date().toISOString()
  }
}];

Lo que hace este código:

• Separa las trazas exitosas de las fallidas
• Agrupa los fallos por agent_id + error_type para detectar patrones recurrentes
• Genera recomendaciones accionables solo para agentes que fallaron 2+ veces
• Asigna prioridad: high para 5+ fallos, medium para 2-4

Esta es la parte de “aprendizaje”. En lugar de alertar por cada error individual, se identifican problemas sistémicos que necesitan correcciones arquitecturales.

Paso 4: Guardar aprendizajes en memoria

Añade un nodo HTTP Request para persistir el análisis.

Configuración:

• Método: POST
• URL: http://tu-api:3010/api/memory/log
• Body (JSON):

{
  "type": "learning-loop",
  "data": {
    "recommendations": "{{ $json.recommendations }}",
    "patterns": "{{ $json.failurePatterns }}"
  },
  "agent": "system"
}

Esto crea un registro persistente. Con el paso de las semanas, construyes una base de conocimiento de qué falla y por qué: habilitando análisis de tendencias y ciclos de mejora de prompts.

Alternativa: Si no tienes una API de memoria, escribe en una Google Sheet, base de datos de Notion o incluso un archivo JSON local con el nodo File de n8n.

Paso 5: Notificación en Discord

Añade un segundo nodo HTTP Request (en paralelo al paso 4, no secuencial).

Configuración:

• Método: POST
• URL: {{ $env.DISCORD_OPS_WEBHOOK }}
• Body (JSON):

{
  "content": "**Agent Learning Loop**\nTrazas analizadas: {{ $json.totalTraces }}\nÉxito: {{ $json.successes }} | Fallos: {{ $json.failures }}\nRecomendaciones: {{ $json.recommendations.length }}"
}

Almacena la URL del webhook como variable de entorno en n8n (DISCORD_OPS_WEBHOOK) en lugar de escribirla directamente en el nodo.

Arquitectura completa del workflow

[Schedule Diario] --> [Obtener Trazas] --> [Analizar Patrones]
                                                |
                                                +--> [Guardar en Memoria]
                                                |
                                                +--> [Notificar Discord]

El nodo de análisis se bifurca en dos salidas paralelas: persistencia y notificación. Esto significa que un fallo en el envío a Discord no bloquea las escrituras en memoria.

Ampliaciones del workflow

Una vez que el bucle base funcione, considera estas mejoras:

1. Auto-remediación: Si un agente falla 10+ veces, desactivarlo automáticamente y notificar al equipo
2. Resumen semanal: Añadir un segundo trigger (semanal) que resuma tendencias de 7 días de datos del learning loop
3. Actualización automática de prompts: Para agentes con fallos consistentes, usar un nodo LLM que sugiera mejoras de prompt basadas en los patrones de error
4. Seguimiento de costes: Añadir datos de tokens/coste a las trazas y trackear el gasto por agente

Descarga el workflow

Puedes importar este workflow exacto en tu instancia de n8n. Descarga el JSON desde nuestra biblioteca de workflows, busca agent_learning_loop.json en la colección n8n.

Lecturas relacionadas

• n8n + MCP: Conecta Tus Agentes IA a Cualquier Herramienta de Negocio
• Crea un Pipeline de Contenido con IA usando n8n: De RSS a Blog
• Agentes de IA para pymes: de dónde sale de verdad el retorno

Por qué esto importa para Edge AI

En Vorlux AI desplegamos agentes IA en hardware local (Jetson, Mac Mini, Intel NUC) para PYMEs españolas. Cuando ejecutas 20+ agentes en infraestructura edge, no puedes permitirte monitorizar cada uno manualmente. El Learning Loop nos da observabilidad automatizada que mejora nuestro sistema sin añadir personal.

Esta es la diferencia entre “desplegamos IA” y “desplegamos IA que se vuelve más inteligente”. Si ejecutas cualquier tipo de sistema multi-agente, este patrón es esencial.

¿Listo para automatizar tus operaciones de IA? Explora nuestra biblioteca de workflows con más de 230 plantillas de n8n, o consulta nuestra página de herramientas para el stack completo de despliegue Edge AI.

Sources: n8n Documentation · Ollama API

¿Necesitas ayuda para configurar esto en tu negocio? Contáctanos para una evaluación gratuita de 30 minutos.

Siguientes pasos

• Configura tu nodo Schedule Trigger para una ejecución diaria.
• Implementa el nodo Code con el JavaScript proporcionado para el análisis de patrones.
• Configura el nodo HTTP Request para persistir los aprendizajes en tu API de memoria.
• Añade la notificación a Discord para recibir alertas de fallos en tu canal de operaciones.

Trabaja con nosotros

Podemos hacer este análisis con tus datos reales antes de recomendar hardware. Una conversación de 30 minutos suele bastar para saber si tiene sentido en tu caso: reserva una llamada o mira cómo trabajamos en consultoría.