Elorian Glimpse: the visual thinking model that looks twice, explained

Why I read this launch closely

I build features and AI agents at eesel, and one request keeps landing on our roadmap: read the picture. In eesel's sales calls this year, technical-product support teams kept asking for an AI that can read the images and diagrams inside their PDFs and the photos customers attach to tickets. One DTC supplement brand doing about 7,000 tickets a month told us part of its product knowledge lived in Loom videos nobody had transcribed.

Most vision models handle that by writing a caption for the image and then reasoning about the caption. That works until the detail that matters wasn't in the caption. Glimpse is the first model I've seen built around fixing exactly that, so I went through the launch post, the Together AI model card, the platform terms and the launch-day reactions. Here's what holds up and what needs a footnote.

What is Elorian Glimpse?

Glimpse is what Elorian calls "a new category of visual thinking model: a system that reasons about the physical world from what it sees." In plain terms, it's a multimodal reasoning model tuned for tasks where the answer is in the image and hard to put into words: how fast something is moving, whether a shot is one continuous pan or two cuts, how many of these objects are actually open.

The company behind it is small and well backed. Elorian says it has $55 million in funding from Striker Ventures, Menlo Ventures and Altimeter, with NVIDIA and Jeff Dean among the other backers. Co-founder and CEO Andrew Dai spent close to 12 years at Google Brain and DeepMind. Elorian says it built Glimpse "as a small team with only a few hundred GPUs, post-trained on an open weights base model."

Here's the spec sheet, with the gaps marked:

Together AI's page also lists it under Chat, Reasoning, Vision and Video, and shows Dedicated as the only deployment type. That matters for budgeting, and I'll come back to it.

How does "visual thinking" work?

Elorian's argument is that today's vision models reason in two steps: first translate the image into language, then reason in text. "No matter how advanced the subsequent reasoning, this chain is fragile," its homepage says, because a lot of visual detail can't be described precisely or briefly.

Glimpse brings the image into the reasoning itself. It "can reason in visual space, revisiting and refining internal visual representations as thinking unfolds." In practice, the launch post shows three moves the model makes mid-answer: zoom into a region, rewatch a short interval at a denser frame rate, and track one feature across time.

The best example is a clip of two birds leaving a door handle while the camera swings. To work out whether the shot cuts or pans, Glimpse first maps the whole 6.13 seconds at 8 frames per second, then rewatches the 0.9-second window that decides the answer at roughly 14 frames per second. The extra looking goes only where the answer is unclear, which is the whole idea.

Two more design choices are worth knowing about:

• Tool use is trained in. Per Together's model card, Glimpse is "trained end to end to use multimodal tools that write code, transform images, and watch videos." That's similar in spirit to Gemini's agentic vision, where the model crops and runs code on images.
• It can split work across subagents. Glimpse "can spawn and coordinate subagents that exchange text, visual artifacts, and internal representations." Passing visual artifacts between agents, rather than text summaries alone, is the unusual part. If you've used subagents in Claude Code, picture the same pattern with images in the handoff.

The chat interface makes all of this visible. As you talk to it, the platform shows what Elorian calls the "visual scratch space": the zooms, rewatches and tracked features, live.

Where it gets precise: counting

Counting sounds trivial until you add lookalikes. Elorian's example asks "How many open pliers are there?" about a photo that also contains closed pliers and scissors. The right answer, per Elorian's reviewed reference, is four. Closed pliers are the right tool in the wrong state, and scissors have two handles and a hinge but are a different tool.

A fair note: Elorian labels this one a reviewed reference answer, "not a recorded model trace." The recorded traces in the post are the train and birds clips, the robot footage and the construction-site count. That distinction is easy to miss and worth keeping in mind when you share the demos.

How good is Glimpse, really?

Every number below comes from Elorian, run at maximum thinking effort with each model's native tool harness. Nobody independent has tested it yet: there's no Artificial Analysis page for Glimpse as of 19 October. With that caveat, here's the launch table.

Bold marks the best score in each row. Read it against GPT-6 Astra and a pattern shows up:

Glimpse's wins are small (0.8 points on chart reasoning, 1.3 on counting) and its losses are bigger (7.2 points on HSS, 7.4 on Video-MME v2). So the honest headline isn't "beats Astra." It's close to Astra on most visual tests at about a sixteenth of the price. That's still a big deal, and it's how Elorian itself frames it: "frontier-level performance at the level of (and sometimes exceeding)" Astra and Claude Opus 5.5.

It also clearly beats the cheap tier. Against Gemini 3.8 Flash, its nearest rival on price, Glimpse wins 11 of the 12 rows, and on WGO Bench it scores 42.70 against 33.99.

A word on the HSS benchmark

HSS, short for Humanity's Sixth Sense, is a new test that Elorian built with Scale AI. It has 522 open-ended questions (288 images and 234 video clips) about what a scene implies but doesn't show: which way the wind is blowing, whether a book would fit on a shelf, whether people are visitors or crew. An answer only counts if it meets every point on a human-written rubric.

Humans score 93.1. The best model on Elorian's leaderboard, GPT 6 Astra, scores 53.6, and Glimpse scores 46.36. Two things are worth holding at once: it's a useful benchmark because it targets a real gap, and it's Elorian's own benchmark, so treat it like any vendor-built test. Credit to Elorian for publishing a test its own model doesn't win. Scale AI being a partner adds some weight to the question set.

What does Elorian Glimpse cost?

The price card is short, because Elorian has published only one line of it:

For context, here's how Elorian's launch table lines up the output prices of the models it compared against:

Those competitor prices are as Elorian listed them; my GPT-6 Astra pricing and Opus 5.5 pricing breakdowns cover the full cards, including caching. Elorian's claim is that Glimpse is 94% cheaper than Astra and 20% cheaper than Gemini 3.8 Flash's introductory rate on both input and output.

Two things change the real bill:

1. Glimpse thinks with a lot of tokens. Elorian says so itself: "Looking that closely takes time, and tokens. Token efficiency is our next highest focus." A low per-token rate on a model that reasons at length can still cost more per task than you expect, so test on your own clips before you budget.
2. Per-task numbers look better than per-token ones. In Elorian's robot planning demo, the whole episode cost $0.035 with Glimpse against $0.249 with Astra, about 7x less. Investor Brian Zhan worked out what that means for a robot checking its cameras every 2 seconds: 1,800 calls per robot-hour, where "the same budget on Astra buys one check every 14s."

On Together, the dedicated-only listing means you're paying for reserved GPUs, not per call. That suits a team with steady volume and a reason to keep traffic on infrastructure it already uses; my Together AI pricing guide explains how dedicated endpoints bill. For a first test, the Elorian API is simpler. A full per-scenario cost breakdown is coming in a separate Glimpse pricing post.

What is it actually good for?

Elorian and Together list the same three clusters of use cases, and they line up with where the benchmarks are strongest.

Robotics data and planning. Glimpse can label teleoperation footage, name and box objects, and split an episode into timestamped pick-and-place events. It can also act as the planner for a vision-language-action robot policy, checking the cameras to decide when a step is done. In the launch demo it planned for Physical Intelligence's π0.5 policy on a LIBERO task. If robotics is your world, compare it with Google's Gemini Robotics 2 and Gemini 4 Argon for robotics.

"Most teleop footage sits unlabelled because segmenting every step by hand is slow and expensive."

Linus Ekenstam, X

Video at scale. Dense captions that capture fine movements and emotional dynamics, tagging short-form and social video for search, and tracking or counting objects across handheld footage. Elorian's puppy demo keeps each puppy's number when the camera pans away and comes back, which is the hard part of counting in video.

Scientific and operational inspection. Reading charts and lab data, counting equipment and inventory while separating lookalikes, and reasoning about physical consequences from a photo. Elorian's construction-site demo counts vehicles in a yard and returns the timestamps it relied on, which is the kind of evidence trail an auditor would want.

What are early users saying?

Launch reactions on X were mostly about the visible process. Andrew Dai's announcement drew over 5,700 likes:

"Spent years watching models ace a single image and completely whiff on anything that moves or changes angle. Today we're fixing that."

Andrew M. Dai, X

One early-access tester ran a counting test on a painting and liked how the model worked, not just the answer:

"Glimpse broke the image into four sections, zoomed in to examine the details, and analyzed the visual clues before reaching its final answer: 5 horses."

Ai Arainz, X

The sharpest pushback came in the replies, and it's the right question to ask of any demo:

"Counting is the easy thing to check, but the footage use is where it gets hard. Asking why something changed means tracking the same object across frames and tying it to a cause, and that is where a lot of vision models start guessing. I'd want to see it on a long clip where the key change happens off to one side of the frame."

Kieren Day, X

Worth noting: several of the most bullish launch posts, including Brian Zhan's robotics thread and Striker's "1/16 the price of Astra" post, come from Elorian's investors. They're useful for the math, but they aren't neutral reviews. I'll update this post once independent testers publish long-clip results.

Where Glimpse falls short

None of these are dealbreakers for a first model, but you should know them before you build on it:

• It's a research preview. Elorian's own wording. Expect the model, limits and price to change.
• No independent benchmarks yet. Every score is Elorian's run, at maximum effort, on a table that includes a benchmark Elorian built.
• Missing basics. No published context window, max output, rate limits, cached-input price or batch tier. For an API buyer, those decide whether it works in production.
• No weights. It's built on an open-weights base, but Glimpse itself is closed. If you need to self-host vision, Nemotron 3.5 Super VL and the DeepSeek V4 Flash vision experiment are the open options.
• Trains on your uploads by default. Elorian's terms license submitted content to "train, test, evaluate, and improve" its models. Paid users can opt out by email; the terms don't give free users that option. The same terms also bar using outputs to train or benchmark another model.
• Text out only. It reads images and video but returns text, and Elorian says robot action outputs are still "work ahead."

Is Glimpse useful for customer support?

This is the question I care about most, so I'll be direct. The vision part is a real fit. Customers send photos of damaged products, screenshots of error messages and screen recordings of bugs. A text model sees "see attached" and nothing else. A model that can count, compare and track what changed in a clip could turn those attachments into answers.

But for a support team today, Glimpse is a component, not a solution. There's no helpdesk integration, no published context window for long ticket threads, and the default training on uploads means you'd want a paid plan before any customer photo goes near it. Helpdesks are also adding their own image reading, like Gorgias AI Agent Vision, and attachment handling has its own limits, like Zendesk's attachment size caps.

The lesson eesel learned the hard way applies to any new model: you can't trust a model to police itself on a live queue. A confident wrong answer about a damaged-goods photo is worse than a slow human one. That's why every eesel rollout is simulated against historical tickets before the AI answers a real customer. My guide to the best support ticket model goes into how to pick the model layer, and AI ticket classification is a lower-risk first job for any new model.

Who should try Elorian Glimpse?

Here's how I'd decide:

• Robotics teams labeling footage or checking a policy's work. This is where Glimpse is strongest on Elorian's table and cheapest per check. Try it first.
• Teams tagging or captioning short video at scale. Strong UGC-VideoCap score and a low output price. Run it against your own clips.
• Inspection and inventory counting. Good on open counting, weaker on product-image counting (CountQA), so test with your actual product photos.
• Long-video question answering. Astra and GPT-6.1 Sol score clearly higher on Video-MME v2. Start there if accuracy matters more than cost.
• Anything that needs weights, contracts or published limits. Wait. Look at open models or at Together's other options until Glimpse leaves preview.

If you're tracking the wider field of new vision-capable models this month, Meta Muse Wonder, Reflection AI Beam and GLM-5.3-Flash are the other launches I've written up.

Try eesel

Glimpse is infrastructure: a model, an API and a per-token bill. To use it on support tickets you'd still need to build the helpdesk connection, the retrieval over your help center, the escalation rules and the testing. eesel is the employee. Our AI helpdesk teammate joins your existing queue in Zendesk, Freshdesk, Gorgias and other helpdesks, learns from your past tickets and docs, and you can replay it against hundreds of your historical tickets before it answers a single customer. That replay is where you catch the confident wrong answer about a customer's photo before the customer does.

If you'd rather work from a terminal, the way you'd test a new model, the eesel CLI drives the same teammate. eesel instructions reads and edits its standing rules, eesel approvals lists actions waiting on a human, and eesel activity shows each run and why it did what it did, so a coding agent like Claude Code can manage your support teammate the same way it manages your repo. If you write content rather than answer tickets, the same roster has an AI blog writer.

It's free to start, no card needed. Try eesel on last month's tickets and see what it would have said, before you price out a single dedicated endpoint. Plans are on the pricing page.