Migrating from ElevenLabs to Naive

• Every voice lives behind a single xi-api-key, disconnected from wherever the agent’s email, cards, phone number, and KYC live.
• The key is coarse and self-attested: any code holding it can clone any voice and synthesize anything with it. The only “consent” is a checkbox in the cloning ToS — there is no record of who consented, and nothing enforces that a voice cloned for one purpose isn’t used for another.
• “Which agent cloned that voice, who consented, and what else can this agent do?” is answered in the ElevenLabs dashboard for voices, and in unrelated systems for everything else. The voice has no shared accountability with the rest of the agent’s footprint.

• Every voice carries a consent record (who consented, the affirmation, and the authorized_uses), and synthesis is refused if the requested use falls outside that set — a voice cloned for email will not narrate a video.
• Cloning and revoking a voice are human-only — they require a signed-in session, not just an agent API key — so a leaked agent key can synthesize with voices it already owns but can never mint or destroy one.
• The tenant user whose Account Kit enables voice is the same user that owns the agent’s email inboxes, its cards, its phone number, and its vault — one identity, one audit trail, revocable in one place.

​

Concept map

​

Before / after: the core path

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import fs from "node:fs";

// One xi-api-key clones AND synthesizes — no consent record, no per-use limit
const elevenlabs = new ElevenLabsClient({ apiKey: process.env.ELEVENLABS_API_KEY });

// Clone: a ToS checkbox is the only "consent"; any code with the key can do this
const voice = await elevenlabs.voices.ivc.create({
  name: "Founder VO",
  files: [fs.createReadStream("./sample.wav")],
});

// Synthesize — nothing enforces what this voice may be used for
const audio = await elevenlabs.textToSpeech.convert(voice.voiceId, {
  text: "Thanks for booking with us.",
  modelId: "eleven_multilingual_v2",
  outputFormat: "mp3_44100_128",
});
// → the voice is a slice of your ElevenLabs account behind one key. No consent
//   record, no per-use enforcement, no shared identity with email/cards/phone.

# Clone is HUMAN-ONLY: establish a signed-in session first (not just an API key)
naive auth session-login

# Clone with an explicit consent record + the uses this voice is allowed for
naive voice clone \
  --file ./sample.wav \
  --name "Founder VO" \
  --consent-type self \
  --authorized-uses email \
  --i-affirm \
  --wait
# → returns a voice id; the consent record (who, affirmation, authorized_uses) is stored

# Synthesize with an agent API key — `use` MUST be within the voice's authorized_uses
naive voice say --voice <voice-id> --text "Thanks for booking with us." --out hello.mp3
# → the SAME identity also owns this agent's email inbox, card, phone, and vault.

• Cloning is human-only, not an agent-key action. ElevenLabs clones with the same key it synthesizes with. Naive requires a signed-in human session (naive auth session-login) to clone or revoke, so a leaked agent key can use voices it already owns but can never mint or destroy one.
• Every voice carries a consent record. ElevenLabs’ “consent” is a ToS checkbox. Naive stores consent_type, the affirmation, and — for third parties — a verified consenter, and marks it revoked on revoke.
• Uses are enforced at synthesis. A Naive voice cloned with --authorized-uses email will refuse a video use. On ElevenLabs the key can synthesize anything.
• The id is your identity, not a separate account. The same tenant user that owns this voice owns the agent’s email, cards, phone, and vault.

​

Consent + authorized uses: the execution-time gate

// The key can synthesize this voice for ANY purpose — there is nothing to enforce.
await elevenlabs.textToSpeech.convert(voice.voiceId, { text: "Buy now!", modelId: "eleven_multilingual_v2" });
await elevenlabs.textToSpeech.convert(voice.voiceId, { text: "Legal disclaimer…" });

// Deleting a voice uses the same key as everyday synthesis — no separation of duty.
await elevenlabs.voices.delete(voice.voiceId);

# Cloned with `--authorized-uses email` only:
naive voice say --voice <voice-id> --text "Thanks for booking." --out ok.mp3   # use=email → allowed

const res = await fetch("https://api.usenaive.ai/v1/voice/synthesize", {
  method: "POST",
  headers: { Authorization: "Bearer nv_sk_your_key", "Content-Type": "application/json" },
  body: JSON.stringify({ voice_id: "voice-uuid", text: "Thanks for booking.", use: "email" }),
});
const { url, credits, char_count } = await res.json();
// A `use` outside the voice's authorized_uses is refused; a revoked voice returns `voice_revoked`.

• authorized_uses is enforced server-side. Clone once with the uses a voice is allowed for (email, video, …); synthesis outside that set is rejected — you don’t police it in app code.
• Revocation is irreversible and enforced. naive voice revoke erases the voice and its audio and marks consent revoked; every later synthesis returns voice_revoked.
• Clone/revoke need a human. They record a legal consent affirmation, so they require a signed-in session — the agent key alone cannot perform them.

​

Minimal viable migration

npm install -g @usenaive-sdk/cli   # or use the REST API directly

​

Consolidate further once you’re on Naive

// One xi-api-key scopes ElevenLabs — and only ElevenLabs — for every customer.
// The card, the inbox, the phone number, and the KYC for this customer's agent
// live in entirely separate systems with their own keys and dashboards.
const voice = await elevenlabs.voices.ivc.create({ name: `${customer.id}-vo`, files: [/*…*/] });
await elevenlabs.textToSpeech.convert(voice.voiceId, { text: "…" });

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

const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });

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

// The SAME client owns this customer's email inbox, card, phone, and vault —
// and its Account Kit is what enables `voice` at all. Tear the customer down
// from one place and the voice, card, inbox, and number all go with it.
await client.email.createInbox({ local_part: "agent" });
await client.cards.create({ spending_limit_cents: 25_000 });

​

Gain #1 — one identity across primitives

• With ElevenLabs, an agent’s voices are a slice of one account, and per-customer separation is a naming convention you maintain yourself. With Naive, naive.forUser(acme.id) is a single handle to the identity whose Account Kit governs voice and email and cards and phone and vault.
• The digital-twin video an agent generates auto-ingests into that identity’s Media Manager — the same place its other assets live — not a separate vendor’s file store.

​

Gain #2 — execution-time governance

• Whether an agent may use voice at all is policy on the identity — toggled per user in the Account Kit — and synthesis is metered against the tenant’s plan quota. This is on top of the per-voice authorized_uses gate that ElevenLabs has no equivalent for.

// A tier that grants voice, gated + metered on the identity — no card for this tier.
const creator = await naive.accountKits.create({
  name: "Creator",
  primitives_config: {
    voice: { enabled: true },
    cards: { enabled: false },
  },
});
await naive.accountKits.assignUser(creator.id, acme.id);

// The plan carries the per-primitive quota that meters usage at execution time.
await naive.plans.upsert({
  key: "creator",
  name: "Creator",
  accountKitId: creator.id,
  period: "month",
  quotas: { voice: 500 },
});
await naive.forUser(acme.id).billing.setSubscription({ planKey: "creator" });

• The agent’s synthesis code path stays the same for every tier. What changes at execution time:
  • Disabled primitive → the call is refused. If the Account Kit doesn’t grant voice, synthesis never runs.
  • Use outside authorized_uses → refused. A voice cloned for email can’t be used for video, regardless of tier.
  • Quota exceeded → capped. Once usage crosses the plan’s voice quota for the period, further synthesis is rejected — no surprise bill from a runaway agent.
  • Clone/revoke need a human session. A leaked agent key can synthesize with owned voices but can never mint or destroy one.

​

Gain #3 — unified accountability

• Every clone, synthesis, and revoke for a customer lands in one per-user activity log — alongside their email, card, phone, and vault events, not in a separate vendor dashboard:

const { events } = await naive.forUser(acme.id).logs.query({ limit: 50 });
// "which voice did this agent synthesize, for what use, and who consented?" — one timeline

• That is the question that is hard to answer when voices live in ElevenLabs, cards live in Stripe, the phone number lives in a carrier console, and email lives somewhere else. Under Naive it is a single query.

​

What does not map yet

​

Where to go next

• voice primitive — clone (human-only), synthesize, list, revoke, consent model, digital-twin video
• Authentication — the human session that clone/revoke require
• Media Manager — where generated talking-twin videos are auto-ingested
• Customer billing — the plan + quota that meters synthesis at execution time
• Account Kits — the policy model that enables/disables voice per user
• Tenant users — the identity that owns the voice, email, cards, phone, and vault