Tell 1 vs LFM2.5 2.6B Base: A Voice Model You Rent and a Checkpoint You Finish Yourself

Put Tell 1 and LFM2.5 2.6B Base next to each other and the size difference looks like the story: one is Retell's in-house reasoning model inside a contact-centre platform, the other is a 2.69-billion-parameter text-only checkpoint from Liquid AI that fits in a 5.4 GB file. It is not the story. The story is that LFM2.5 2.6B Base is a base model — it has never been instruction-tuned, and if you ask it a question it will continue your text rather than answer it — while Tell 1 is a finished component of a product that answers phone calls for a living. One of them is raw material. The other is a working part you are not allowed to take apart. Everything below is about which of those two things your problem actually needs, because neither can substitute for the other and the price comparison that seems obvious is the least useful thing on this page.

The timing matters too, and it is the reason this pairing exists at all. Both are recent: Liquid AI published the LFM2.5 family in August 2026, and Retell's Tell 1 entered public view in November 2026 when it appeared at the top of a benchmark Retell publishes. Neither is a launch you are reading about late. Both are also unusually thin on public documentation, for opposite reasons — Liquid shipped a checkpoint with no instructions because instructions were never the point, and Retell shipped a model with no documentation because the model is not a product you can buy separately.

Start with what the Liquid checkpoint cannot do

LFM2.5 2.6B Base is the pretrained checkpoint of Liquid AI's LFM2.5 hybrid family: 30 layers, 22 of them dual-gated short-convolution blocks and 8 grouped-query attention, trained on roughly 34 trillion tokens across 16 languages, with a 131,072-token context window and a Q4_K_M quantisation that lands near 1.67 GB. Text in, text out. No vision, no audio, no tool-calling template you can rely on, no instruction tuning — and Liquid's own model card says plainly that it is intended for heavy fine-tuning rather than for prompting.

That is not a defect, and treating it as one is the most common mistake in write-ups of base models. A base checkpoint is the correct starting point when you have a task with a shape, a large body of your own examples, and no interest in paying a vendor per token to solve it. A 2.69B model that fine-tunes on one consumer GPU and then runs quantised on a laptop or a phone is a different economic object from any hosted API: the marginal cost per call goes to roughly the electricity, and the cost you actually pay moves into data labelling, training runs and evaluation.

What it cannot do is be dropped into a conversation. There is no system prompt that turns a base checkpoint into a reliable tool-calling agent, and no amount of prompt engineering substitutes for the post-training step. If your plan is "download it, wrap it in an O​penAI-compatible server and point a voice agent at it," the plan will fail at the first function call — and that failure will look like a model quality problem when it is a missing training stage.

Then what Tell 1 is, and why you cannot have it

Tell 1 is the reasoning layer of Retell's voice stack, listed on the company homepage under "Developed by Retell Labs" beside an agent harness that assembles models, knowledge and tools. It is not sold as a model. There is no model card, no repository, no context-window figure, no parameter count, no licence and no per-token price published anywhere on Retell's site. The only quantitative public evidence is a row in the Retell vCX Benchmark, which is a leaderboard Retell itself maintains: 88.6% instruction following, 97.2% on the dimension labelled hallucination, 95.4% tool calling, 96.6% colloquial, a 94.45% average, at 72.5 ms median latency and 3.5 cents per minute of model cost.

Whether Tell 1 is a fine-tune of something public, a model trained from scratch, or a small model distilled from a larger one is not disclosed. The 72 ms median suggests a small, fast model rather than a frontier generalist, since that figure is inside the band where round-trip time to a third-party inference stack starts to dominate — but that is reasoning from a latency number, and latency numbers have many causes. What is not inference is the packaging: you get Tell 1 by buying time on Retell's platform, at $0.07 to $0.31 per minute depending on the configuration, and the model is not separable from the telephony, the speech stack and the harness around it.

This is the asymmetry a buyer has to price in. LFM2.5 2.6B Base is yours in a way that no hosted model ever is: you can read its weights, quantise it, ship it in an app, and keep running it if the vendor disappears. Tell 1 is available in a way that no downloadable model is: it is already wired to a phone number, a turn-taking layer and a voice, and the work of making it sound human on a real call has been done by someone else.

The comparison that actually matters: where the latency budget goes

Both of these models live or die on a stopwatch, which is why they get mentioned in the same breath even though they do different jobs. A phone call gives you a budget of roughly 800 ms between the caller finishing a sentence and the agent starting one before the pause reads as a dropped line. That budget pays for speech recognition, the model turn, tool calls, and speech synthesis, in that order.

• Model latency — 72.5 ms median for Tell 1 inside Retell's harness, first of 62 configurations on that benchmark; not published for LFM2.5 2.6B Base, because a base checkpoint has no served product to measure and its quantised throughput depends entirely on your hardware.

• What else is in the 800 ms — for Tell 1, telephony and speech are inside the platform's number, and Retell quotes a typical end-to-end response of around 600 ms; for a self-hosted LFM2.5 stack, ASR, T​TS and the serving layer are all yours to add, and each is a vendor decision.

• Throughput — Liquid's post-trained sibling of this checkpoint runs at 220 tokens per second on an Apple M5 Max and 113 on an AMD Ryzen CPU, and the vendor notes 30 tokens per second is achievable on a phone; a 2.69B model's speed is a function of the machine, not of a service level.

That last line is the whole difference in kind. Tell 1's latency is a promise someone else keeps; LFM2.5's latency is a property of hardware you choose. If your deployment target is a call centre with 200 concurrent lines, the first is what you are buying. If it is a device in a warehouse with no network, the second is the only one that exists.

Fine-tuning is the fork in the road

Here is the decision, stated as plainly as I can. Choose LFM2.5 2.6B Base if you have a task you can describe precisely, examples of it, and a reason not to send those examples to a third party — a classification step inside a call flow, a domain-specific summariser, an on-device router that decides what a request is. The model is small enough that a fine-tune is an afternoon rather than a quarter, the context window is large enough for real documents, and the licence permits commercial use below $10 million in annual revenue, with a separate agreement required at or above that line. That threshold is a procurement fact and belongs in the decision, not in a footnote.

Choose Tell 1 if you are buying a phone agent rather than a model, and specifically if the thing you cannot build is the conversational surface: interruption handling, colloquial phrasing, and a first syllable that arrives fast enough that the caller does not notice a machine. Retell's benchmark says those are the two dimensions Tell 1 leads — colloquial rank 1, latency rank 1 — and says just as clearly that it is not leading on instruction following, grounding or tool calling, where it ranks second, second and fifth respectively. Test those three against your own calls before you standardise, because they are the ones that produce wrong answers rather than merely slower ones.

There is a third option, and it is the one most teams with a real workload end up on: keep the small fine-tune for the part of the task that is narrow and repetitive, and route the hard turns to a larger hosted model. That is exactly the split a routing layer is built for, and it is where our own catalogue fits. Neither Tell 1 nor LFM2.5 2.6B Base is routable through OrcaRouter — we do not host either — so the practical version of that architecture puts the Liquid fine-tune on your own hardware and sends the escalation path to a model we do carry, on one API key, at provider list price with nothing added.

What would change the answer

For Tell 1, three publications would move it from "test inside the platform" to "consider standardising": a model card naming the architecture and the training data, a per-model price so the cost can be separated from the per-minute bundle, and an evaluation run by someone other than Retell. The current record is one row on the vendor's own leaderboard, and a vendor ranking itself first on its own harness is a hypothesis, not a result.

For LFM2.5 2.6B Base, the missing piece is not documentation — it is your own fine-tune. The checkpoint is complete and the licence is readable, which means the only unknown is whether a 2.69B model trained on your data clears the bar on your task. That is a question you can answer this week with one GPU, and no amount of reading will answer it for you. That is the trade in one sentence: Tell 1 saves you the engineering and takes the control; LFM2.5 2.6B Base gives you the control and makes you do the engineering.