Why Liforma's AI Avatar Cost Will Be Hard to Beat

Liforma's cost advantage does not come from one cheap model or one cloud discount. It comes from four different layers of architecture that reduce the amount of server work, reduce the amount of always-on infrastructure, reduce inference cost and reduce the cost of the remaining GPU compute.

The important point: the savings compound. A competitor cannot close the gap by swapping one model or negotiating one cheaper GPU contract, because the cost reduction happens across the whole STT → LLM → TTS → STA stack.

The normal cost structure of a conversational avatar

A realtime avatar usually needs four expensive stages: speech-to-text, an LLM or other intelligence, text-to-speech, and speech-to-animation. A conventional architecture may also keep a continuous media session alive and render the avatar on server GPUs.

Liforma attacks those costs at four separate layers.

Layer	Liforma approach
1. Client compute	Move speech recognition and speech-to-animation into the browser where practical.
2. Transport	Use request-oriented HTTP for naturally turn-based experiences instead of requiring an always-on AI media session.
3. Models	Operate and optimise open-source STT/LLM infrastructure rather than paying retail API margins on every turn.
4. GPU infrastructure	Use Liforma's own multi-provider elastic GPU layer so remaining inference can run on attractive capacity without permanent over-provisioning.

1. Move heavyweight work into the browser

Every Liforma user already arrives with a capable computer or phone. Where the browser can do useful work reliably, we prefer to use that compute rather than duplicate it in a data centre.

Speech-to-text at the edge

On supported paths, speech recognition can run in the browser rather than requiring every second of microphone audio to become a paid server-side inference workload. Server-side STT remains useful as a compatibility and fallback path, but it does not have to be the default cost for every user.

Proprietary speech-to-animation in the browser

The larger architectural saving is animation. Liforma's speech-to-animation technology is designed so the character can be animated and rendered on the user's device.

That avoids the conventional pattern of paying a central GPU to render a realtime avatar, encode a video stream and continuously deliver that stream back to the browser.

Once STT and STA have been pushed toward the client, the central server path is dramatically simpler: the expensive core is largely reduced to intelligence plus speech generation.

Why client-side compute changes scaling economics

If every additional user requires another server-rendered avatar stream, infrastructure cost rises with concurrency. If major parts of recognition and rendering run on the user's own device, those workloads scale with the devices users already own.

This is not a small optimisation. It removes entire categories of centralised compute from the unit economics.

2. Use HTTP when the interaction is naturally turn-based

WebRTC is excellent for continuous full-duplex calls. But many AI character experiences are not continuous calls. Training, tutoring, role-play, games and website assistants are often naturally:

listen → think → speak → listen.

Liforma is designed so those experiences do not require a continuously provisioned AI media session for the entire period the user has the experience open.

Match infrastructure lifetime to actual AI work

When a turn needs server compute, the client makes a request. The server performs the work and streams or returns the result. Between turns, much of the application layer can remain stateless.

This maps naturally to serverless infrastructure. Liforma uses Vercel for significant parts of the application layer, so compute can scale around actual requests rather than around the wall-clock length of every conversation.

The cost advantage is not that HTTP is magically cheaper than WebRTC. It is that a request-oriented architecture can avoid paying for a continuously provisioned session when no AI work is happening.

For more detail, see Does Conversational AI Really Need WebRTC?.

3. Self-host and optimise the models that matter

Hosted AI APIs are a fantastic way to launch quickly, but retail API pricing includes the provider's infrastructure costs and margin on every request.

At scale, Liforma can do better by operating optimised open-source models for important server-side parts of the stack.

The advantage is not simply “we use open source.” Anyone can download a model. The hard part is making that model deliver the right combination of quality, latency, throughput, memory efficiency and reliability under realtime traffic.

We deliberately do not publish the specific models, serving configuration, quantisation choices or other optimisation details. Those change over time and form part of the engineering advantage.

Why model serving matters as much as model choice

Two companies can run the same model and have very different unit economics.

Cost depends on how effectively hardware is used, how much concurrency is achieved, how idle capacity is handled, how quickly a workload becomes ready and how the service behaves during bursts.

That is why simply moving from a frontier API to a smaller open-source model does not reproduce the Liforma cost structure.

4. Run the remaining GPU workload through our own elastic compute layer

After the first three layers have reduced the amount of work that still needs central compute, the remaining GPU workload is handled through Liforma's own orchestration layer across multiple compute providers.

At a high level, that layer exists to find compatible GPU capacity at an attractive cost, bring it online quickly, make it ready for Liforma workloads and avoid paying for unnecessary idle capacity.

We do not publish the provider-selection logic, bootstrap pipeline, model-loading strategy or other operational details behind it.

The economic effect is what matters: Liforma is not permanently tied to one provider's standard on-demand GPU price.

Cold-start engineering is part of the moat

Cheap elastic GPU capacity is only useful if it can become productive quickly.

One easy way to guarantee low latency is to keep large amounts of GPU capacity permanently warm. That also guarantees a large idle-compute bill.

Liforma has invested heavily in reducing the time required to turn newly acquired GPU capacity into useful production capacity. That enables a more serverless GPU model: scale capacity up when it is needed and avoid keeping more expensive hardware warm than necessary.

The real advantage is multiplicative

The four layers reinforce one another:

browser compute removes server workloads entirely;
turn-based transport reduces idle application infrastructure;
optimised self-hosted models lower the cost of the server work that remains; and
the GPU layer lowers the hardware cost of running those already-optimised workloads.

The fourth optimisation is therefore being applied to a cost base that has already been reduced by the first three.

This is why the gap is hard to close: changing one vendor, one model or one hosting contract only attacks one layer. Liforma's economics come from the complete system.

Why cheaper APIs alone do not reproduce this

A platform built from third-party STT, LLM, TTS and server-rendered avatar services can negotiate better rates as volume grows. But discounts only reduce the price of workloads that still exist.

Liforma removes some work from the server entirely, avoids keeping some infrastructure alive between turns, removes retail inference margin where appropriate and then shops the remaining GPU workload across an elastic compute layer.

That is fundamentally different from negotiating a percentage discount on an otherwise unchanged stack.

Why a smaller LLM alone does not reproduce this either

A cheaper LLM does not remove server-side avatar rendering. It does not remove speech-recognition cost. It does not remove an always-on media session. And it does not make the GPU running the model itself cheaper.

Model optimisation matters, but only as one part of an end-to-end cost architecture.

RAG can push the model cost down further

Many avatar experiences need deep expertise in a narrow domain rather than maximum general intelligence. Retrieval lets a smaller, faster model answer from the right domain evidence instead of relying on an expensive frontier model for every turn.

That is another example of Liforma's broader philosophy: improve the whole system rather than throwing the largest available model at every problem.

See RAG for AI Avatars: Why Your Character Doesn't Always Need a Frontier LLM.

Low cost does not mean customers are forced onto the cheapest components

Liforma is deliberately composable.

Customers who want simplicity can use the complete managed stack. Developers who want their own LLM can use Liforma for STT, TTS and animation. Teams that already use a premium speech-to-speech system can keep that entire stack and use Liforma only for the visual layer.

See Three Ways to Build With Liforma.

What this means for Liforma's unit economics

Taken together, these architectural choices allow Liforma to generate a complete STT → LLM → TTS → STA conversational response at below one cent per conversational minute while still keeping room to improve the stack over time.

We do not publish our underlying internal cost, model choices, serving configuration or orchestration logic. Those are deliberately private.

What customers, investors and competitors can see is the architecture around them: client-side compute, request-oriented transport, self-hosted inference and elastic multi-provider GPU capacity.

The cost advantage should improve, not disappear

There is another useful property of this design: every layer can improve independently.

Browsers and consumer hardware continue to become more capable.
Open-source AI models continue to become smaller and stronger.
Inference software continues to become more efficient.
GPU markets continue to become more competitive.
Liforma can continue improving its own animation and orchestration technology.

Because Liforma owns the integration between these layers, improvements can flow directly into the unit economics rather than being captured entirely by an upstream provider.

The moat is the system

No individual piece described here is impossible for another engineering team to understand.

The difficult part is making all four layers work together without sacrificing latency, quality, compatibility or reliability.

That is why we think Liforma will remain difficult to beat on cost.

The advantage is not one secret model or one clever hosting trick.

It is an architecture designed from the beginning to avoid paying for work that does not need to happen on the server.