Glimpse vs LFM2.5 2.6B Base: One of These Cannot Answer a Question

Glimpse is Elorian's visual-reasoning research preview, released on 16 October 2026, and its selling point is a behaviour: while it is thinking it can go back to the image or the video, re-scan a 0.9-second interval at a denser frame rate, zoom into a region, or track one feature across time, and only then answer. LFM2.5 2.6B Base is a 2.69-billion-parameter checkpoint Liquid AI published on 4 August 2026 under the LFM Open License v1.0, and it has no instruction tuning at all — it was never trained to answer anything. Hand it a question and it continues the text, plausibly, in the register of whatever came before. That is not a defect or a missing release; it is the specification. So the first thing to say about this pairing is that it is not a matchup between two models of different quality. It is a matchup between a capability you rent and a raw material you train, and the single fact that decides between them is whether the work you have is a question or a dataset.

Everything below follows from that, including the fact that only one of these two has a benchmark table — and it is not the one a reader would guess.

Two objects, described without the marketing

Glimpse has no downloadable artefact. Elorian publishes no parameter count, no architecture, no context window, and no name for the open-weights base model it says it was post-trained on. What exists is an API and a chat interface with a free sign-up, a price of $0.60 per million input tokens and $3.00 per million output, and a set of worked traces showing the model revisiting visual evidence mid-thought. Its visual scratch space — the surface where it re-examines what it saw — is the product.

LFM2.5 2.6B Base is the exact inverse. It is a file. Thirty layers, of which 22 are dual-gated short-convolution blocks and 8 are grouped-query attention; roughly 34 trillion training tokens across 16 languages; a 131,072-token context window; a quantised build around 1.67 GB. It is text-only, it is dense, and it is deliberately unscored, because scoring a base checkpoint on instruction-following benchmarks would measure the absence of fine-tuning rather than the quality of the substrate.

• What you receive — Glimpse: an API key and a hosted endpoint. LFM2.5 2.6B Base: weights, a tokenizer and a licence.

• Modality — Glimpse: images and video in, with re-entrant sampling over time. LFM2.5 2.6B Base: text in, text out.

• Price — Glimpse $0.60 / $3.00 per million tokens, vendor-published. LFM2.5 2.6B Base: nothing per call; you supply the hardware.

• Published size — undisclosed for Glimpse, which is unusual for a hosted model and is itself the disclosure. 2.69B dense for LFM2.5 2.6B Base, every weight visible in the repository.

• Out-of-the-box behaviour — Glimpse answers questions about what it has looked at. LFM2.5 2.6B Base continues your text, because that is what pretraining produces.

• Licence — Glimpse is a hosted preview under Elorian's terms. LFM Open License v1.0, free below $10M annual revenue and requiring a separate licence at or above that line.

Why only one of these has a scorecard

This is the part that reads backwards. The model with no weights, no disclosed size and no independent evaluation publishes a twelve-row benchmark table against GPT-6 Astra. The model with every weight published and a fully documented architecture publishes nothing.

Both blanks are rational, and they mean opposite things, so it is worth separating them.

Glimpse's table is vendor-reported and unreproduced — Elorian's own numbers, against its own choice of rivals, run at the model's highest thinking effort with its native agent harness, with a footnote disclosing that several competitors were run below their maximum effort and that the HSS row mixes in paper-reported figures from other labs. Read as a claim about direction it is informative; read as a score it is not yet evidence, because nobody outside the company has run it. And where the table is most useful is where it is unflattering: Glimpse scores 46.36 on Humanity's Sixth Sense against Astra's 53.6, on a benchmark Elorian itself built with Scale AI. The rewind buys perception — counting, chart reading, tracking an object through motion — and does not buy inference about what a scene implies.

LFM2.5 2.6B Base's blank is different in kind. There is nothing to score. A base checkpoint has no behaviour; it has a distribution. Liquid AI benchmarks the post-trained sibling in the family instead, which is the correct engineering decision and tells you precisely zero about whether the substrate will suit your task.

That asymmetry has a practical consequence. For Glimpse, the evaluation question is "will the vendor's claim survive my clip." For LFM2.5 2.6B Base, the evaluation question is "can I train this into something that works" — and the second question is answerable today, by you, for the price of a download. The 1.67 GB build fits on a laptop; the training loop is the work.

The units do not convert, so convert them by hand

A per-token price and a free download cannot be compared directly, which is where most comparisons of this shape quietly cheat. The honest way is to pick a task and price both routes.

Take a narrow, high-volume job that a small fine-tune is genuinely good at: reading a fixed document type and emitting structured JSON, run 50 million tokens a month, roughly half in and half out. On Glimpse that is about $90 a month — $15 of input at $0.60 per million, $75 of output at $3.00 — plus the engineering time to prompt and validate it. On LFM2.5 2.6B Base the inference is free, and the bill moves entirely to the front: assembling a few thousand labelled examples, one training run on your own card, an evaluation set, and a re-run every time the document format shifts.

Two things fall out of that arithmetic that are easy to miss.

The first is that the fine-tune wins on cost only above a volume threshold, and the threshold is set by how much engineering your team can absorb rather than by anything Liquid AI publishes. A team with no training capacity has no break-even point at all on that side of the comparison, which is a real and frequently decisive fact.

The second is that Glimpse's own price claims are aimed somewhere else entirely. Elorian frames $0.60/$3.00 as 94% below GPT-6 Astra at $10/$50 and 85% below Claude Opus 5.5 at $4/$20. Against frontier flagships Glimpse is cheap. Against the small-model end — a 2.6B checkpoint you own, or a volume lane like A​libaba's Qwen3.8-Flash at $0.15/$0.47 — it is the expensive side of the comparison, and the article beside this one on Q​wen 3.8 works that out with the real rate cards. A vendor's discount claim is always relative to the comparison set the vendor chose.

How you would actually run the test

The comparison above is only worth anything if it is cheap to run, and the practical obstacle is that the two sides live in different systems: a hosted endpoint with one key, and a training loop that ends in a model you have to serve somewhere. Making that into an A/B test on your own workload is where a routing layer earns its place, and it is the same argument whether you are comparing a fine-tune to an API or two APIs to each other.

OrcaRouter puts a text endpoint and every published model side by side behind one key — 200-plus models, provider list price passed through with nothing added per token, one bill, and automatic failover so that a provider's bad afternoon does not become your evaluation's bad afternoon. Neither Glimpse nor LFM2.5 2.6B Base is on that catalogue, and no LFM2.5 variant is: Glimpse comes from Elorian's own API and chat interface, and the Liquid checkpoint comes from Liquid AI, both of them things you obtain directly. What the routing layer changes is the control group. When the question is "is my fine-tune actually better than just calling something," you want the something to be a config change rather than a procurement cycle, because the experiment you can run this afternoon is the only one that produces a number.

Where fine-tuning cannot get you, at any size

This is the part of the comparison that does not resolve into a cost question, and it is the reason these two are not substitutes in either direction.

Glimpse's capability is temporal and visual. Object identity across a cut, an event inside a sub-second window, a count that changes when something occludes — a rewind mechanism addresses those directly, and the traces show whether the model actually re-scanned the interval that mattered. No amount of fine-tuning a 2.69B text-only checkpoint produces that behaviour, because the substrate has no video input and no mechanism for spending extra compute on a specific interval after a first pass. You cannot train your way into an architecture you did not build.

The reverse holds just as firmly. A hosted preview whose parameter count, context window and base model are all undisclosed is not something you can ship inside a regulated product, run air-gapped, or guarantee the availability of. And a research preview's rate card can move at any time, which is fine for a trial and awkward for a cost model.

So the honest summary is not that one is better. It is that a team with a text task and a dataset should be looking at the checkpoint, a team with a temporal visual question should be looking at the preview, and a team that has neither has no reason to be comparing them yet.

Three conditions, and what each implies

If your task is narrow, text-only, and you have — or can buy — a few thousand labelled examples, LFM2.5 2.6B Base is the more valuable object, because you end up owning the artefact and paying electricity instead of tokens. Download the 1.67 GB build first and confirm the thing runs on your hardware before you plan anything around it. That step costs an afternoon.

If your failure mode is temporal — the model looked but did not look closely enough — Glimpse is the first hosted model whose stated mechanism aims at that directly, and the free sign-up makes the test cheap. Run your own clip, then read the scratch space: if it never re-scanned the interval that decided the answer, you have learned something about your pipeline and not only about the model.

If you do not yet know which of those two you are, the order of operations is settled: run the hosted model first, because it answers in an afternoon what a fine-tuning project answers in a month. The substrate stays available. It will still be a 1.67 GB download next quarter, and the only thing you will have spent is the time you would otherwise have spent assembling a dataset for a task an API call might have covered.

None of that is hypothetical: the documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive, where each entry carries its own sources, severity, confidence grade and disputed flag.