Introducing AKA-1: Akapulu Lab's Flagship Real-Time Avatar Model

Today we're introducing AKA-1, Akapulu's flagship real-time avatar model. It turns audio into a synchronized, photorealistic talking face fast enough to sustain a live conversation.

Getting there is harder than it looks. Real-time audio-driven avatar synthesis is one of the more punishing problems in applied generative AI, and most systems that look good in a demo reel quietly fail the moment they have to run live, uninterrupted, for the length of a real conversation.

Below is a tour of where these systems break, and what AKA-1 does differently.

Diffusion: high fidelity, and way too slow

Why full video diffusion can't run live

End-to-end video diffusion models produce the highest visual fidelity available today, but they generate pixels through hundreds of iterative denoising steps, each one a full forward pass over a high-dimensional spatiotemporal latent.

• Cost scales with sampling steps × latent grid size
• With transformer backbones, attention scales quadratically in spatial-temporal tokens
• A few seconds of video can take tens of seconds of compute, a non-starter when conversational AI needs a response within 1 second
• Smaller models or fewer steps trade away exactly the realism that made diffusion worth using

AKA-1's approach: diffuse over motion, not pixels

AKA-1 sidesteps the cost curve by pushing diffusion to its extreme: we do not diffuse over pixels, or even over spatial latent patches, but over a compact vector of facial control parameters.

1. Factor identity from dynamics: lock the speaker's appearance into a fixed reference
2. Denoise kinematic coefficients: low-dimensional values governing face, expression, head pose, and articulation, conditioned on incoming audio
3. Single-shot render: a synthesis network expands coefficients into full-resolution pixels in one feed-forward pass

Because appearance is held constant, the generator only solves the audio-to-dynamics problem rather than re-synthesizing the entire face at every step. The diffusion target is a few hundred parameters per frame instead of the millions of values in a spatial latent, collapsing per-step cost by orders of magnitude and allowing very few sampling steps with no visible quality loss.

Small errors = big drift

The streaming feedback loop

To run live, a model has to generate in a streaming, chunk-by-chunk fashion, emitting short windows of motion as audio arrives and conditioning each new segment on its own past output. The model's predictions become the context for its next predictions.

Any autoregressive system of this form is subject to exposure bias: the mismatch between clean ground-truth context seen during training and imperfect, self-generated context at inference. Small errors in early frames are fed back in and, because the mapping is recursive, compound rather than wash out.

What goes wrong over a long session

• Identity drift: the reconstructed face gradually diverges from the original speaker as residual error accumulates across windows
• Temporal jitter: motion loses smoothness at chunk seams, producing abrupt transitions the eye reads instantly as fake

How AKA-1 prevents drift

• Fixed identity anchor: every frame is reconstructed against an immutable source representation, not a degrading copy of the previous frame. No recursive appearance path for drift to travel down.
• Bounded, overlapped context: temporal conditioning is explicitly bounded with boundary-aware blending across chunk seams. Historical state informs continuity but cannot snowball.

An avatar that looks identical in minute thirty as it did in second one, with smooth, seam-free motion across unbounded multi-turn dialogue.

Who you are vs. how you move

The entanglement problem

Many pipelines drive each new frame from features pulled out of previous frames, which entangles two fundamentally different signals:

• Identity & appearance: what this person looks like
• Motion: how they are currently moving (expression, articulation, pose)

Because both ride in the same shared representation, the network has no clean way to vary one without perturbing the other. When those signals bleed together:

• Flickering between frames
• Smearing around the mouth as lips move
• A face that subtly warps as it talks, with appearance re-estimated from motion-contaminated features every step

Separate, decoupled representations

AKA-1 keeps appearance and motion apart end to end:

1. Extract a fixed identity code once per session; appearance locked for the entire conversation
2. Generate motion independently, conditioned only on audio
3. Combine at render time: motion applied on top of the frozen identity, never folded back into it

Clean, stable, phoneme-accurate lip-sync and full-face animation, with coordinated motion across jaw, cheeks, eyes, and brow, instead of a moving mouth pasted onto a drifting head.

The face on your audio

Your bot hears the person and produces the spoken audio. AKA-1 takes that audio and renders the face in sync. The avatar publishes the face and the played audio.

The renderer streams. It emits frames as the audio arrives, so the mouth is already moving before the sentence is finished. An incoming turn stops the current speech. Output stays at a continuous 25 FPS, including the idle between turns.

One GPU, one container

The face runs inside a single container on one GPU. The motion model diffuses over a handful of facial coefficients rather than pixels, so the renderer fits in one memory budget and executes on that device.

Generic models produce generic faces

Most systems animate a single shared model across every identity, conditioning on a reference image at inference time. Deployment stays simple, but subtle, person-specific detail gets regressed toward the mean, because the network's weights encode a population average of faces and motion.

Per-avatar fine-tuning

From an actor's reference material (a short, 1 minute clip), AKA-1 fits dedicated weights for that individual:

• Motion profile: idiosyncratic dynamics: how their mouth shapes phonemes, brow and eye movement, resting pose, micro-expressions
• Appearance model: high-fidelity capture of their face

Those weights compile into an optimized inference engine for the target hardware, so personalization adds fidelity without adding latency. The identity stays consistent across thousands of conversations because it is baked into the model, not approximated from a reference at run time.

Text, then voice, now face

The first wave of conversational AI was text. Now, we're starting to see voice-to-voice applications flourish. We believe face-to-face interactions are the next step, and the hardest one to get right.

A response can be fast and still not feel present. A face can look good in a demo and still break once a conversation runs long, gets interrupted, or needs to hold a specific identity across thousands of turns.

AKA-1 exists to solve that layer: real-time face-to-face presence, not just animated output. It is the model behind every live avatar on Akapulu today, and the foundation for the next generation of live, face-to-face AI experiences.