DEV Community: FaceMode

Interactive Avatar APIs Compared: 10 Options (2026)

prajwaldkadam — Sun, 18 Oct 2026 00:00:00 +0000

Ten APIs now sell the same promise: send speech, get a live talking face. They differ on who owns the media room, which stacks they attach to, what "latency" each vendor actually measures, and what a streamed minute really costs. This page compares all ten on those four axes.

Every vendor in this market has published a comparison, and every one of those comparisons ranks its publisher first: HeyGen's seven-platform scoring puts HeyGen #1, Beyond Presence's benchmark puts Genesis #1, D-ID's SyncNet table puts D-ID #1 on lip-sync, and Anam's latency benchmark puts Anam fastest. This post takes a different approach. It is documentation-based, every cell links to the vendor's own current page, and it is written by FaceMode - one of the products in the table, disclosed rather than hidden.

Sources were checked on October 18, 2026. Pricing and access rules change often in this category; confirm in your account before budgeting.

Three ways to put a face on a voice agent

"Interactive avatar API" covers three different products, and most bad purchases come from comparing across the boundary.

Avatar layer on your own transport. You create and own the LiveKit or Daily room; the vendor joins as a participant and publishes video. Your STT, LLM, TTS, and turn detection stay untouched. FaceMode and Synthesia's Interactive Avatar API both document this model, and Beyond Presence's speech-to-video describes the same division.

Avatar layer on the vendor's transport. You still bring the conversation logic, but the session runs on vendor infrastructure - their WebRTC, their participant, their metering. Simli (built on Daily), LemonSlice (widget, hosted, or self-managed pipelines), and Runway Characters (WebRTC sessions) fit here.

End-to-end conversational platform. The vendor supplies the whole call: speech recognition, LLM wiring, voice, turn-taking, and the face. Tavus's Conversational Video Interface, HeyGen LiveAvatar's FULL mode, and D-ID Agents are built this way. Several of them also expose a render-only path for your own stack - HeyGen's LITE mode, Tavus's LiveKit plugin, Anam's LiveKit/Pipecat integrations - so the boundary is a dial, not a wall.

The first question to answer is which of the three you are actually shopping for. A full platform is the fastest demo and the deepest lock-in; a render-only layer is the least code on day one only if your agent already exists.

Interactive avatar APIs: the comparison table

Cells link to the vendor's own documentation or pricing where we verified it. "Not published" means we did not find a public figure in reviewed sources - it is not a zero or a criticism.

Vendor	Architecture	Integration surface	Published latency (boundary)	Pricing model	Free tier
Anam	Avatar layer + hosted pipeline	LiveKit + Pipecat plugins, JS SDK, embed widget	180ms median server-side; sub-1s end-to-end claim (interactive avatars); own public TTFF benchmark: 1.55s median	Subscription $12-$999/mo with minute pools + $0.11-0.16/min overage; enterprise floor $0.04/min	30 min/mo (watermark, 3-min sessions)
Beyond Presence	Avatar layer + managed agents	LiveKit + Pipecat, n8n webhooks	Sub-100ms model inference; sub-250ms global (vendor claims on homepage)	Headline: "rates fall to EUR 0.03/min at scale"; full schedule not published in reviewed pages	Not published in reviewed pages
D-ID	End-to-end agents + video API	LiveKit plugin, client SDK	Sub-500ms conversational, sub-120ms model (V4 tech specs)	Subscription minutes shared across studio and API	Trial with watermark
FaceMode	Avatar layer on your LiveKit or Daily room	LiveKit Python + TypeScript plugins, Pipecat plugin, REST + WebSocket	~960ms audio-to-rendered-frame target (product summary)	Credits: 1 credit = 1s of streamed video; paid top-ups open at GA	60 minutes in beta, no card
HeyGen LiveAvatar	FULL hosted pipeline + LITE bring-your-own	LiveKit, Pipecat, Agora, VisionAgent; `openai_agent` BYO-key mode	Not published	Credits: Essential $99/mo for 1,100 credits; 1 credit = 30s FULL / 60s LITE (about $0.16-0.18/min FULL); overage $0.10/credit	10 credits/mo (1 session, 2-min sessions, watermark)
LemonSlice	Avatar layer: widget / hosted / self-managed	LiveKit plugin, REST, WebSocket, Agora; Python/Node/Pipecat examples	471ms p99 (homepage claim; response latency during a call, not startup)	Subscription $8-$960/mo with minute pools + $0.22/min overage (Starter); CWM-1 Lite "as low as $0.048/min" on Ultra+; hosted pipeline +$0.09/min	Free on-site avatar chat; API needs a paid plan
Runway	Characters API (GWM-1), hosted sessions	WebRTC API, LiveKit plugin, React SDK, ElevenLabs Agents	No comparable figure on current docs	`gwm1_avatars`: 2 credits upfront + 2 credits per 6s = $0.20/min at $0.01/credit (dev pricing); 5-min max sessions	125 one-time developer credits
Simli	Avatar layer on Daily infra	LiveKit + Pipecat plugins, WebRTC	Sub-300ms speech-to-video (homepage claim)	$10 credit on signup + 50 min/mo top-up; paid plans with volume discounts	Yes, as described
Synthesia	BYO-stack avatar layer on LiveKit	Python `livekit-plugins-synthesia`, REST; Pipecat marked coming soon	No comparable audio-to-frame figure	Product page $0.12/min; operational docs $0.10/min - public conflict	500 free minutes
Tavus	End-to-end CVI platform	LiveKit plugin (Python + Node)	No comparable round-trip figure	Free 25 min/mo; $59/$397 subscriptions + $0.37/$0.32 per-min overage; 30s minimum charge	25 min/mo, 1 concurrent stream

Read the table as a map, not a ranking. The columns are deliberately different units - transport, latency boundary, billing shape - because those are the dimensions where a wrong assumption costs you a rewrite.

How to read the latency numbers

Every vendor publishes a number, and almost none of them measure the same interval.

Model inference isolates the avatar model's compute time. Beyond Presence's sub-100ms and D-ID's sub-120ms are measured here - before network, before transport, before your room.
Server-side / speech-to-video measures one stage of the pipeline. Anam's 180ms median and Simli's sub-300ms are this type: from received audio to generated response inside the vendor's system.
Conversational or turn latency covers the wider gap between the user finishing a sentence and the avatar's reply starting. D-ID's sub-500ms and Anam's sub-1s end-to-end claim live here, and both still exclude parts of your own stack.
Audio-to-rendered-frame is the boundary FaceMode publishes: approximately 960ms from audio input to a rendered frame. It counts the avatar layer's work, not your STT, LLM, TTS, or the user's perceived end-to-end wait.
Time to first frame (TTFF) is startup, not response speed. Anam runs the category's only public cross-vendor benchmark: 80 raters, 1,280 live conversations, measured July 31, 2026, with a published caveat that products change continuously. It measured Anam at 1.55s median TTFF, HeyGen at 4.7s, Tavus at 5.7s, and LemonSlice at 9.4s - and that is connection setup time, unrelated to LemonSlice's separate 471ms p99 mid-call claim. Both can be accurate; they describe different intervals.

The practical consequence: an "under 100ms" badge and a "960ms" target can coexist on honest pages because they time different things. When you evaluate, instrument at least three points - session startup, response onset, and interruption recovery - under the same region, voice model, and utterance. Our Synthesia comparison walks through that measurement checklist in more detail.

If you run on LiveKit, there is now a standardized hook: the virtual avatar docs describe AvatarMetrics emitted by every avatar plugin through the session's metrics_collected event, reporting join latency (session start to the avatar participant publishing video) and playback latency (first audio frame forwarded to playback starting on the avatar). That gives you a comparable number across LiveKit plugins without trusting any vendor's marketing page.

Your frontend also has to tell the agent apart from the avatar worker. LiveKit's docs mark the worker as a participant of kind agent carrying an lk.publish_on_behalf attribute; in React, useVoiceAssistant resolves the correct tracks:

const {
  agent, // The agent participant
  audioTrack, // the worker's audio track
  videoTrack, // the worker's video track
} = useVoiceAssistant();

What a minute of avatar actually costs

Headline prices in this category span an order of magnitude - roughly $0.03-0.05/min at volume commitments to $0.20/min pay-as-you-go and $0.37/min on overage - but the number only means something next to its billing shape.

Subscription plus minute pool. Anam ($12-$999/mo + $0.11-0.16/min overage), LemonSlice ($8-$960/mo + $0.22/min overage on Starter), HeyGen ($99-$475/mo credit packs), and Tavus ($59-$397/mo + $0.32-0.37/min overage) all work this way. The effective per-minute rate depends on how much of the pool you consume; unused minutes mostly do not roll over.

Metered credits or per-minute. Synthesia publishes $0.10-0.12/min (two public pages disagree, which we flagged in our Synthesia vs FaceMode post). Runway bills gwm1_avatars at 2 credits per 6 seconds - $0.20/min at its $0.01 credit. FaceMode bills 1 credit per second of streamed video; during beta, 3,600 credits (60 minutes) are free and paid top-ups are not yet open, so there is no published paid rate to compare.

The gotchas that change the bill:

Concurrency caps. Anam ranges 1-10 sessions by tier, LemonSlice 3-100+, Tavus 1-10, Synthesia 1 on free vs 100 on paid; HeyGen advertises unlimited on paid plans. A 24/7 kiosk and a 50-user support line price very differently.
Session duration limits. Runway caps sessions at 5 minutes per current docs, Anam at 3 minutes to 2 hours by tier, LemonSlice at 30 minutes to 24 hours by tier, HeyGen at 20-60 minutes, FaceMode's beta at 10 minutes. Long sessions are a paid-tier feature almost everywhere.
Minimum charges and burst pricing. Tavus bills a 30-second minimum per conversation; LemonSlice prices calls above the concurrency limit at a 2x burst multiplier; D-ID rounds video minutes up to 15-second intervals.
Free tiers are evaluation budgets. Synthesia's 500 minutes, FaceMode's 60-minute beta, Anam's 30 min/mo, Tavus's 25 min/mo, HeyGen's ~10-20 minute monthly equivalent, and Simli's $10-plus-50-minutes let you test startup, interruption, and idle behavior. They are not production capacity, and most carry watermarks or session caps.

The ten APIs, briefly

Anam

The most productized avatar-layer competitor: Cara-4 model with Director Notes for mid-call emotion control, 1152x768 landscape or 768x1152 portrait output, 70+ languages, SOC 2 Type II with HIPAA-aligned controls, and the only public cross-vendor latency benchmark in the category. Strengths to weigh honestly: transparent tiered pricing, both LiveKit and Pipecat plugins, and the strongest public measurement posture. Its enterprise floor of $0.04/min is the lowest published rate we found, gated behind enterprise terms.

Beyond Presence

The enterprise-compliance play: Genesis 2.0 renders 1080p with claimed sub-100ms model inference and sub-250ms global latency, backed by SOC 2, GDPR, and EU data residency. October 2026 additions include bringing your own ElevenLabs agent, pushing agents into Zoom/Meet/Teams/Webex calls, and 24-hour speech-to-video sessions. Its homepage benchmark claims #1 across measured dimensions - treat it like every other vendor-run ranking in this post.

D-ID

The established enterprise vendor: V4 Expressive avatars with sentiment control, up to 4K output, generative UI inside conversations, and a SyncNet lip-sync table ranking itself above Anam, HeyGen, and Tavus. Agents are a full hosted pipeline (LLM, knowledge, voice in one API object), and the October launch of Presentation Mode extends the stack into slide-led sessions. Heavier than a bare avatar layer, but the broadest packaged feature set.

FaceMode

This site's product, so read this cell accordingly. FaceMode is the audio-in, face-out layer: stream your agent's audio over WebSocket and it publishes lip-synced video into a LiveKit or Daily room you own, as an ordinary participant you subscribe to with the SDK you already have. Plugins exist for LiveKit Agents in Python and TypeScript and for Pipecat; anything else uses the REST + WebSocket path directly. Five art styles plus a one-portrait custom avatar, idle crossfades instead of freeze frames, credits pricing. Published target: ~960ms audio-to-frame. Honest limits: private beta, 10-minute sessions, one concurrent session per account, and - unlike the nine competitors above - FaceMode's plugin is not yet listed in LiveKit's official avatar directory, which currently covers 16 providers.

HeyGen LiveAvatar

The biggest brand in the space, now with a genuine developer path. FULL mode is a hosted conversational pipeline; LITE mode renders the avatar for your own stack at half the credits. LiveKit, Pipecat, Agora, and VisionAgent integrations are documented, an openai_agent mode runs your own OpenAI key, and paid plans carry unlimited concurrency - the strongest concurrency posture in the table. The credit math (1 credit = 30s FULL / 60s LITE) puts effective FULL pricing around $0.16-0.18/min on self-serve plans. Their October comparison post ranks LiveAvatar #1 of 7; apply the same skepticism as to any self-ranked table.

LemonSlice

The most aggressive shipper this month. In the first half of October alone it launched the Cartoon Model (hyper-expressive cartoon/anime/3D mascot avatars from one image), CWM-1 Lite at "as low as $0.048/min", smoother rendering, and GDPR compliance - on top of CWM-1's action and emotion control, non-human characters, and mid-call image updates. Integration surface is the widest on the list: LiveKit plugin, REST, WebSocket aimed at Vapi/Retell/Bland-style agents, Agora, and a two-line widget. Caveats: the interesting models and the $0.048/min floor sit behind the $800/mo Ultra tier or enterprise, API access requires a paid plan, and its 471ms p99 is a mid-call response figure that says nothing about session startup.

Runway

The world-model entrant: Characters builds persistent avatars from a single image on GWM-1, accepts webcam and screen vision input, and now also lives inside OpenAI's Dots. Developer experience is genuinely good - React SDK, LiveKit plugin, embedded widget, MCP support. Constraints are real: sessions cap at 5 minutes per current docs, and at $0.20/min it is the most expensive pay-as-you-go cell in the table. Best fit for short, high-production-value interactions rather than long support calls.

Simli

"The face layer for AI agents" - the closest positioning match to FaceMode - built on Daily's WebRTC infra with LiveKit and Pipecat plugins. Its wedge is price: the Trinity-1 launch claimed under $0.01/min through Gaussian-splatting efficiency, and the site currently offers a $10 signup credit plus a 50-minute monthly top-up. The sub-300ms speech-to-video figure is a pipeline-stage claim like Anam's 180ms, not end-to-end latency. Watch the pricing page rather than launch-era numbers, which we could not reconfirm as a current rate card this cycle.

Synthesia

The enterprise video giant's real-time entry: a bring-your-own-stack Interactive Avatar API that joins your LiveKit room, with optional hosted TTS. Python livekit-plugins-synthesia and REST endpoints are documented, Pipecat is marked coming soon, and a Claude Code/Cursor skill now wires the integration for you. 500 free minutes is the most generous evaluation budget in the table. Public pricing pages conflict ($0.12 vs $0.10/min), transport is LiveKit-only, and plugin support is Python-only today - our full Synthesia vs FaceMode comparison covers the detail.

Tavus

The most complete hosted pipeline: CVI bundles STT, LLM, TTS, turn-taking (Sparrow), vision (Raven-1), and Phoenix rendering into one API object, with a LiveKit plugin for teams that only want the face. Replicas train from a headshot or two minutes of video, the object model was recently renamed to PAL/Face/Voice, and a Griffin model in preview claims Turing-test-level realism. The trade-off is price and shape: $0.32-0.37/min overage and a 30-second minimum make it the heaviest metering here, and its strength is an opinionated full stack you adopt wholesale.

Which interactive avatar API fits your situation

You already run LiveKit Agents. All nine competitors have official plugins in the LiveKit avatar directory, and FaceMode ships a public Python and TypeScript plugin outside it. Shortlist on transport ownership (your room vs vendor session) and avatar style, then instrument with AvatarMetrics.
You run Pipecat. FaceMode (pipecat-facemode), Anam, Simli, LemonSlice, HeyGen LiveAvatar, and Beyond Presence all document Pipecat paths; Synthesia marks it coming soon. Our LiveKit avatar tutorial shows the attachment pattern that carries over.
You are on Vapi, Retell, or a custom stack. You need a raw audio-in or WebSocket path: FaceMode's direct API, LemonSlice's WebSocket GA (built for exactly these agents), Simli's WebRTC, Anam's SDK, or Runway's session API. Skip anything that only ships as a plugin.
You want zero orchestration work. Tavus CVI, HeyGen FULL, or D-ID Agents supply the whole call including turn-taking. You trade away stack control and pay for the full pipeline whether you need it or not.
Compliance gates the deal. Beyond Presence (SOC 2, GDPR, EU residency), Anam (SOC 2, HIPAA-aligned, enterprise ZDR and data residency), D-ID, Synthesia, and now LemonSlice (GDPR, with ZDR and residency on Enterprise) all publish postures worth a procurement review. FaceMode is in private beta - evaluate it after compliance needs are met, not before.
Your character is not a photoreal human. LemonSlice's Cartoon model and CWM-1 animate mascots, anime, and non-humans; Runway accepts any visual style; Tavus accepts cartoon/anime/Pixar faces; FaceMode's library covers realism through flat vector. Compare listening and idle behavior, not just the talking demo.
Platform agents are not this comparison. Meta Muse, OpenAI Dots, and Gemini Live Avatar put a face inside a consumer assistant, not an API you attach to your agent - the Muse/Dots/Gemini post separates those categories.

Common questions

Which interactive avatar API is the cheapest?

At published floors, Beyond Presence advertises EUR 0.03/min at scale, Anam $0.04/min on enterprise, and LemonSlice $0.048/min on CWM-1 Lite - all volume-gated. Pay-as-you-go spans $0.10-0.20/min, and subscription-plus-pool plans vary with utilization. The honest answer: model your minutes, concurrency, and session lengths against the table above rather than trusting any headline figure, including ours.

Which interactive avatar API is the fastest?

There is no fair public answer. The only cross-vendor measurement published - Anam's TTFF benchmark - covers four vendors, measures startup time, and is run by one of the products it ranks first. Everything else is single-vendor claims with different boundaries, which is why this post lists each figure's measurement type instead of picking a winner.

Is there a free interactive avatar API?

For evaluation, yes: Synthesia offers 500 free minutes, FaceMode's beta includes 60 minutes, Anam 30 min/mo, Tavus 25 min/mo, Simli $10 plus a 50-minute monthly top-up, HeyGen about 10-20 minutes monthly, Runway 125 developer credits, and LemonSlice offers free on-site chats. None of these is a production tier.

Does HeyGen have an interactive avatar API?

Yes - LiveAvatar. LITE mode renders the face for your own stack over LiveKit, Pipecat, or Agora; FULL mode hosts the whole conversational pipeline. It bills in its own credit system, separate from HeyGen's video-generation subscriptions.

Is FaceMode the right choice here?

If your requirements are a LiveKit or Daily room you own, audio from any stack, Python or TypeScript LiveKit plugins or Pipecat, and per-second credit pricing, FaceMode was built for exactly that shape. If you need GA availability, enterprise compliance attestations, or concurrency beyond the beta's one-session limit today, several rows above fit better right now. The point of this post is that you can check that claim against primary sources, not our word for it.

If you want to test FaceMode, request beta access or read the quickstart and integration guides. If this comparison helped, the LiveKit avatar plugin walkthrough is the fastest way to see one of these rows running.

LiveKit Avatar Plugin: Add a Face to Your Voice Agent

prajwaldkadam — Fri, 02 Oct 2026 00:00:00 +0000

Use the FaceMode LiveKit avatar plugin to turn your existing voice agent's speech into lip-synced video in the room you already run. This guide covers the Python and TypeScript attachment paths, then shows how a browser subscribes to the avatar's media.

Your STT, LLM, TTS, and conversation logic stay in your agent. The avatar layer receives its audio and publishes synchronized audio/video as another room participant, following the model described in LiveKit's virtual avatar overview.

The examples below are integration excerpts validated against FaceMode's plugin READMEs and integration docs. They assume you already have a working LiveKit agent; they are not standalone worker applications.

What you need

Four things, all server-side:

A FaceMode account. Sign-up is waitlist-gated during the private beta at console.facemode.io/signup. Approved testers get 3,600 free credits - 60 minutes of avatar video, no card required.
A FaceMode API key (fm_...) from the dashboard.
An avatar ID for the face that should speak. Pick from the library across five art styles, or upload one front-facing portrait and make it your own.
A LiveKit room you own, plus a publisher token. The token must grant the FaceMode worker room_join, can_publish, and can_subscribe on your room.

The access and beta limits come from the FaceMode quickstart. Use a separate participant identity for the avatar worker and for each viewer. Reusing a token identity for multiple connections is not a way to give every participant the same permissions.

Set the credentials as environment variables on your backend:

export FACEMODE_API_KEY="fm_your_key_here"
export FACEMODE_AVATAR_ID="your_avatar_id"
export LIVEKIT_URL="wss://your-project.livekit.cloud"
export LIVEKIT_TOKEN="<publisher-token>"

Keep every token in this guide on the server. The browser only ever receives the room URL and its own subscribe-only viewer token - never the API key, never the publisher token.

The 30-second mental model

FaceMode is not another agent framework. It is one job done well: turn the audio your agent already produces into a lip-synced avatar, published into the room you already run.

Your agent (STT -> LLM -> TTS)
        |
        v (the TTS audio you already have)
    FaceMode -- lip-synced video frames, ~960ms audio-to-frame target
        |
        v
  Your LiveKit room -- the avatar joins as an ordinary participant
        |
        v
  Your frontend -- subscribes with the livekit-client SDK you already ship

Nothing sits between your app and your room. FaceMode joins as a participant, publishes its video track, and leaves when the session ends. If you removed FaceMode tomorrow, your agent would keep working exactly as before.

Step 1A: Python LiveKit avatar integration

If your agent runs on LiveKit Agents for Python, install the plugin:

pip install livekit-plugins-facemode

The FaceMode Python integration guide requires Python 3.13+ and LiveKit Agents 1.7+. In your existing asynchronous worker entrypoint, ctx is its job context and agent_session is the AgentSession you have already configured with speech and model providers. The attachment excerpt is:

import os

from livekit.agents import Agent, AgentSession, room_io
from livekit_plugins_facemode import AvatarSession

avatar = AvatarSession(
    api_key=os.environ["FACEMODE_API_KEY"],
    avatar_id=os.environ.get("FACEMODE_AVATAR_ID", ""),
)

await ctx.connect()
await avatar.start(
    agent_session,
    ctx.room,
    room={
        "type": "livekit",
        "url": os.environ["LIVEKIT_URL"],
        "token": os.environ["LIVEKIT_TOKEN"],
    },
)
await agent_session.start(
    agent=Agent(instructions="You are a helpful assistant."),
    room=ctx.room,
    room_options=room_io.RoomOptions(audio_output=False),
)
await avatar.wait_for_join()

Three details worth noticing:

audio_output=False. The avatar publishes synchronized audio and video. Disabling the agent's separate audio path avoids duplicate playback; it is not a guarantee against every possible synchronization issue.
The room object. You hand the plugin the same LiveKit URL and publisher token you already manage. FaceMode never creates or replaces your room.
wait_for_join(). A one-line confirmation that the avatar participant is actually in the room before you consider the session live.

Success means wait_for_join() resolves and the avatar's video track is available in the room, not merely that the REST request succeeded. The Python integration docs distinguish session creation, WebSocket negotiation, and media readiness.

Under the hood, avatar.start() creates a FaceMode session over REST, opens the worker WebSocket, negotiates the audio format, and forwards TTS frames as PCM. After a started session loses its transport, the plugin attempts up to two reconnects with fresh one-time tokens. Exhaustion surfaces an error; reconnect is not a guarantee that every outage is invisible.

Optionally, pin the upstream input provider so the backend knows which TTS is driving the audio:

avatar = AvatarSession(
    api_key=os.environ["FACEMODE_API_KEY"],
    avatar_id=os.environ["FACEMODE_AVATAR_ID"],
    input_provider="elevenlabs", # deepgram, gemini, gnani, elevenlabs, openai, cartesia, sarvam, custom
)

Any TTS works. If it can stream audio, it can drive a face.

Step 1B: TypeScript LiveKit avatar integration

Use @facemode/agents-plugin-facemode with Node 20+ and @livekit/agents 1.x, as specified in the TypeScript integration guide. This is an alternative to the Python route, not a second worker you need to run:

npm install @facemode/agents-plugin-facemode

Use this inside your worker entrypoint with an already-configured agentSession. The session-start portion is adapted from the TypeScript docs so the excerpt includes the audio-output setting as well as the avatar attachment.

import { voice } from "@livekit/agents";
import { AvatarSession } from "@facemode/agents-plugin-facemode";

const avatar = new AvatarSession({
  apiKey: process.env.FACEMODE_API_KEY!,
  avatarId: process.env.FACEMODE_AVATAR_ID,
  inputProvider: "deepgram", // optional
});

await ctx.connect();
await avatar.start(agentSession, ctx.room, {
  room: {
    type: "livekit",
    url: process.env.LIVEKIT_URL!,
    token: process.env.LIVEKIT_TOKEN!,
  },
});
await agentSession.start({
  agent: new voice.Agent({ instructions: "You are a helpful voice assistant." }),
  room: ctx.room,
  outputOptions: { audioEnabled: false },
});
await avatar.waitForJoin();

The plugin replaces the agent session's audio tail: TTS frames flow to FaceMode as binary pcm_s16le, interruptions send a cancel_utterance control, and reconnects are handled for you. Sample rates from 8kHz to 48kHz are accepted, with 8, 11.025, 12, 16, 22.05, 24, 32, 44.1, and 48kHz as the preferred set covering common TTS outputs.

Step 2: render the LiveKit avatar in the browser

This is the part developers expect to be hard and is actually the easiest. The avatar is just a participant in your room, so your existing LiveKit client code subscribes to it like any other video track.

Mint a separate, subscribe-only viewer token for a read-only viewer and pass it down with the room URL. In the browser, register the subscription listener before connecting and insert the elements returned by track.attach() into the DOM. This excerpt is adapted from LiveKit's track subscription guide:

import { Room, RoomEvent } from "livekit-client";

const room = new Room();
const media = document.createElement("div");
document.body.appendChild(media);
room.on(RoomEvent.TrackSubscribed, (track) => {
  if (track.kind === "video" || track.kind === "audio") {
    media.appendChild(track.attach()); // render the avatar
  }
});
await room.connect(roomUrl, viewerToken); // your own viewer token

Success is visible video plus audible speech, not just a connected room. In a multi-participant app, filter tracks by the avatar participant identity instead of rendering every subscribed participant. Your real app should also detach media on unsubscribe and disconnect the room when its viewer component unmounts.

This is a read-only viewer example. A user who talks to the agent needs microphone publication in your existing voice UI and appropriate grants on their own token. Do not give them the worker's publisher token. Browser autoplay policies can require a user gesture to enable audio; use LiveKit's playback controls in that interaction rather than interpreting silent playback as an avatar failure.

Interruptions, silence, and the in-between moments

Real conversations are messy, and the avatar behaves accordingly:

Barge-in. The plugin docs say an agent interruption sends cancel_utterance. That control is not evidence of zero-delay playback cancellation; test the visible and audible result in your actual client.
Silence between utterances. The FaceMode product summary describes crossfading into an idle loop between utterances. Check that this remains visible when your voice agent is waiting on a long-running tool call.
Startup budgets. The Python docs allow up to 240 seconds for readiness polling and WebSocket opening, but use a separate 15-second protocol acknowledgement budget and a 30-second default media-join timeout. Those are timeout settings, not a measured cold-start duration or a guaranteed successful startup.

A short pitfalls checklist

Before your first session, check the five things that bite most often:

Token grants. The publisher token must allow join, publish, and subscribe. If it pins a fixed participant identity, make the room policy allow that identity.
Secrets stay server-side. API key and publisher token never reach the browser. Only the room URL and a subscribe-only viewer token do.
audio_output=False on the agent session, or you will hear double.
Declared sample rate must match the actual PCM. The plugin locks the format at negotiation and rejects a mismatch mid-stream.
Beta limits. Sessions auto-end after 10 minutes, one concurrent session per account, and a session needs at least 60 credits of remaining balance to start.

Step 3: validate media, failure recovery, and shutdown

A LiveKit avatar integration crosses several boundaries: your voice agent, the FaceMode API, its ingestion WebSocket, the avatar participant, and browser playback. Diagnose the boundary that failed rather than treating all five as one connection.

Start with a short utterance whose beginning and end are easy to recognize. Confirm that only one audio path is audible and that the visible avatar is the participant you intended to subscribe to. Then interrupt a longer sentence. Observe whether the agent stops generating speech, whether cancellation reaches the avatar, and whether already-buffered client media continues playing. This separates agent behavior from transport and playback behavior.

Next, test a pause with no speech. Idle animation should not be mistaken for proof that the agent is ready to answer, and a connected room should not be mistaken for proof that the ingestion socket is healthy. Keep the voice agent's own state indicator alongside the video so users can distinguish listening from waiting.

The Python lifecycle guide documents await avatar.stop() or aclose() for shutdown. The TypeScript guide documents the equivalent methods. Wire these into your existing call cleanup path, including failures; an abandoned browser tab should not be your only cleanup mechanism. The canonical ended acknowledgement confirms the protocol message, not that every backend cleanup action has finished.

If you test reconnect behavior, do it with disposable development sessions. The plugin only attempts recovery after negotiation has completed; intentional shutdown and fatal protocol errors do not trigger the same recovery path. Do not write code that retries a consumed one-time WebSocket token or replays previously sent audio.

What the latency target does and does not mean

FaceMode publishes an approximately 960ms audio-to-rendered-frame target. Your total voice-agent response time also includes turn detection, transcription, LLM generation, TTS, transport, and client playback. A sub-second target for the avatar layer does not imply the whole conversation responds within one second.

When comparing providers, measure the same utterance from the same boundary. Keep session startup separate from steady-state response latency. Also keep interruption recovery separate: a pipeline can begin speaking quickly and still feel poor if it cannot stop naturally when the user cuts in.

Record observations from a real room rather than using a console-only voice test. Console mode can validate conversation logic without exercising the video subscription and browser playback paths. These are suggested acceptance checks, not benchmarks we ran for this article.

Choosing a plugin or the direct talking avatar API

Use the plugin when LiveKit Agents already owns your speech pipeline. It captures the framework's audio frames and lifecycle events, so you do not have to reproduce its WebSocket protocol handling. Use the direct talking avatar API when your application produces audio outside that framework and you can manage session creation, PCM negotiation, and shutdown yourself.

That choice does not automatically prove compatibility with every hosted voice-agent platform. A provider that cannot expose its generated audio, or whose calls are phone-only, may need an additional transport or product integration. FaceMode's documented room output is LiveKit or Daily, not a claim of native support for every conferencing system.

For a comparison with another bring-your-own-stack provider, see Synthesia Interactive Avatar vs FaceMode. Both preserve existing conversation models; their documented runtimes, transport paths, and access limits are the useful differences.

LiveKit avatar plugin: short version

Inside your existing asynchronous Python worker, connect the room, attach the configured avatar, start the configured agent session with direct audio disabled, and wait for video. This recap uses the room binding and objects configured in Step 1A; it is not a standalone script:

await ctx.connect()
await avatar.start(agent_session, ctx.room, room=room)
await agent_session.start(
    agent=Agent(instructions="You are a helpful assistant."),
    room=ctx.room,
    room_options=room_io.RoomOptions(audio_output=False),
)
await avatar.wait_for_join()

Here room is the server-side dictionary containing type, url, and the worker token from the earlier example. Stop the avatar through your call's cleanup path once the conversation ends.

From zero to a talking face

The whole flow is: install the plugin, hand it your room, keep your agent code. If you want the raw HTTP and WebSocket protocol instead - any language that can hold a socket open works - the direct API quickstart walks it end to end.

For the broader category distinction, read Muse Avatar, OpenAI Dots, Gemini Live Avatar vs FaceMode. It separates platform agent experiences from avatar components you integrate into a product.

Ready to see your agent talk? Join the beta - 60 free minutes, no card - or skim the docs first.

Synthesia Interactive Avatar vs FaceMode

prajwaldkadam — Fri, 02 Oct 2026 00:00:00 +0000

Synthesia Interactive Avatar and FaceMode both turn voice-agent speech into live, lip-synced video. If your agent already works, the useful comparison is which avatar API fits its transport, runtime, avatar requirements, and deployment constraints.

Synthesia's Interactive Avatar API supports a bring-your-own conversation stack connected to LiveKit. FaceMode accepts your existing audio and publishes avatar media into a LiveKit or Daily room you own. Neither requires replacing your LLM simply to add a face.

This is a documentation-based comparison by FaceMode, not an independent performance benchmark. Sources were checked on October 2, 2026. Prices, access rules, and plugin support can change; conflicting vendor documentation is called out rather than resolved by guesswork.

Synthesia Interactive Avatar vs FaceMode: the short version

Criterion	Synthesia Interactive Avatar	FaceMode
Conversation stack	Bring your own STT, LLM, and TTS; optional hosted TTS (docs)	Keep your voice stack; supply its audio (product summary)
Media transport	LiveKit-only in current operational docs (limitations)	Customer-owned LiveKit or Daily room (quickstart)
Integration paths	Documented Python LiveKit plugin and direct REST endpoints; Pipecat marked coming soon (product page)	LiveKit Python/TypeScript plugins, Python Pipecat plugin, direct REST + WebSocket (integrations)
Avatars	Synthetic and personal avatars; operational docs exclude stock actor avatars (limitations)	Front-facing portrait uploads and five library styles (product summary)
Comparable latency figure	No numeric audio-to-rendered-frame figure in the sources reviewed	Approximately 960ms audio-to-rendered-frame target, not a measured result from this comparison
Pricing and trial	Product page: $0.12/min and 500 free minutes; operational docs: $0.10/min (pricing sources)	Private beta: 3,600 credits / 60 minutes; paid top-ups not open yet (beta terms)

The shared capabilities matter as much as the differences. Bring-your-own models and room ownership are not FaceMode-exclusive features. A useful evaluation starts with those similarities, then tests the details that actually change your implementation.

Architecture: both can keep your voice stack

Synthesia's announcement describes an open architecture: customers supply their STT, LLM, and optionally TTS, while Synthesia provides real-time avatar rendering. Its plugin reference says the plugin replaces session.output.audio, so it can lip-sync the speech your agent already produces.

FaceMode follows a similar division of responsibility. Your agent handles conversation logic and produces speech. FaceMode takes that audio, generates synchronized avatar media, and publishes it as a participant in your room. Your frontend subscribes through the room SDK it already uses, as described in the FaceMode product summary.

Consequently, switching LLMs is not the main reason to choose one over the other. If your application mixes one company's transcription with another company's language model and a third company's TTS, both document a path for preserving that composition.

The transport boundary is a clearer difference. Synthesia's current operational documentation explicitly lists LiveKit-only transport. FaceMode's direct API accepts a room binding for LiveKit or Daily. That makes FaceMode relevant to a Daily-based application without implying that every third-party voice platform already has a tested, native FaceMode integration.

Be specific about what “keep your stack” means. You still need to route audio correctly, handle session lifecycle, and build a frontend that plays media. An avatar layer does not remove those responsibilities or make an existing voice agent production-ready by itself.

Integration paths: LiveKit, TypeScript, and Pipecat

For a Python LiveKit application, Synthesia documents livekit-plugins-synthesia and the livekit.plugins.synthesia import namespace. The plugin requirements specify Python 3.10 or later and LiveKit Agents 1.8.2 or later. Its marketing page uses a different installation name, so follow the plugin reference and quickstart for exact package instructions.

The following is the integration excerpt from that reference, without its inline annotation. It belongs in an existing worker with session, ctx, environment credentials, and a workspace-accessible avatar ID already configured:

from livekit.plugins import synthesia

avatar = synthesia.AvatarSession(
    synthesia.AvatarConfig(avatar_ids=["<avatar-id>"]),
)
await avatar.start(session, room=ctx.room)

The reference says the room must already be connected and avatar.start() must run before AgentSession.start(). It returns after the avatar joins and publishes video. This is an attachment excerpt, not a standalone script; use Synthesia's minimal quickstart for the complete worker and browser app.

FaceMode's Python package is livekit-plugins-facemode, imported as livekit_plugins_facemode. Its Python guide requires Python 3.13 or later and LiveKit Agents 1.7 or later. The same attachment boundary looks like this, adapted from FaceMode's integration README with required environment values made explicit:

import os
from livekit_plugins_facemode import AvatarSession

avatar = AvatarSession(
    api_key=os.environ["FACEMODE_API_KEY"],
    avatar_id=os.environ["FACEMODE_AVATAR_ID"],
)
await avatar.start(
    agent_session,
    ctx.room,
    room={
        "type": "livekit",
        "url": os.environ["LIVEKIT_URL"],
        "token": os.environ["LIVEKIT_WORKER_TOKEN"],
    },
)

Here too, the room and agent session already exist. Start the Python agent with audio output disabled, wait for avatar media using the documented helper, and shut the avatar session down when the call ends. The LiveKit avatar tutorial covers those surrounding steps.

FaceMode also ships @facemode/agents-plugin-facemode for TypeScript and pipecat-facemode for Python pipelines. A Pipecat avatar integration is not just an interchangeable LiveKit snippet: FaceMode's service taps TTS frames and handles returned media, with transport output configuration depending on how the pipeline is connected. Follow the integration overview rather than assuming all transports use identical setup.

Synthesia's product page mentions Python and Node in one section, but its FAQ says the plugin currently supports Python LiveKit Agents only; the reviewed reference is Python-specific. The same page marks Pipecat as coming soon. Treat those as availability questions to confirm before choosing a runtime, not proof that undocumented paths cannot exist.

Avatar styles and custom creation

Synthesia's announcement describes photorealistic avatars and branded Style Avatars powered by Express-3. However, its operational limitations say Interactive Avatar currently uses synthetic and personal avatars, not stock actor avatars. Its minimal quickstart repeats that restriction and explains how to obtain an Interactive ID from an eligible workspace avatar.

That distinction prevents a common purchasing mistake: a large catalog on a video-generation website does not mean every avatar in it can be used in a real-time session. Validate the specific appearance you want through the interactive product, using the actual account and API access you plan to deploy.

FaceMode documents five styles: realism, semi-realism, 3D animation, anime, and flat vector. It also accepts a front-facing portrait for a custom avatar. Those are documented product capabilities, not evidence that its visual quality is better than Synthesia's.

For a branded tutor, compare readability and character consistency during a full lesson. For a support agent, inspect listening behavior and lip sync across several utterances. Use the same script and reference style wherever the products permit it, rather than comparing each vendor's most favorable demo.

Latency: compare the same measurement

FaceMode's published target is approximately 960ms from audio to rendered frame. It is not a promise of 960ms from the user's last word to a response, and it is not a result measured for this article. Transcription, turn detection, LLM generation, TTS, networking, and playback all affect the experience a user sees.

The Synthesia pages reviewed describe real-time operation but do not provide a directly comparable audio-to-rendered-frame latency figure. Its quickstart discusses a preflight optimization for the voice pipeline; that is not an avatar rendering benchmark. “Not published in the reviewed sources” is different from “slow.”

Measure at least three separate timings in your evaluation:

Session startup: request creation to the first playable video track.
Response onset: end of the user's turn to audible speech and visible response.
Interruption recovery: user interruption to stopped playback and return to listening.

Use the same region, voice model, utterance, and client conditions. Record both typical and slower responses, including cold starts. A target for one stage cannot establish which complete system is faster, and neither successful socket negotiation nor a room join proves that media is already playing.

Pricing, free access, and production limits

Synthesia's Interactive Avatar product page advertises 500 free Interactive Avatar minutes and pay-as-you-go at $0.12/minute , with no commitment or minimum. Its operational documentation instead says 10 credits per minute, or $0.10/minute. These public sources disagree. Confirm the account-specific rate before estimating a production bill.

At the advertised $0.12 rate, 1,000 avatar minutes would cost $120 for that layer alone. That is arithmetic based on the product page, not a quote: your voice models, media infrastructure, and other services remain separate costs. Do not use prices for Synthesia's scripted-video plans as a substitute for Interactive Avatar pricing.

FaceMode's beta terms provide 3,600 credits, equivalent to 60 minutes , with one credit metering one second of streamed video. Credit purchases are disabled during beta and top-ups open at general availability. There is no published paid rate in the reviewed FaceMode product summary, so this comparison cannot establish which service is cheaper in production.

FaceMode's beta also has ten-minute sessions, one concurrent session per account, and a minimum remaining balance of 60 credits to start. Synthesia's operational docs list one concurrent session for Freemium and 100 for paid plans. Check current terms for both products before building load-test or rollout plans.

Free allowances are evaluation budgets, not substitutes for availability, quotas, or production support. Count the minutes needed for testing startup, interruptions, multiple voices, and failure recovery, not just one polished demonstration.

Where each product is a stronger fit

Synthesia is a stronger candidate when your immediate path is documented Python LiveKit integration and you need a publicly offered paid service. Its Python baseline is lower than FaceMode's, its current product page describes general availability, and it publishes an initial usage rate. Its announcement also describes enterprise security certifications and workspace controls; validate their scope for your procurement requirements rather than assuming they apply identically to every deployment.

FaceMode is a useful Synthesia alternative when your requirements include its documented TypeScript LiveKit plugin, Python Pipecat integration, or Daily room output through the direct API. Its portrait-upload workflow and five library styles may also match your design requirements. Those benefits come with explicit private-beta access and limits.

Neither choice should be justified by claiming the other forces a different LLM, owns your room, or lacks all stylized avatars. The public sources do not support those claims. The real decision is which documented integration and operating model fits the application you are shipping.

How to choose an interactive avatar API

Before committing to either product, run the same acceptance checklist:

Confirm your runtime, framework version, and media transport have a documented path.
Verify your intended avatar is available for interactive use, not only rendered video.
Check startup, speech, interruptions, and idle behavior in an actual room.
Keep API credentials and worker tokens server-side; give the browser its own room token.
Confirm pricing, concurrency, session duration, and access in your account.
Inspect reconnect and shutdown behavior, including what happens after a failed session.

Does Synthesia have interactive avatars?

Yes. The current Interactive Avatar page describes a generally available API that renders real-time conversations, not just scripted video. This question also appears in the autocomplete suggestions reviewed for this post. The important next check is whether your particular workspace avatar and integration path are supported.

Is FaceMode a Synthesia alternative?

For adding real-time visual output to existing voice-agent audio, it is an alternative worth testing. It is not a replacement for every Synthesia product, such as its broader scripted-video creation workflow. Compare the interactive APIs on their documented transports, runtimes, limits, and actual media behavior, while accounting for FaceMode's private-beta access.

If your goal is to understand how these avatar APIs differ from platform-level launches, read the Muse Avatar, OpenAI Dots, and Gemini Live Avatar comparison. If you already have a LiveKit agent and want to try the FaceMode path, use the LiveKit avatar plugin walkthrough.

For a FaceMode proof of concept, request beta access or start with the direct API quickstart. Choose on documented fit and a tested workflow, not on a comparison table that hides the constraints.

Muse Avatar, OpenAI Dots, Gemini Live Avatar vs FaceMode

prajwaldkadam — Fri, 02 Oct 2026 00:00:00 +0000

Muse Avatar, OpenAI Dots, and Gemini Live Avatar put different kinds of visual presence around AI agents. For a developer, the first question is not which looks best: it is whether the product supplies an agent experience or a talking avatar API you can attach to the voice agent you already run.

Meta's Muse Realtime Avatar research announcement appeared on September 23, 2026. Google's Gemini 3.8 Live with Live Avatar announcement followed on September 24, and OpenAI introduced Dots on September 29. They are related developments, but they are not interchangeable integration options.

This is FaceMode's documentation-based category comparison, checked on October 2, 2026. We have not run an independent visual-quality or latency benchmark across these products. The differences below describe documented product boundaries, not a claim that one provider wins every workload.

The short version

Product	What the reviewed sources describe	Developer integration question
Meta Muse Avatar	Avatar rendering coupled to Muse Realtime Voice; images can drive expressive characters	The research post does not document an external PCM-to-avatar API for your room
OpenAI Dots	Persistent assistants with cloud computers, connected apps, messaging, and voice calls	An assistant product, not a documented lip-synced video output API
Gemini Live Avatar	Avatar capability natively paired with Gemini 3.8 Live, available in Gemini Enterprise	Evaluate as part of the Gemini Live conversation stack
FaceMode	Audio-driven avatar API and plugins, publishing into your LiveKit or Daily room	Evaluate as an added visual layer for your existing audio pipeline

The table separates categories before comparing features. A hosted assistant may be the right product for an employee who wants work delegated. A video-generation layer may be the right component for a team building a customer-facing voice application. Both needs are real; they do not share the same acceptance criteria.

Meta Muse Realtime Avatar: shared speech tokens and video

Meta's research post describes Muse Realtime Voice and Muse Realtime Avatar as a single streaming system. The voice model produces speech tokens carrying both content and delivery. An audio decoder turns those tokens into speech, while the avatar model consumes the same stream to generate the visual performance.

The avatar model is an audio-driven Diffusion Transformer conditioned on the speech-token stream, reference media, and recent video context. It produces video in short causal chunks and carries recent generated context into the next chunk. That is the technical mechanism Meta describes for maintaining continuity during a live conversation.

Meta reports 448×768 portrait video at 25fps and approximately 870ms from the end of a user's turn to the first byte of a synchronized voice-and-video response. This is a vendor-reported end-of-turn response metric, not the time taken to render an isolated audio frame and not a measured browser playback delay from our own test.

The post also describes company-run live-call preference tests against Runway Characters and HeyGen LiveAvatar. Raters preferred Muse overall, while the mannerism comparison with Runway was not statistically distinguishable from parity. That result should be attributed to Meta's evaluation and its tested conditions, not turned into a universal ranking of every avatar API.

For integration planning, the important limit is what the post actually documents. It explains Muse's coupled voice-and-avatar system and notes that its examples do not all reflect avatars available in the Muse app. It does not provide a public recipe for sending your own PCM audio to Muse Avatar or publishing its output into your LiveKit room. That is a limit of the reviewed documentation, not proof that Meta will never offer such a product.

OpenAI Dots: an assistant with a visual identity

OpenAI's Dots announcement describes always-on agents powered by GPT-6 Astra. They have cloud computers, can use a browser, connect to more than 4,000 apps through plugins, and work on goals over time. Users can message or call them through ChatGPT, with Slack and Teams also described as communication channels.

This is a persistent-assistant architecture. Its value is task continuity: a user gives the agent context and goals, then reviews work or decisions rather than supplying every next instruction. The announcement includes examples such as investigating software feedback, updating research analysis, and preparing content for approval.

The cartoon-like identity shown around Dots is not equivalent to a streaming avatar renderer. The launch article does not document an endpoint that accepts a developer's audio stream and returns a lip-synced video participant. Calling it an “avatar” in news coverage does not make it a substitute for a real-time avatar API.

OpenAI says rollout begins across Pro, Business Premium, and Enterprise plans in eligible markets. Those access details matter if you want a personal or organizational assistant. They do not answer whether your product can stream its own TTS into a custom face; that is a different capability and is not documented in the reviewed announcement.

Choose Dots for the assistant workflow it actually offers. Do not evaluate it as though its cloud computer, connected apps, and background tasks were features that a narrowly scoped audio-to-video renderer ought to provide. FaceMode does not replace that agent harness or perform those tasks on your behalf.

Gemini Live Avatar: a native conversational video capability

Google's announcement presents Gemini 3.8 Live with Live Avatar as near-real-time visual presence natively coupled to Gemini's live dialogue model. It includes lip sync, expressions, multimodal conversation, and asynchronous tool execution while dialogue continues.

Google says the feature can transition across 97 languages , adapting speech-to-speech synchronization and expressions. It also describes a preset avatar library and custom avatars created from reference images, with custom creation available through enterprise allowlisting. These are Google's published capabilities, not independently tested quality claims from this article.

The announcement says Live Avatar is available in Gemini Enterprise and links developers to API documentation. It also describes SynthID watermarking for audio and video output. For organizations already evaluating Gemini's live conversational stack, those capabilities belong in the procurement and technical review.

What the announcement does not establish is a drop-in renderer for an arbitrary external TTS stream. Its architecture is described as paired with Gemini 3.8 Live. That is narrower than saying “all your infrastructure must be Google,” which the launch post alone does not prove. Review the actual enterprise API and deployment terms before drawing conclusions about external clients, networking, or room integration.

A team adopting Gemini for conversation generation is making a different decision from a team that already has a working STT/LLM/TTS pipeline and wants only video output. The distinction is about the integration boundary, not whether either architecture is inherently better.

FaceMode: a talking avatar API for existing voice agents

FaceMode's product summary describes a focused audio-to-video layer. Your agent retains its speech recognition, language model, voice synthesis, and turn detection. FaceMode receives the audio it produces, renders a lip-synced avatar, and publishes media as a participant in a LiveKit or Daily room you own.

The integration overview covers LiveKit Agents plugins for Python and TypeScript, a Python Pipecat integration, and the direct REST/WebSocket path. The direct API is useful when your application produces audio outside those frameworks, provided you can implement the documented session lifecycle and PCM negotiation.

That does not mean every hosted voice service or conferencing application is already supported natively. Verify that your platform exposes the audio you need and that your intended output can use the documented room transport. “Can stream audio” is an input capability, not proof of an end-to-end integration with every product bearing an API label.

FaceMode documents a front-facing portrait upload workflow and five library styles: realism, semi-realism, 3D animation, anime, and flat vector. Its published latency target is approximately 960ms from audio to rendered frame. That target is not a guarantee of total conversational response time or instantaneous interruption cutoff.

The quickstart describes private-beta access, 3,600 free credits equivalent to 60 minutes, one credit per second of streamed video, ten-minute sessions, and one concurrent session per account. Paid top-ups are not open during beta. Those operating limits should be part of the decision, especially if your next step is production deployment rather than a proof of concept.

Latency claims are not directly comparable

Meta's approximately 870ms number begins at the end of the user's turn and ends at the first byte of synchronized response. FaceMode's approximately 960ms target begins with supplied audio and concerns its rendering path. Comparing the two numbers as a speed ranking would combine different timing boundaries and a reported result with a product target.

The reviewed Dots announcement is not an avatar-rendering benchmark. Google's Live Avatar announcement does not publish a directly comparable numeric latency figure. Missing numbers should remain missing, rather than being inferred from words such as “real-time” or “near-real-time.”

For an application test, record session startup, end-of-turn response onset, media synchronization, and interruption recovery separately. Use the same voice settings, client region, network conditions, and utterances where the architectures permit it. Keep cold-start observations separate from ongoing turns.

This also makes failures easier to diagnose. A delayed LLM response, slow avatar startup, and browser audio playback restriction can all look like “the avatar is slow” while requiring different fixes. A comparison article should not flatten those into one unexplained millisecond figure.

Where each product is a useful fit

Muse Avatar: investigate it when you care about Meta's integrated consumer-facing embodiment research, shared speech-token architecture, or expressive character generation. Its research demos provide technical context, but the reviewed post is not an external integration guide.
OpenAI Dots: evaluate it when you want a persistent assistant working across connected applications with review and permission controls. It addresses delegated work, not just a visual response to supplied speech.
Gemini Live Avatar: evaluate it when Gemini's live dialogue stack and enterprise access fit your application. The announced multilingual synchronization, tools, and custom-avatar pathway are genuine reasons to include it in that review.
FaceMode: test it when your voice agent already exists and its audio needs a visual layer in a documented LiveKit or Daily room. Account for private-beta limits and test media readiness, not only API responses.

FaceMode is not the only provider in the last category. Other vendors also offer bring-your-own-stack real-time avatar components. For a more direct comparison, read Synthesia Interactive Avatar vs FaceMode, which examines shared architecture as well as differences in runtimes, transport, pricing, and access.

Adding a face to an existing LiveKit voice agent

If you choose the component route, attach an avatar session inside the worker you already run. This FaceMode excerpt is adapted from the Python integration README. It assumes agent_session and a connected ctx.room already exist, and that environment credentials are configured on the server:

import os
from livekit_plugins_facemode import AvatarSession

avatar = AvatarSession(
    api_key=os.environ["FACEMODE_API_KEY"],
    avatar_id=os.environ["FACEMODE_AVATAR_ID"],
)

await avatar.start(agent_session, ctx.room, room={
    "type": "livekit",
    "url": os.environ["LIVEKIT_URL"],
    "token": os.environ["LIVEKIT_TOKEN"],
})

The complete flow also starts the agent with direct audio output disabled, waits for avatar media, and handles shutdown. The LiveKit avatar plugin tutorial covers those steps and the browser subscription path. Use the direct API quickstart if you are not using a framework plugin.

Keep credentials separate: the avatar worker receives a server-side publisher token, while the browser gets its own room token. A read-only viewer and a user publishing a microphone have different permissions. An API key or worker token should never be the shortcut used to make a browser demo connect.

Questions to answer before choosing

Do you need an assistant or a renderer? If the requirement is autonomous work across apps, compare agent products and their controls. If it is visual output for existing speech, compare real-time avatar APIs and transports.

Can you keep the voice pipeline you already have? FaceMode documents that path explicitly. Google's launch describes native pairing with Gemini Live. Meta's research describes shared voice tokens. Dots is a packaged assistant. Check documentation for the specific integration boundary rather than assuming the marketing term “avatar” implies the same contract.

What will you actually test? Start with a short real conversation: join, speak, interrupt, pause, resume, and end. Inspect video, audio, and session cleanup. Then check pricing and concurrency with the account you will deploy, not only the public demo.

The goal is to choose the right layer for your application. If FaceMode's component model fits, request beta access or read the FaceMode docs before wiring it into your agent.

DEV Community: FaceMode

Interactive Avatar APIs Compared: 10 Options (2026)

Three ways to put a face on a voice agent

Interactive avatar APIs: the comparison table

How to read the latency numbers

What a minute of avatar actually costs

The ten APIs, briefly

Anam

Beyond Presence

D-ID

FaceMode

HeyGen LiveAvatar

LemonSlice

Runway

Simli

Synthesia

Tavus

Which interactive avatar API fits your situation

Common questions

Which interactive avatar API is the cheapest?

Which interactive avatar API is the fastest?

Is there a free interactive avatar API?

Does HeyGen have an interactive avatar API?

Is FaceMode the right choice here?

LiveKit Avatar Plugin: Add a Face to Your Voice Agent

What you need

The 30-second mental model

Step 1A: Python LiveKit avatar integration

Step 1B: TypeScript LiveKit avatar integration

Step 2: render the LiveKit avatar in the browser

Interruptions, silence, and the in-between moments

A short pitfalls checklist

Step 3: validate media, failure recovery, and shutdown

What the latency target does and does not mean

Choosing a plugin or the direct talking avatar API

LiveKit avatar plugin: short version

From zero to a talking face

Synthesia Interactive Avatar vs FaceMode

Synthesia Interactive Avatar vs FaceMode: the short version

Architecture: both can keep your voice stack

Integration paths: LiveKit, TypeScript, and Pipecat

Avatar styles and custom creation

Latency: compare the same measurement

Pricing, free access, and production limits

Where each product is a stronger fit

How to choose an interactive avatar API

Does Synthesia have interactive avatars?

Is FaceMode a Synthesia alternative?

Muse Avatar, OpenAI Dots, Gemini Live Avatar vs FaceMode

The short version

Meta Muse Realtime Avatar: shared speech tokens and video

OpenAI Dots: an assistant with a visual identity

Gemini Live Avatar: a native conversational video capability

FaceMode: a talking avatar API for existing voice agents

Latency claims are not directly comparable

Where each product is a useful fit

Adding a face to an existing LiveKit voice agent

Questions to answer before choosing

Primary sources