Financial infrastructure for AI inference.

tiers is an LLM routing and governance layer — one endpoint between your application and every model provider. It classifies each call, routes to the cheapest model that clears the quality bar, enforces policy, verifies the output, and returns a signed receipt.

Talk to the founders See the integration

The same workload. 87% less spend. Every result verified.

live

Reference workload, today¹

DEFAULT MODEL

$0.00

GOVERNED

$0.00

Avoided spend $0.00 · 87% below the default path

Latest settlement receipt

call_9f27e4 · summarize filing

route claude-haiku-4.5 · settled $0.0003

verification passed

sig 30:82:01:0a:02:82:01:01:00:c8…

Switch to Ungoverned. The requests stay the same. The quality bar stays the same. Only the economics change.

models in the catalog

providers

87%¹

verified cost reduction

signed receipt per call

request→ gate→ aiglos→ forge→ ulmo→ response + receipt

Some work never needs a model. tiers resolves it locally, with no token bill and no provider exposure.

A router chooses a model. tiers governs the outcome.

Every production AI call creates four questions: where should it run, is it allowed, did it work, and can you prove what happened? Gateways answer the first. Dashboards arrive after the fact. tiers answers all four inside the call path.

capability

gateways & routers

observability

tiers

Routecheapest model that clears the bar

✓

Inspecttools, requests, injections, distillation

✓

Verifyoutput against task, before consumption

watch only

✓

Settlesigned receipt, hash-chained audit

✓

Learnevery call retrains routing, security, quality

✓

Production controlwhat the system is trusted to run

traffic

dashboards

agents and workflows

Observability tells you what happened after the call. A gateway moves traffic and walks away. tiers prices, inspects, verifies, and settles the call before the output reaches your system. That is the difference between moving traffic and governing production.

Four capabilities. One governed call.

Each one solves a different failure mode. Together they turn inference into infrastructure.

Gate

Finds the lowest-cost execution path that meets the task's quality, latency, and policy requirements.

classify ticket → gpt-5.4-mini · $0.0001

refactor module → claude-sonnet-4.6 · $0.0041

compute 18% of 34,200 → local · $0.0000

Aiglos

Enforces policy inside the session, before tools, network requests, and subprocesses execute.

tool: read_file(config.yaml) · clean

blocked · embedded instruction in retrieved page

blocked · distillation probe across session

sovereign routing · residency enforced per call

Forge

Checks the result against the task, schema, and rolling quality baseline before release.

schema match · pass

task alignment · pass

quality vs rolling baseline · pass (no drift)

Ulmo

Settles the call into one tamper-evident record: route, cost, policy, verification, and outcome.

call_9f27e4 settled · $0.0003

route + scan + verification recorded

sig 30:82:01:0a:02:82:01:01:00:c8…

Every call makes the system better.

Routing without verification is guesswork. Verification without settlement is a dashboard. tiers connects the signals, so every governed outcome improves the next decision.

1Routes learn from outcomes. Models earn traffic by clearing real task-level quality bars.
2Quality bars become task-specific. The system learns what good looks like for each class of work.
3Repeated context gets cheaper. Caching, compression, and reuse reduce the cost of long-running agents.
4Deterministic work leaves the model path. The system learns which tasks never needed inference.
5Session policy gets sharper. Tool use, data movement, and agent behavior are evaluated in context.
6Weak routes lose traffic. Provider drift, failed verification, and poor economics change the next route.
7Receipts become infrastructure. Every call adds to the audit trail, the control plane, and the underwriting record.

The first call is governed by policy. The thousandth is governed by everything the system learned before it. On the reference workload, governed spend fell from $47.00 to $6.10 per day while maintaining the quality bar.¹

Reference workload: 90-day learning curve; final 14 days signed against the default-model counterfactual

Ungoverned baseline ($47/day) Governed spend ($6/day by day 90) Eliminated waste

The same work. 87% less spend.

tiers did not reach this result by lowering the quality bar. It reached it by paying the right price for each unit of work: smaller models where they were sufficient, deterministic execution where a model was unnecessary, and verification before an output entered production.¹

WHAT TIERS REMOVED FROM THE REFERENCE WORKLOAD

Frontier model on tasks a smaller model handles40%

LLM calls that were deterministic work17%

Repeated computation, no cache15%

Unverified outputs consumed and reworked9%

Overpayment vs. cheapest model at quality6%

Useful inference13%

WHAT THE SAME BUDGET CAN DO

Same $50M budget, governed$385M of intelligence

Teams that couldn’t afford AI, now can7.7× more

Workflows too expensive to automatenow viable

Outputs checked before useverified by default

Every decision traceableauditable by default

The point is not a smaller AI budget. It is more useful work from the same one. Every dollar removed from waste becomes another task, another workflow, or another team that can use intelligence.

One endpoint. A live market behind it.

Models differ by capability, latency, geography, price, and risk. List prices across production models span a 643x range.² tiers clears each task against those constraints, then records how the decision was made.

ModelProviderRouted share¹List output $ / 1M²

claude-haiku-4.5Anthropic22.4%$5.00

gpt-5.4-miniOpenAI18.1%$4.50

local deterministictiers16.9%$0.00

gemini-3-flashGoogle12.7%$3.00

claude-sonnet-4.6Anthropic10.3%$15.00

grok-4.5xAI8.6%$6.00

gpt-5.6-solOpenAI6.2%$30.00

claude-fable-5Anthropic2.1%$50.00

OpenAIAnthropicGoogleMetaDeepSeekMistralxAIAmazonCohereQwenKimiPerplexityAI21Local

tiers has no model to favor and no token markup to protect. We operate no foundation models, sell no tokens, retain no prompt or output content, and are paid to govern the call, not steer it to a provider.

Every agent action contains two transactions: a cognition transaction that decides what to do, and a value transaction that does it. The second has financial infrastructure. tiers is building it for the first.

The market has reached the same conclusion.

The largest AI buyers are asking for lower cost, clearer control, and an independent exchange between applications and models.³

“There’s going to be a hot new company that’s going to come along and say this: I’m going to sit between you and Anthropic and OpenAI, and I’m going to make sure that you only need their tokens when you actually need them.”

Marc Benioff, Chair and CEO, Salesforce · All-In, May 2026

Change one line. Govern every call.

Point your existing SDK at tiers. Keep your provider relationships, your keys, and your application code.

WITHOUT TIERS

$0.0000

WITH TIERS

$0.0000

SAVED

$0.0000

you@prod ~ tiers session

GOVERNED

Simulated session using verified reference-workload figures.¹ When the proxy is live, the same component runs against your tiers endpoint and nothing changes except the transport. Open the full demo.

Add the endpoint. OpenAI-compatible and Anthropic-compatible, the two wire formats nearly every SDK speaks. Behind the endpoint, routing spans all 56 models and 14 providers.

Keep your stack. Your prompts, provider keys, and application logic remain yours.

See the control plane. Routes, policy decisions, verification, cost, and receipts appear from the first session.

Aligned by design.

tiers charges 2% of governed spend. No markup on model costs. No seats. No minimums. When your inference bill falls, our fee falls with it.

fee on governed spend

markup on model costs

minimum commitment

Built for the people accountable for AI.

Engineering gets control. Finance gets attribution. Security gets enforcement. Leadership gets proof.

Engineering Finance Security & Compliance AI Leadership Executive

Signed receipt on every call Tamper-evident audit trail Sovereign routing available Bring your own provider keys

Put every AI call under control.

One endpoint across every model. Lower cost, enforced policy, verified outputs, and a signed receipt for every decision. And the same budget operates 7.7x the intelligence.¹

Talk to the founders See it for your role

Common questions.

What is AI inference governance?

AI inference governance is the practice of controlling, auditing, and optimising every call your application makes to a large language model. It covers four decisions inside every call: which model should handle this task (routing), is this request policy-compliant (inspection), did the model produce a correct result (verification), and can you prove what happened (settlement). tiers handles all four inside the call path so applications receive a governed, signed result rather than a raw model response.

How do I reduce AI API costs?

Most AI API overspend comes from four sources: using a frontier model for tasks a smaller model handles equally well (40% of reference workload cost), sending deterministic work to a model at all (17%), not caching repeated computation (15%), and consuming unverified outputs that require rework (9%). tiers addresses all four: it routes each task to the cheapest model that clears a task-specific quality bar, resolves deterministic work locally at $0.0000, caches repeated context, and verifies outputs before they reach your application. On the reference workload this produced an 87% cost reduction while maintaining the quality bar.

What is the difference between an AI gateway and tiers?

An AI gateway routes traffic and walks away: it selects a model and forwards the call, but does not inspect the request for policy violations, verify the output against the task, or produce a signed record of the decision. tiers does all four: it routes (Gate), inspects before execution (Aiglos), verifies before the output reaches your application (Forge), and settles with a signed receipt (Ulmo). A gateway answers where to send the call. tiers also answers whether the call was allowed, whether the result was correct, and whether you can prove it.

Why use tiers instead of calling model APIs directly?

Calling a model API directly commits your application to one provider, one model, and one price for every request. There is no automatic fallback when a model fails, no routing to cheaper alternatives for simpler tasks, no policy enforcement before the call executes, no verification that the output is correct, and no auditable record of what happened. tiers adds all four inside the existing call path with one line of code — your SDK, prompts, and application logic stay unchanged. On the reference workload: 87% lower costs, pre-execution policy enforcement, verified outputs before they reach your application, and a signed receipt for every call.

How does tiers route AI calls to cheaper models?

tiers classifies each incoming request into a task-and-complexity cell and routes it to the cheapest model in the catalog that has cleared the quality bar for that cell. The routing learns from outcomes: every verified call improves the next routing decision. Deterministic tasks — math, date logic, template fills — are resolved locally at $0.0000 without reaching any model. The catalog covers 56 models across 14 providers including OpenAI, Anthropic, Google, Meta, DeepSeek, Mistral, xAI, and others.

What is a signed settlement receipt?

A signed settlement receipt is a tamper-evident record that tiers produces for every governed call. It contains the route taken, the model used, the cost at list price and governed price, the policy decision, the verification result, and a cryptographic signature. Receipts are hash-chained so any alteration to a historical record is detectable. They are exportable and form the audit trail for compliance, FinOps attribution, and underwriting.

How many providers does tiers support?

56 models across 14 providers: OpenAI, Anthropic, Google, Meta, DeepSeek, Mistral, xAI, Amazon, Cohere, Qwen, Kimi, Perplexity, AI21, and local deterministic execution. The endpoint speaks both OpenAI and Anthropic wire formats, the two protocols nearly every SDK already uses. Integration is one line: set your client's base_url to the tiers endpoint and pass your tiers key. Your provider keys and contracts stay yours.

How much does tiers cost?

tiers charges 2% of governed spend — the total cost of model calls at the provider's list price. There is no per-token markup, no seat fee, and no minimum commitment. Because tiers reduces governed spend by an average of 83% across measured cohorts, the 2% fee is applied to a significantly smaller number than the original inference bill.

How do I integrate tiers into an existing application?

Integration requires one line of code: set the base_url of your OpenAI or Anthropic SDK client to the tiers endpoint and replace your provider API key with your tiers key. Everything else — your prompts, application logic, and provider relationships — stays the same. For OpenAI: base_url="https://YOUR_TIERS_ENDPOINT/v1". For Anthropic: base_url="https://YOUR_TIERS_ENDPOINT". For direct HTTP, POST to https://YOUR_TIERS_ENDPOINT/v1/chat/completions with Authorization: Bearer your_tiers_key.

1. Verified against a signed, immutable 14-day shadow baseline running the identical workload through the enterprise default model and through tiers: $47.00 per day default versus $6.10 per day governed on the reference workload, an 87% reduction at the maintained quality bar. Platform average: 83.08% across measured cohorts; optimized cohorts: 87.9%. The 90-day chart shows the production learning curve; the final 14-day comparison is the signed counterfactual. Category shares and console rows illustrate the reference workload. Results vary by workload.

2. Provider list-price snapshot, July 2026, across the 56 models and 14 providers in the tiers catalog. Prices, availability, and model coverage change over time.

3. All quotations are public statements about the market, reproduced verbatim with source and date. Ellipses mark omitted words. None are endorsements of tiers.