Migrating from AgentMail to Naive

• Inboxes live behind their own API key, dashboard, and inbox_id namespace.
• That account scopes email and nothing else — it knows the agent’s inboxes and threads, but not its virtual card, its vault secrets, its connected apps, or its KYC status.
• “Who let this agent email a customer, and what else can it touch?” is answered in AgentMail for mail, and somewhere else for everything else. There is no shared accountability.

• The tenant user that owns the inbox is the same user that owns its cards, its vault secrets, its connections, and its KYC.
• Whether the agent may send mail at all — and whether a send freezes for human approval — is decided by that user’s Account Kit at execution time.
• Every inbox, send, and inbound reply lands in the same per-user activity log as everything else the agent does.

​

Concept map

​

Before / after: the core path

import { AgentMailClient } from "agentmail";

const client = new AgentMailClient({ apiKey: process.env.AGENTMAIL_API_KEY! });

// 1. Create an inbox (clientId makes the create idempotent)
const inbox = await client.inboxes.create({
  username: "outreach",
  clientId: "acme-outreach-v1",
});
// → inbox.inboxId, e.g. "outreach@agentmail.to"

// 2. Send a message from it
const sent = await client.inboxes.messages.send(inbox.inboxId, {
  to: "prospect@company.com",
  subject: "Research findings",
  text: "Hi Sarah, here are the results...",
  html: "<p>Hi Sarah, here are the results...</p>",
});
// → sent.messageId, sent.threadId

import { Naive } from "@usenaive-sdk/server";

const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });
const client = naive.forUser("acme"); // same id space as your own users

// 1. Create an inbox on your auto-provisioned (or custom) domain
const inbox = await client.email.createInbox({ local_part: "outreach" });
// → inbox.id (UUID) and inbox.address, e.g. "outreach@acme.usenaive.ai"

// 2. Send a message from it (one body — HTML auto-detected)
const sent = await client.email.send({
  from_inbox: inbox.id,
  to: "prospect@company.com",
  subject: "Research findings",
  body: "<p>Hi Sarah, here are the results...</p>",
});
// → sent.id, sent.status, sent.credits_used, sent.credits_remaining

• One body, not two. AgentMail takes text and html. Naive takes a single body and sends it as HTML when it contains tags, otherwise plain text.
• Inbox id is a UUID (or the address). AgentMail uses the address itself as inbox_id. Naive returns a UUID id plus the address; from_inbox accepts either.
• The id is your identity, not a separate account. In AgentMail the API key scopes email. In Naive the same forUser(id) handle also owns the agent’s cards, vault, connections, and KYC.

​

Receiving replies

// Poll
const res = await client.inboxes.messages.list(inbox.inboxId, { limit: 20 });
for (const m of res.messages) {
  const body = m.extractedText ?? m.text; // quoted history stripped
}

// Or react to the webhook event: "message.received"

// Poll
const { emails } = await client.email.inbox({ inboxId: inbox.id, limit: 20 });
for (const m of emails) {
  console.log(m.from, m.subject, m.snippet);
  const full = await client.email.getEmail(m.id); // full body
}

// Or subscribe to the inbound event once, per company or per tenant:
const sub = await naive.webhooks.create(
  "https://app.example.com/api/webhooks/naive",
  ["email.received"],
);
// store sub.secret — verify with verifyWebhookSignature()

• On Naive, an inbound delivery fires a signed, retried email.received webhook. When present, data.tenant_user_id identifies which tenant user the reply belongs to (company-wide subscriptions may omit it — see Webhooks).
• Naive returns a snippet in the list and the full body via getEmail — there is no separate quoted-history-stripped field (see gaps).

​

Minimal viable migration

npm install @usenaive-sdk/server

​

Consolidate further once you’re on Naive

// One pod (or API key) per customer; isolates inboxes, and only those.
const inbox = await client.inboxes.create({ username: "acme-outreach" });
await client.inboxes.messages.send(inbox.inboxId, { to, subject, text });

// The card, the vault secrets, the connected apps, the KYC for this customer's
// agent live in entirely separate systems with their own tenancy.

// One tenant user per customer; isolates *every* primitive.
const acme = await naive.users.create({
  external_id: dbCustomer.id,
  email: dbCustomer.email,
});

const client = naive.forUser(acme.id);

const inbox = await client.email.createInbox({ local_part: "outreach" });
await client.email.send({ from_inbox: inbox.id, to, subject, body });

// The SAME client owns this customer's card, vault, connections, and KYC —
// one identity, isolated end to end.
await client.cards.create({ spending_limit_cents: 25_000 });
await client.vault.put("internal.api_key", "key_xyz");

​

Gain #1 — one identity across primitives

• With AgentMail, the agent’s inboxes are an island. With Naive, naive.forUser(acme.id) is a single handle to email and cards and vault and connections and KYC.
• You provision a customer’s whole agent footprint from one identity, and tear it down from one place. Sibling tenants can never read each other’s inboxes, cards, or secrets.

​

Gain #2 — execution-time permission enforcement

• Whether an agent may send mail — and whether a send freezes for human review — is policy on the Account Kit, not a check you hand-write and not a separate draft-review service.

const starter = await naive.accountKits.create({
  name: "Starter",
  primitives_config: {
    email: { enabled: true, requiresApproval: true }, // every send freezes for approval
    cards: { enabled: false },                          // no card for this tier
  },
});
await naive.accountKits.assignUser(starter.id, acme.id);

• The agent’s code is identical for every tier — client.email.send({ ... }). Whether the call runs is decided by the caller’s kit at execution time:
  • primitives_config.email.enabled: false makes the exact same line return forbidden, with no code change on your side.
  • requiresApproval: true freezes the send until a human approves — the API replays it only after approval. This is Naive’s answer to AgentMail’s human-in-the-loop drafts: the review gate is policy, applied to the live call, not a separate object you build a UI around.

​

Gain #3 — unified accountability

• Every inbox, send, and inbound reply for a customer lands in one per-user activity log — alongside their card, vault, and connection events, not in a separate mail dashboard:

const { events } = await naive.forUser(acme.id).logs.query({ limit: 50 });
// "what did this agent do, for whom?" — email, cards, vault, connections, one timeline

• That is the question that is hard to answer when mail lives in AgentMail, cards live in Stripe, and secrets live somewhere else. Under Naive it is a single query.

​

What does not map yet

​

Where to go next

• email primitive — full inbox/send/receive lifecycle
• Email API reference — exact request/response shapes
• email SDK sub-client — typed method signatures
• Webhooks — the email.received event that makes inbound autonomous
• Account Kits and Approvals — the policy model that makes execution-time send governance and human-in-the-loop real
• Tenant users — the identity that the consolidation hangs off