Como deixar agentes de IA enviarem e-mail

Agentes de IA que não conseguem enviar e-mail estão pela metade. Eles conseguem raciocinar, pesquisar, resumir e planejar — mas no momento em que precisam notificar um cliente, dar follow-up num lead ou confirmar um compromisso, batem numa parede. E-mail ainda é o canal de comunicação padrão para negócios, e seus agentes precisam de acesso direto a ele.

Este guia mostra como conectar agentes de IA para enviarem e-mail pela API do Sendkit, com código funcional em Node.js e Python, guardrails de segurança e integração com webhooks para workflows de ciclo fechado.

Por que agentes de IA precisam de e-mail

Os casos de uso estão em todo lugar quando você olha:

• Agentes de suporte ao cliente resolvem um ticket e mandam um resumo pro cliente. Nenhum humano copia e cola um template.
• Agentes de vendas qualificam leads de entrada e mandam follow-ups personalizados segundos depois do envio do formulário.
• Agentes de agendamento negociam horários de reunião por e-mail, mandando confirmações e convites de calendário automaticamente.
• Agentes de notificação monitoram sistemas e avisam os stakeholders quando algo quebra, com contexto que o LLM montou a partir dos logs.

Em cada caso, o agente gera o conteúdo. Seu código valida. O Sendkit entrega. Essa separação importa.

A arquitetura

Nunca deixe um LLM chamar uma API de e-mail diretamente sem supervisão. O padrão que funciona:

1. LLM gera conteúdo — assunto, corpo, seleção do destinatário
2. Seu código valida — checa o destinatário contra allow-lists, escaneia o conteúdo em busca de violações de política, aplica rate limits
3. Sendkit envia — entrega o e-mail e retorna status estruturado

Esse fluxo de três etapas mantém o agente útil sem deixá-lo perigoso. O LLM nunca segura credenciais da API diretamente. A sua camada de aplicação é a guardiã.

O padrão de tool/function calling

LLMs modernos suportam tool calling (a OpenAI chama de "functions", a Anthropic chama de "tools"). Você define uma tool send_email com um schema e o modelo a invoca quando decide que um e-mail deve sair. Seu código intercepta essa chamada, valida e executa o envio de verdade.

Aqui está a definição de tool que você passaria pra um 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"]
  }
}

O LLM nunca vê sua chave de API. Ele só preenche to, subject e html. Seu código cuida do resto.

Node.js: tool de agente que envia e-mail via Sendkit

Instale o SDK:

npm install @sendkitdev/sdk

Defina o handler da tool:

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 };
};

Conecte isso no seu loop do LLM. Quando o modelo retornar uma tool call com name: "send_email", parseie os argumentos e passe pro handleSendEmailTool. Devolva o resultado pro modelo pra ele poder confirmar a entrega pro usuário.

Para um mergulho mais profundo em envio de e-mail com Node.js, veja Como enviar e-mail transacional com Node.js.

Python: tool de agente que envia e-mail via Sendkit

Instale o SDK:

pip install sendkit

Defina o handler da tool:

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 mais sobre envio de e-mail com Python, veja Como enviar e-mail com Python.

Valide destinatários antes de enviar

Um agente de IA que envia pra endereços inválidos queima sua reputação de remetente. Antes de cada envio, valide o destinatário usando a API de validação de e-mail do 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);
};

Isso pega erros de digitação, caixas mortas e endereços descartáveis antes que eles cheguem na sua infraestrutura de envio. Sua taxa de bounce fica baixa e a reputação do seu domínio fica intacta. Leia mais sobre isso em Como lidar com bounces de e-mail.

Guardrails de segurança

Dar a um LLM a capacidade de enviar e-mail em seu nome exige guardrails sérios. Aqui está o que implementar:

Listas de remetentes e destinatários aprovados. Restrinja o endereço from a remetentes verificados. Para agentes de alto risco, mantenha também uma allow-list de domínios de destinatários.

Rate limiting. Tanto por destinatário quanto global. Um agente preso em loop consegue spammar uma caixa em segundos. Os exemplos de código acima mostram limites por destinatário — adicione também um contador global.

Revisão de conteúdo. Escaneie mensagens de saída em busca de dados sensíveis (CPFs, números de cartão de crédito, URLs internas). Um regex pega os casos óbvios. Para ambientes mais rígidos, faça uma segunda chamada de LLM pra auditar o conteúdo.

Humano no loop. Para e-mails sensíveis — notificações jurídicas, divulgações financeiras, qualquer coisa pra uma lista VIP — coloque o e-mail numa fila pra aprovação humana em vez de enviar imediatamente. O agente rascunha, um humano aprova e então seu código envia.

Logging. Logue cada e-mail que o agente envia, incluindo o contexto completo do prompt que levou ao envio. Você precisa de uma trilha de auditoria.

Integração com webhooks

Enviar é metade do loop. Seu agente também precisa reagir ao que acontece depois da entrega. O Sendkit dispara webhooks para eventos de entrega, bounces, aberturas, cliques e reclamações.

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);
});

Alimente eventos de bounce de volta no contexto do seu agente. Se um destinatário dá bounce, o agente deve saber pra não tentar aquele endereço de novo. Isso cria um feedback loop que deixa o agente mais inteligente com o tempo.

Por que API vence SMTP para agentes

SMTP é um protocolo de conversa. Seu código abre um socket, negocia TLS, autentica, manda MAIL FROM, RCPT TO, DATA, espera por códigos de resposta. É frágil, lento e te dá quase nenhum feedback estruturado.

Uma chamada de API é uma única requisição HTTP. Você recebe de volta um JSON com um ID de mensagem, ou um erro estruturado com um código em que você pode ramificar. Para um agente de IA que pode enviar dezenas de e-mails em uma sessão, a diferença é enorme:

• Velocidade — uma ida e volta HTTP vs. um handshake SMTP em múltiplos passos
• Tratamento de erro — objetos de erro tipados vs. parsear códigos de resposta SMTP
• Observabilidade — cada envio é logado com metadados, consultável via API
• Sem gerenciamento de conexão — sem sockets persistentes, sem pooling, sem drama de timeout

Se você quer uma comparação detalhada, leia SMTP vs Email API.

Juntando tudo

A stack é direta: seu LLM gera o conteúdo do e-mail via tool calling, sua camada de aplicação valida e aplica rate limits, o Sendkit cuida da entrega e te dá feedback estruturado via webhooks. O agente segue útil sem ser perigoso.

Comece pela referência da API do Sendkit pra pegar suas chaves e verificar um domínio. Confira o pricing — o tier gratuito é generoso o bastante pra construir e testar seu agente antes de escalar.

Os agentes que ganham são os que conseguem de fato fazer coisas. Enviar e-mail é uma das ações mais valiosas que você pode desbloquear.