Glimpse Vision Model Priced at Just 6% of GPT-6 Astra, Yet Loses 6 Categories on Its Own Benchmark

On October 16, Elorian released its first model, Glimpse, a research preview built around "visual thinking." Pricing is $0.60 per million input tokens and $3 per million output tokens—by Elorian's own comparison, 94% cheaper than GPT-6 Astra's $10/$50.

But the 12-row benchmark table included in the same launch post tells another story: against Astra, Glimpse wins only 4 rows, ties 1, and loses 6. The remaining row has no Astra score. If your workload involves reading screenshots, charts, product photos, or videos, look at those 6 losing rows before deciding whether to migrate.

What Glimpse Actually Is

Elorian is a Palo Alto startup that, according to TechCrunch, raised a $55 million seed round before it even had a product, at a $300 million valuation, with investors including Nvidia and Google's Jeff Dean. CEO Andrew Dai was previously a researcher at Google DeepMind.

Glimpse is built on top of an "open-weight foundation model"—the launch post doesn't name which one—and was post-trained by "a small team with only a few hundred GPUs." The post doesn't specify a license or a context window.

There are two ways to access it: Elorian's own platform offers an API and a chat interface; it's also listed on OpenRouter under the model name elorian/glimpse, where endpoint data shows the provider is Together, a 262,144-token context, support for text, image, and video input with text output, and a cached input read price of $0.06 per million tokens.

On positioning, TechCrunch places it above lightweight models like Haiku and Luna, and below mid-tier models like Sonnet and Sol. Elorian also claims it's 20% cheaper than Gemini 3.8 Flash's introductory pricing ($0.75 and $3.75).

Open-weight foundation model refers to a base model whose parameters are publicly downloadable and allow third parties to deploy or fine-tune on their own—typical examples include the Llama series, Mistral, and Qwen. It's not fully equivalent to "open source": open-weight releases usually only publish the trained parameters, not the training data, code, or training details, and licenses may carry commercial restrictions. Glimpse chose to post-train on top of an open-weight model, which saves the enormous compute of pretraining from scratch—a small team with a few hundred GPUs can manage it. The cost is that the model's capability ceiling and license obligations are inherited from the base, and the launch post names neither the base model nor the license—exactly the key information you must confirm with the vendor before migrating to production.

Post-training refers to using supervised fine-tuning, preference optimization, or reinforcement learning on top of a pretrained foundation model to give it specific capabilities or alignment goals. Glimpse's claimed end-to-end multimodal tool-use ability was injected through post-training, not something the base model had natively.

Core Idea: Going Back to the Image Itself

Most multimodal models work by converting an image into tokens once, then reasoning in text space. Glimpse takes a different approach—during its reasoning process, it repeatedly returns to the original image. It can crop a region, extract a frame from a video, and even run code to measure what it sees. Elorian calls this a "visual scratchpad."

The launch post says the model is trained end-to-end to use multimodal tools: writing code, transforming images, watching videos, and spawning sub-agents, passing text, visual artifacts, and internal representations between them. TechCrunch notes that OpenAI added similar crop-and-zoom capabilities to its o-series models back in 2025, and Elorian's claim is that it has built this behavior into the entire model.

This is essentially an agent loop: look, call a tool, look again. That also means a single answer may involve multiple internal passes over the same image, and each one is billed.

Reading the Whole Table

Here are the complete results of Glimpse versus GPT-6 Astra, from Elorian's launch post:

Benchmark	Glimpse	GPT-6 Astra	Result
WGO Bench (manipulation event understanding)	42.70	39.42	Win
CharXiv-R (scientific charts)	92.90	92.10	Win
UGC-VideoCap (video captioning)	82.66	80.32	Win
FSC-147 (open-vocabulary counting)	83.36	82.02	Win
ERQA (embodied spatial reasoning)	83.75	83.75	Tie
BabyVision	95.36	97.68	Loss
HSS (image + video)	46.36	53.6	Loss
DREAM-1K (dense video captioning)	76.04	79.05	Loss
TOMATO (temporal reasoning)	93.60	96.02	Loss
Video-MME v2 (with subtitles)	56.68	64.06	Loss
CountQA (product image counting)	82.66	86.42	Loss
E.T. Bench	63.55	N/A	Not applicable

The launch post also includes several caveats. Unless otherwise stated, all models ran at their highest thinking effort in their native agent harness, with Code Interpreter enabled for OpenAI and Anthropic models. In the video-related rows, Sol and Opus 5.5 ran at high effort because Elorian didn't have their max-effort results; the HSS row also includes data pulled directly from papers rather than newly run. On CharXiv-R, Claude Opus 5.5 leads with 93.40, ahead of both models; on Video-MME v2, GPT-6.1 Sol leads with 65.27.

All numbers come from Elorian. TechCrunch labels them as "Elorian's evaluations" and doesn't cite any independent testing. I haven't run Glimpse myself either.

The fair reading is this: a small team's first model is within a few points of frontier models on most rows, leads on four, and costs a fraction of the price. But if your workload is video QA, cross-image-and-video scene understanding, or product image counting, its own table shows Astra answers better. The two biggest gaps—HSS and Video-MME v2—are both around 7 points.

Agent harness refers to the orchestration system wrapped around a model that decides when to call tools, how to parse tool returns, and how to loop through multiple rounds until it produces a final answer. The same model can score noticeably differently under different harnesses, so harness consistency is critical when comparing across models. The post mentions "native agent harness" for each and enabling Code Interpreter for OpenAI and Anthropic models, meaning each vendor used different tool sets and loop strategies—so the fairness of the comparison is inherently limited.

Effort / thinking effort is a common adjustable parameter on current reasoning models that controls how much internal reasoning the model does before answering; higher effort is usually more accurate but consumes more tokens and adds latency. The benchmark table uses different effort settings for different models (some video rows switched to high effort due to missing max-effort data), which distorts cross-model comparison and is a reminder to readers: when reproducing, fix the effort level at what you'd actually use.

Per-Token Price Is Not Per-Task Price

A 94% per-token discount equals a 94% bill discount only if both models consume the same number of tokens. Glimpse's design actively spends more tokens. Every crop, frame extraction, and code execution is extra inference—Elorian acknowledges this in the launch post: careful review "takes time and tokens," and "token efficiency is our next top priority."

The post gives one per-task number: on a single LIBERO robot planning task, Glimpse costs $0.035 per episode versus $0.249 for GPT-6 Astra. But that's a vendor-picked task, and one episode says nothing about your workload's average. Real numbers depend on your own images and effort settings.

Cached input read pricing refers to the discounted rate charged when a repeated input prefix (such as a long system prompt or a fixed set of images) hits the cache; Glimpse's price on OpenRouter is $0.06 per million tokens, about one-tenth of the normal input price. For scenarios that repeatedly send the same batch of images or long contexts, caching can significantly reduce costs. But whether the cache hits depends on whether the request prefix is stable, and Glimpse's internal repeated reviews of the original image don't necessarily go through the cache path—when testing, check the usage field in the response to see actual hit rates.

Test It on Your Own Images First

Because OpenRouter uses the chat completions format, the first call is simple. Image input goes in the content array alongside text:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elorian/glimpse",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text",
         "text": "How many pallets are in this photo?"},
        {"type": "image_url",
         "image_url": {"url": "https://example.com/yard.jpg"}}
      ]
    }]
  }'

Before routing real traffic over, run a small comparison:

1. Collect 30 to 50 images or clips from your own product, each with a known correct answer.
2. Run them through both Glimpse and your current model, using the effort setting you'd actually use. Elorian's published scores mostly used each model's highest effort.
3. Record accuracy, the usage token count in each response, and actual latency.
4. Divide total cost by the number of correct answers. That's the price you should compare, not the sticker price.

Treat it as what Elorian itself says it is: a research preview. The launch post names robot control and calibrated reconstruction as unfinished work, and there's no license. Keep a fallback model until your own numbers speak.

A Few Things Worth Noting

Benchmark limitations. This table was entirely run and reported by the vendor, with no third-party reproduction. The HSS row mixes in paper data, video rows use non-maximum effort, and different models have inconsistent harnesses and tool permissions. Cross-model comparison is inherently limited in fairness—especially for your specific scenario.

The billing structure of the visual scratchpad. Folding the agent loop inside the model saves an orchestration layer but makes token consumption opaque. At the API level you can't see how many times it cropped internally or how many code snippets it ran—you can only infer from the usage field. For cost-sensitive scenarios, this needs close attention during testing.

The weight of the words "research preview." No license, no formal context window specification, robot control not yet done—these aren't minor blemishes. For production systems planning to migrate an image pipeline over, these are all question marks.

The common trap of price narratives. "Only 6% of the competitor's price" is a catchy claim, but per-token price and per-task cost are two different things. Glimpse's design of actively spending more tokens means the real bill discount will be less than 94%, and how much less depends on task type. The vendor's single-task number is a reference, not something to extrapolate.

For developers, Glimpse is worth adding to your test list: if your image tasks lean toward chart understanding, video captioning, and open-vocabulary counting—the rows it wins—and unit price is sensitive, it's worth a try. But if your core scenario falls in video QA or cross-modal scene understanding, its own data is telling you to hold off. The final answer still has to come from your own 30 to 50 images.

One-line Summary

Elorian's first model Glimpse touts 94% lower pricing for visual thinking, but loses more than it wins against Astra on its own benchmark.

Paragraph Summary

Elorian released Glimpse, a research-preview multimodal model priced at $0.60 input and $3 output per million tokens—roughly 94% cheaper than GPT-6 Astra. Its core design is a "visual scratchpad": during reasoning it repeatedly crops images, extracts video frames, and runs code, effectively folding an agent loop inside the model. But the 12-row benchmark in its launch post shows it only wins 4 rows against Astra, ties 1, and loses 6—mostly in video QA, cross-image-video scene understanding, and product image counting, with the largest gaps around 7 points. All data is vendor-run with no third-party reproduction, and some rows mix in paper data or use non-maximum effort settings. The article stresses that per-token price is not per-task cost, and Glimpse actively spends more tokens, so it recommends testing accuracy and cost-per-correct-answer on your own 30 to 50 images before deciding whether to migrate.