Cómo permitir que los agentes de IA envíen email

Los agentes de IA que no pueden enviar email están a medio construir. Pueden razonar, buscar, resumir y planificar, pero en el momento en que necesitan notificar a un cliente, dar seguimiento a un lead o confirmar una cita, chocan con un muro. El email sigue siendo el canal de comunicación por defecto para los negocios, y tus agentes necesitan acceso directo a él.

Esta guía te muestra cómo conectar agentes de IA para enviar email a través de la API de Sendkit, con código funcional en Node.js y Python, guardrails de seguridad e integración con webhooks para workflows de ciclo cerrado.

Por qué los agentes de IA necesitan email

Los casos de uso están por todas partes una vez que los miras:

• Agentes de soporte al cliente resuelven un ticket y envían un resumen al cliente. Ningún humano copia y pega una plantilla.
• Agentes de ventas califican leads entrantes y envían seguimientos personalizados en segundos después del envío de un formulario.
• Agentes de agendado negocian horarios de reuniones por email, enviando confirmaciones e invitaciones de calendario automáticamente.
• Agentes de notificación monitorean sistemas y alertan a los interesados cuando algo se rompe, con contexto que el LLM armó a partir de los logs.

En cada caso, el agente genera el contenido. Tu código lo valida. Sendkit lo entrega. Esa separación importa.

La arquitectura

Nunca dejes que un LLM llame directamente a una API de email sin supervisión. El patrón que funciona:

1. El LLM genera contenido: asunto, cuerpo, selección de destinatario
2. Tu código valida: verifica el destinatario contra listas permitidas, escanea el contenido por violaciones de política, aplica rate limits
3. Sendkit envía: entrega el email y devuelve un estado estructurado

Este flujo de tres pasos mantiene al agente útil sin volverlo peligroso. El LLM nunca tiene credenciales de API directamente. Tu capa de aplicación es el guardián.

El patrón de tool/function calling

Los LLMs modernos soportan tool calling (OpenAI las llama "functions", Anthropic las llama "tools"). Defines una herramienta send_email con un esquema, y el modelo la invoca cuando decide que debe salir un email. Tu código intercepta esa llamada, la valida y ejecuta el envío real.

Esta es la definición de la herramienta que le darías a un LLM:

{
  "name": "send_email",
  "description": "Send an email to a recipient. Use this when the user needs to be notified via email or when a follow-up email is required.",
  "parameters": {
    "type": "object",
    "properties": {
      "to": { "type": "string", "description": "Recipient email address" },
      "subject": { "type": "string", "description": "Email subject line" },
      "html": { "type": "string", "description": "Email body as HTML" }
    },
    "required": ["to", "subject", "html"]
  }
}

El LLM nunca ve tu API key. Solo rellena to, subject y html. Tu código maneja el resto.

Node.js: herramienta de agente que envía email vía Sendkit

Instala el SDK:

npm install @sendkitdev/sdk

Define el handler de la herramienta:

import { Sendkit } from '@sendkitdev/sdk';

const sendkit = new Sendkit('sk_live_your_api_key');

const APPROVED_SENDERS = ['[email protected]', '[email protected]'];
const RATE_LIMIT = new Map(); // email -> timestamp[]

const handleSendEmailTool = async params => {
  const { to, subject, html } = params;
  const from = '[email protected]';

  // Validate sender
  if (!APPROVED_SENDERS.includes(from)) {
    return { error: 'Sender not in approved list' };
  }

  // Rate limit: max 5 emails per recipient per hour
  const now = Date.now();
  const history = RATE_LIMIT.get(to) || [];
  const recent = history.filter(ts => now - ts < 3600000);
  if (recent.length >= 5) {
    return { error: 'Rate limit exceeded for this recipient' };
  }

  // Send via Sendkit
  const { data, error } = await sendkit.emails.send({
    from,
    to,
    subject,
    html,
  });

  if (error) {
    return { error: error.message };
  }

  // Track for rate limiting
  recent.push(now);
  RATE_LIMIT.set(to, recent);

  return { success: true, messageId: data.id };
};

Conecta esto a tu loop del LLM. Cuando el modelo devuelve una llamada a herramienta con name: "send_email", parsea los argumentos y pásalos a handleSendEmailTool. Devuelve el resultado al modelo para que pueda confirmar la entrega al usuario.

Para una mirada más profunda al envío de email con Node.js, mira Cómo enviar email transaccional con Node.js.

Python: herramienta de agente que envía email vía Sendkit

Instala el SDK:

pip install sendkit

Define el handler de la herramienta:

from sendkit import Sendkit
from time import time

client = Sendkit("sk_live_your_api_key")

APPROVED_SENDERS = ["[email protected]", "[email protected]"]
rate_limit: dict[str, list[float]] = {}

def handle_send_email_tool(params: dict) -> dict:
    to = params["to"]
    subject = params["subject"]
    html = params["html"]
    from_ = "[email protected]"

    if from_ not in APPROVED_SENDERS:
        return {"error": "Sender not in approved list"}

    # Rate limit: max 5 emails per recipient per hour
    now = time()
    history = rate_limit.get(to, [])
    recent = [ts for ts in history if now - ts < 3600]
    if len(recent) >= 5:
        return {"error": "Rate limit exceeded for this recipient"}

    result = client.emails.send(
        from_=from_,
        to=to,
        subject=subject,
        html=html,
    )

    if result.error:
        return {"error": result.error.message}

    recent.append(now)
    rate_limit[to] = recent

    return {"success": True, "message_id": result.data.id}

Para más sobre envío de email con Python, mira Cómo enviar email con Python.

Valida destinatarios antes de enviar

Un agente de IA que envía a direcciones inválidas quema tu reputación como remitente. Antes de cada envío, valida el destinatario usando la API de validación de email de Sendkit:

const validateAndSend = async params => {
  const { to, subject, html } = params;

  // Validate recipient first
  const { data: validation } = await sendkit.emailValidations.validate({
    email: to,
  });

  if (validation.result === 'undeliverable') {
    return { error: `Invalid recipient: ${to}` };
  }

  if (validation.is_disposable) {
    return { error: 'Disposable email addresses are not allowed' };
  }

  // Proceed with send
  return handleSendEmailTool(params);
};

Esto atrapa errores tipográficos, buzones muertos y direcciones desechables antes de que lleguen a tu infraestructura de envío. Tu tasa de rebote se mantiene baja y la reputación de tu dominio se mantiene intacta. Lee más sobre esto en Cómo manejar rebotes de email.

Guardrails de seguridad

Darle a un LLM la capacidad de enviar email en tu nombre requiere guardrails serios. Esto es lo que debes implementar:

Listas de remitentes y destinatarios aprobados. Restringe la dirección from a remitentes verificados. Para agentes de alto riesgo, mantén también una lista permitida de dominios de destinatarios.

Rate limiting. Tanto por destinatario como global. Un agente atascado en un loop puede hacer spam en un buzón en segundos. Los ejemplos de código de arriba muestran límites por destinatario; añade también un contador global.

Revisión de contenido. Escanea los mensajes salientes en busca de datos sensibles (SSNs, números de tarjetas de crédito, URLs internas). Una pasada con regex atrapa los casos obvios. Para ambientes más estrictos, ejecuta una segunda llamada al LLM para auditar el contenido.

Human-in-the-loop. Para emails sensibles (avisos legales, divulgaciones financieras, cualquier cosa a una lista VIP) pon el email en cola para aprobación humana en lugar de enviarlo inmediatamente. El agente redacta, un humano aprueba, luego tu código envía.

Logging. Registra cada email que el agente envía, incluyendo el contexto completo del prompt que llevó al envío. Necesitas un rastro de auditoría.

Integración con webhooks

Enviar es la mitad del loop. Tu agente también necesita reaccionar a lo que pasa después de la entrega. Sendkit dispara webhooks para eventos de entrega, rebotes, aperturas, clics y quejas.

import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhooks/sendkit', (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'email.bounced':
      // Feed back to agent: this recipient is invalid
      // Update your allow-list or CRM
      break;
    case 'email.delivered':
      // Mark conversation as "email sent successfully"
      break;
    case 'email.complained':
      // Block future sends to this recipient
      // Alert your team
      break;
  }

  res.sendStatus(200);
});

Conecta los eventos de rebote de vuelta al contexto de tu agente. Si un destinatario rebota, el agente debería saber no reintentar esa dirección. Esto crea un feedback loop que hace al agente más inteligente con el tiempo.

Por qué una API le gana a SMTP para agentes

SMTP es un protocolo de conversación. Tu código abre un socket, negocia TLS, se autentica, envía MAIL FROM, RCPT TO, DATA, espera códigos de respuesta. Es frágil, lento y te da casi ningún feedback estructurado.

Una llamada a API es una sola request HTTP. Recibes JSON con un message ID, o un error estructurado con un código sobre el que puedes ramificar. Para un agente de IA que podría enviar docenas de emails en una sesión, la diferencia es masiva:

• Velocidad: un ida y vuelta HTTP vs un handshake SMTP multi-paso
• Manejo de errores: objetos de error tipados vs parsear códigos de respuesta SMTP
• Observabilidad: cada envío se registra con metadata, consultable vía API
• Sin gestión de conexiones: sin sockets persistentes, sin pooling, sin drama de timeouts

Si quieres una comparación detallada, lee SMTP vs Email API.

Juntando todo

El stack es directo: tu LLM genera contenido de email a través de tool calling, tu capa de aplicación valida y aplica rate limits, Sendkit maneja la entrega y te da feedback estructurado a través de webhooks. El agente se mantiene útil sin ser peligroso.

Empieza con la referencia de la API de Sendkit para obtener tus keys y verificar un dominio. Revisa los precios: el nivel gratuito es lo suficientemente generoso para construir y probar tu agente antes de escalar.

Los agentes que ganan son los que realmente pueden hacer cosas. Enviar email es una de las acciones más valiosas que puedes desbloquear.