Outbound GTM / SDR AI agent

npx eve@latest init sdr-agent --model anthropic/claude-sonnet-5
cd sdr-agent
npm install agentmail svix
export AGENTMAIL_API_KEY="..."

import { AgentMailClient } from "agentmail";

export const agentmail = new AgentMailClient(); // reads AGENTMAIL_API_KEY
export const INBOX = process.env.SDR_INBOX!; // set after part 2, e.g. [email protected]

import { DatabaseSync } from "node:sqlite";

export const db = new DatabaseSync("pipeline.db");
db.exec(`CREATE TABLE IF NOT EXISTS leads (
    email TEXT PRIMARY KEY,
    name TEXT, company TEXT, notes TEXT,
    state TEXT DEFAULT 'new',   -- new, contacted, replied, handed_off, closed, suppressed
    thread_id TEXT,
    followup_draft_id TEXT,
    touches INTEGER DEFAULT 0,
    contacted_at TEXT
)`);

import { defineTool } from "eve/tools";
import { z } from "zod";

export default defineTool({
  description:
    "Research a prospect before drafting. Fetches their website and searches recent news. " +
    "Returns raw findings; only claims backed by these findings may appear in the email.",
  inputSchema: z.object({ company: z.string(), domain: z.string() }),
  async execute({ company, domain }) {
    const site = await fetch(`https://${domain}`)
      .then((r) => r.text())
      .catch(() => "");
    const news = await fetch("https://api.exa.ai/search", {
      method: "POST",
      headers: { "Content-Type": "application/json", "X-API-Key": process.env.EXA_API_KEY! },
      body: JSON.stringify({
        query: `${company} funding hiring product launch`,
        numResults: 5,
        contents: { text: { maxCharacters: 1500 } },
      }),
    }).then((r) => r.json());
    return { site: site.slice(0, 5000), news: news.results };
  },
});

const inbox = await agentmail.inboxes.create({
  username: "mara",
  domain: "tryacme.com",
  displayName: "Mara Ellison",
});
console.log(inbox.email); // [email protected]

You are Mara, an SDR for Acme. Work through leads with get_next_leads.

For each lead: call research_prospect first. Write a plain-text email under
120 words with one reason to reply. Every claim about the prospect must come
from the research findings. If the research has nothing useful, mark the lead
closed with update_lead and move on. Close with a low-pressure question, not
a calendar link.

Send with send_first_touch, then schedule the follow-up with
schedule_followup. Never contact a lead in state suppressed or closed, and
never send more than 3 emails to one person.

import { defineTool } from "eve/tools";
import { always } from "eve/tools/approval";
import { z } from "zod";
import { agentmail, INBOX } from "../lib/agentmail";
import { db } from "../lib/leads";

const DAILY_CAP = 25; // deliverability ceiling for one warmed inbox

export default defineTool({
  description: "Send the first outreach email to a prospect. Refuses past the daily cap.",
  inputSchema: z.object({ to: z.string(), subject: z.string(), text: z.string() }),
  approval: always(), // a person reviews every send. Relax per category later
  async execute({ to, subject, text }) {
    const today = db.prepare(
      "SELECT COUNT(*) AS n FROM leads WHERE date(contacted_at) = date('now')",
    ).get() as { n: number };
    if (today.n >= DAILY_CAP) return { sent: false, reason: "daily cap reached" };

    const sent = await agentmail.inboxes.messages.send(
      INBOX,
      { to: [to], subject, text },
      { headers: { "Idempotency-Key": `first-${to}` } },
    );
    db.prepare(
      "UPDATE leads SET state='contacted', thread_id=?, touches=touches+1, contacted_at=datetime('now') WHERE email=?",
    ).run(sent.threadId, to);
    return { sent: true, messageId: sent.messageId, threadId: sent.threadId };
  },
});

import { defineTool } from "eve/tools";
import { z } from "zod";
import { agentmail, INBOX } from "../lib/agentmail";
import { db } from "../lib/leads";

export default defineTool({
  description: "Schedule a follow-up 4 days out, threaded under the first touch.",
  inputSchema: z.object({ email: z.string(), messageId: z.string(), text: z.string() }),
  async execute({ email, messageId, text }) {
    const draft = await agentmail.inboxes.drafts.create(INBOX, {
      inReplyTo: messageId,
      text,
      sendAt: new Date(Date.now() + 4 * 86_400_000).toISOString(),
    });
    db.prepare("UPDATE leads SET followup_draft_id=? WHERE email=?").run(draft.draftId, email);
    return { draftId: draft.draftId };
  },
});

const webhook = await agentmail.webhooks.create({
  url: "https://sdr-agent.example.com/webhooks/agentmail",
  eventTypes: ["message.received", "message.bounced", "message.complained"],
  inboxIds: [INBOX],
  clientId: "sdr-agent-v1",
});

import { defineChannel, POST } from "eve/channels";
import { Webhook } from "svix";
import { suppress, claim } from "../lib/leads";

const verifier = new Webhook(process.env.AGENTMAIL_WEBHOOK_SECRET!);

export default defineChannel({
  turnPolicy: "queue",
  routes: [
    POST("/webhooks/agentmail", async (request, { from }) => {
      const payload = await request.text();
      let event: any;
      try {
        event = verifier.verify(payload, {
          "svix-id": request.headers.get("svix-id") ?? "",
          "svix-timestamp": request.headers.get("svix-timestamp") ?? "",
          "svix-signature": request.headers.get("svix-signature") ?? "",
        });
      } catch {
        return new Response(null, { status: 400 });
      }

      const message = event.message;
      if (!claim(message.message_id)) return new Response(null, { status: 200 });

      if (event.event_type !== "message.received") {
        // suppress() also cancels the lead's pending follow-up draft
        suppress(message.to[0]);
        return new Response(null, { status: 200 });
      }

      await from(message.thread_id).send(
        `New reply from ${message.from} in thread ${message.thread_id}. ` +
          `Classify it with the classifier subagent, then act per the playbook.`,
        { auth: null },
      );
      return new Response(null, { status: 200 });
    }),
  ],
});

import { defineAgent } from "eve";

export default defineAgent({
  description: "Classifies one inbound reply to a cold email.",
  model: "anthropic/claude-haiku-4.5",
});

Classify the reply into one of: interested, question, not_now, not_interested,
out_of_office, referral, unsubscribe, auto_reply. Return JSON:
{category, summary (one line), return_date (out_of_office only),
referred_contact (referral only)}.

"Interesting, but ask me next quarter" is not_now. "Take me off your list" is
unsubscribe even without the word unsubscribe. Read only what the prospect
wrote, not the quoted history.

When a reply comes in: cancel the pending follow-up with cancel_followup,
fetch the message, and pass its extracted_text to the classifier.

- interested: send a short acknowledgment with reply_in_thread (under five
  sentences, first line reacting to what they said, propose two concrete
  times, calendar link as fallback, no pitching). Then forward_to_human with
  the research notes and this ask: "Reply to this, or CC yourself into the
  thread and take it from here." Label the thread handed-off.
- unsubscribe or not_interested: block_sender, mark the lead suppressed.
- out_of_office: reschedule the follow-up for after the return date.
- auto_reply: do nothing.
- anything else (question, not_now, referral): forward_to_human with the
  classifier's summary.

Never reply in a thread labeled handed-off. Never reply to a message whose
Auto-Submitted header is set.