Glimpse API: a reasoning agent for images and video

Short answer: one OpenAI-compatible request

LLMTR is a gateway that gives access to language models from different providers through one OpenAI-compatible API. You call Elorian's Glimpse there with the model id elorian/glimpse on the /v1/chat/completions endpoint at https://llmtr.com/v1. The model takes text, images and video and returns text; its context window on LLMTR is 220,000 tokens.

Elorian announced Glimpse on 16 October 2026 as a research preview and describes it as a visual thinking model that reasons about the physical world from what it sees. According to the announcement, Glimpse works as an agent that uses multimodal tools which write code, transform images and watch videos.

• Elorian, Introducing Glimpse · 2026-10-17

How do you use the Glimpse API?

Create an API key on LLMTR, set the OpenAI client's base_url to https://llmtr.com/v1 and pass elorian/glimpse as the model. The Python example below sends a local photo as a base64 data URL and asks what the sign in it says. Images go in image_url parts, and both base64 data URLs and https addresses are accepted. One request can carry at most 20 images, earlier messages included.

Glimpse works step by step before it replies, so an answer can take from a few seconds to several minutes. Without streaming, give the client a long timeout as the example does (1800 seconds); for longer tasks send stream: true, which keeps the connection open and delivers the answer as it is written. If your connection drops while you wait, the request can still be billed.

The answer arrives in content and the token counts in usage. A finish_reason of length means the visible answer reached the max_tokens limit. The provider states 4,096 tokens as the upper limit for the visible answer, so in that case ask for a shorter answer or split the question.

To give the image by address instead, put its https address in the url field in place of the data URL. On a streamed request, send include_usage inside stream_options and usage arrives in the last chunk. The first chunk arrives once the agent has finished thinking; until then the stream can carry : keep-alive comment lines, which standard SSE clients skip.

An elorian/glimpse call with the OpenAI Python SDK: a local photo is sent as a base64 data URL, then the answer and the token usage are printed.

import base64
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmtr.com/v1",
    api_key=os.environ["LLMTR_API_KEY"],
    timeout=1800,
)

with open("sign.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("ascii")

response = client.chat.completions.create(
    model="elorian/glimpse",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What does the sign in this photo say? Answer in one sentence."},
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}},
            ],
        }
    ],
    reasoning_effort="medium",
    max_tokens=4096,
)

print(response.choices[0].message.content)
print(response.choices[0].finish_reason)
print(response.usage)

Pricing and token counts

Each request is billed from the counts in the response's usage. Per 1M tokens, input costs $0.60, input read from cache $0.06 and output $3.00. max_tokens (or max_completion_tokens) limits only the visible answer; when you send none, 4,096 applies. The agent's steps and reasoning are added on top of that limit as completion_tokens and billed at the output price, so a short answer can report completion_tokens far above max_tokens. Do not estimate the cost from the prompt length; read each response's usage.

Images count as input tokens too. This row has no separate image price; an image's tokens are part of prompt_tokens and billed at the input price. You can see how many tokens an image took in the response's usage.

A worked example: a 3,000-token prompt and a 2,000-token response, reasoning included, cost (3,000 x $0.60 + 2,000 x $3.00) / 1M = $0.0078. The figures are an example; each response's usage gives the real ones.

Reasoning level: low, medium, xhigh

The reasoning_effort field takes low, medium and xhigh; when you send none, medium applies. The same levels can be written as a suffix on the model id: elorian/glimpse:low, elorian/glimpse:medium and elorian/glimpse:max (the same as xhigh). high, minimal and none are refused with a 400. Reasoning cannot be turned off; use low for the least thinking.

The reasoning text is not returned. The number of reasoning tokens spent appears in usage.completion_tokens_details.reasoning_tokens and is part of completion_tokens. How the level affects cost is covered, with worked examples, in a separate article in this series.

Unsupported fields and the cache

Glimpse uses its own tools and cannot return a call to your function. For that reason tools, tool_choice and role: tool messages, a JSON response_format (json_object, json_schema), stop, n above 1, logprobs, logit_bias, background and mode are refused with a 400 before the request reaches the provider. A refused request is not billed. Describe the output format you need in the prompt. Other fields such as seed, user, top_p, presence_penalty, frequency_penalty and metadata are removed from the request and listed in the response's llmtr_dropped_parameters field.

Files the agent creates while it works (charts, tables) are not returned through LLMTR; the answer is text only. Repeated prompt prefixes are cached automatically, with no field to send. The number of tokens read from the cache arrives in usage.prompt_tokens_details.cached_tokens and is part of prompt_tokens. Video goes only by https address and one per request; the details are in the series' video article.

The model card describes Glimpse as a reasoning agent for questions about images and video. If you need an agent loop that calls your own functions, or output bound to a JSON schema, pick another model in the catalog that lists those capabilities; Glimpse refuses both fields.

Data notice and first request

This model is served through a third-party provider. The text, images and videos you send may be stored by the provider and used to train Elorian's models. Do not send sensitive, personal or customer data.

To start, create an account at llmtr.com and top up your balance from Dashboard > Billing. Create a key under Dashboard > API Keys; the raw key is shown only once, so store it in the LLMTR_API_KEY environment variable. Then run the example above. The same key works for the other models in the catalog.

Call Glimpse through LLMTR

Create an account, create an API key and send an image question to https://llmtr.com/v1 with elorian/glimpse.

1. Account and balance. Create an account at llmtr.com and top up your balance from Dashboard > Billing.
2. API key. Create a key under Dashboard > API Keys and store it in the LLMTR_API_KEY environment variable; the raw key is shown only once.
3. First request. In an OpenAI-compatible SDK, set base_url to https://llmtr.com/v1, pass elorian/glimpse as the model and send an image in an image_url part along with your question.

Frequently asked questions

How much does the Glimpse API cost?

On LLMTR, per 1M tokens: $0.60 input, $0.06 input read from cache and $3.00 output. The agent's steps and reasoning count in completion_tokens and are billed at the output price.

Can I use Glimpse with the OpenAI SDK?

Yes. Set base_url to https://llmtr.com/v1, use your LLMTR key as the API key and pass elorian/glimpse as the model. Requests go to the /v1/chat/completions endpoint.

Does Glimpse support function calling?

No. Glimpse uses its own tools and cannot return a call to your function; a request with tools or tool_choice is refused with a 400 and not billed. A JSON response_format is not supported either; describe the output format in the prompt.

Related posts

• Video analysis API: asking Glimpse about a video
• Glimpse reasoning_effort and cost: low, medium, xhigh
• Models added to LLMTR in October 2026: facts and guide

• Glimpse model
• Elorian Glimpse documentation
• Chat Completions guide
• Pricing