DEV Community: FaceMode

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.

Primary sources

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.