Pricing

Dollar and token based pricing for VLM Run Orion agents.

VLM Run Orion agents are priced in US dollars. Every response tells you exactly what a run cost.

What makes up your cost

Every run’s cost comes from two components:

• Fixed-price tools: GPU and API actions charged at a flat rate per unit.
  • Examples: image generation and editing, OCR and layout, and video generation and editing.
• Token-billed model usage: Orion reasoning and LLM-backed tools charged by input and output tokens.
  • Examples: image captioning, document extraction, and video analysis.

A single run typically combines both: the agent reasons (tokens), calls a tool or two, and returns a result with the total attached.

How a run adds up

Your cost is the sum of the two components, then scaled by your service tier:

run cost   = token-billed usage + fixed-price tools
total cost = run cost × service-tier multiplier

The per-span cost ledger

Every Orion 2 run returns a per-span cost ledger: a line item for each billable action, priced as either a fixed-price tool or token-billed usage. This is where the two components become concrete, so you can see exactly what drove a run’s cost.

Span Type	Priced By	Example
mllm	Model tokens (input + cached + output)	One LLM reasoning turn
execute_code	Fixed price ($0.001/call)	One sandbox code execution
tool (fixed-price)	Fixed dollar price	vlmrun.image.generate, vlmrun.image.segment
tool (token-billed)	Model tokens consumed	vlmrun.document.extract, vlmrun.video.caption

The multiplier is applied once, at the run level (effective_cost = SUM(span.cost) × multiplier), and the response hands you the totals directly, so you never have to add up spans yourself:

Response Field	What It Tells You
cost_dollars	What you actually pay, after the service-tier multiplier
standard_cost_dollars	Baseline cost at the standard tier
savings_dollars	Amount saved versus standard (positive on flex)
service_tier	Which delivery tier ran the request

An example ledger

Here is an illustrative, ballpark example for a single document processed by Orion 2 Auto in program mode. Actual token usage and cost vary with the document and the requested output.

Span	Billed Usage	Cost
execute_code	Fixed price	$0.0010
vlmrun.document.extract	6,000 input + 1,000 output tokens	$0.0020
vlmrun.document.grounding	Fixed price	$0.0010
Total	2 fixed-price spans, 7,000 tokens	$0.0040

Running the generated program contributes the fixed execute_code charge, extraction is billed on the tokens it consumed, and grounding adds a second fixed charge. The run total is the sum of the three spans, before the service-tier multiplier is applied.

For the full rate card behind each span, see the Pricing Reference.

Choose your tiers

Two independent dials control quality and delivery. Quality picks the models; the service tier scales the whole bill.

Model quality

Use Fast, Auto, or Pro as a curated default, or pass a specific model ID to pin a backbone. Token rates vary by model; see the Pricing Reference for the full rate card.

Tier	Model ID	When to Use
Fast	vlmrun-orion-2:fast	Speed and cost-efficiency. Lighter models, fastest processing.
Auto	vlmrun-orion-2:auto	Recommended default. Uses Fast tools, upgrades to Pro for complex tasks.
Pro	vlmrun-orion-2:pro	Maximum quality. More powerful models, higher cost, longer processing.

VLM Run hosts additional Orion-2 backbones (open-weight and frontier models) beyond these three tiers. Pass any supported model ID on chat completions or agent execute to pin a backbone. Per-model input/output rates are in the Pricing Reference.

Service tiers

Same models, same tools, same output: the service tier only changes how quickly the result comes back. Batches, backfills, and eval sweeps that nobody is waiting on cost half as much at flex; save the 1.8× priority premium for when a person is waiting on the response.

Tier	Multiplier	Cost Effect	Best For
standard (default)	1.0×	Base USD price	Most production workloads.
flex	0.5×	50% of standard	Background jobs with no one waiting: overnight batches, backfills.
priority	1.8×	180% of standard	Interactive or blocking workflows where latency is user-visible.

A $1.00 standard run costs $0.50 at flex and $1.80 at priority. Set it per request:

Python

# Flex tier: 50% discount on total agent cost
response = client.agent.execute(
    name="my-orion-agent",
    inputs={...},
    service_tier="flex",
)
# response.usage.cost_dollars   → effective cost
# response.usage.savings_dollars → amount saved

What a run actually costs

See the following worked examples. The cost_dollars field in the response is always the exact figure.

Image segmentation + generation

Component	Type	Auto
Segment objects in 1 image	Fixed-price (1×)	$0.01
Generate 1 image	Fixed-price (1×)	$0.04
LLM orchestration	Tokens (approx.)	~$0.01
Estimated total		~$0.06

Fixed-price tools dominate; token orchestration is a small share.

50-page document: OCR + extraction with Flex

Component	Type	Standard Cost
OCR & layout (50 pp)	Fixed-price: $0.01/page	$0.50
Parse / extract data	Token-billed	Varies by complexity
LLM orchestration	Tokens (approx.)	~$0.02–$0.05
Estimated standard subtotal		~$0.52–$0.55
Flex service tier	0.5× multiplier	× 0.5
Estimated total with Flex		~$0.26–$0.28

Full rates

Pricing Reference

Every fixed-price tool and per-model token rate, plus the per-span ledger and cost formula.

Gateway Pricing

Per-token rates for VLM Run Gateway models, metered on every request.