Blog · 2026-07-13 · Vynaris Team
3 Ways to Route LLM Requests: OpenRouter, Not Diamond, Vynaris
OpenRouter vs Not Diamond vs Vynaris: three LLM router architectures, fee math verified 2026-07-13, and when to pick each.
"LLM router" now means three different architectures. OpenRouter load-balances providers of the same model by the inverse square of price. Not Diamond returns a model recommendation and makes you place the call yourself. Vynaris proxies the request to a right-sized cheaper model and prints a cost receipt on every response. They solve different problems. Pick the wrong one and you either leave money on the table or end up bolting failover logic onto a product that never promised it.
All prices and mechanics below were pulled from the three providers' own pages on 2026-07-13. Check the dates before acting on the numbers.
The verdict table
OpenRouter Not Diamond Vynaris
------------------------------------------ ------------------------------------------------------- ------------------------------------------------------------- ---------------------------------------------------------
Architecture Proxy; provider load-balancing per model Recommendation API; you dispatch the call Proxy; disclosed model downgrade
Default routing signal Uptime filter + inverse-square price weighting Learned quality prediction per prompt Right-sizing: cheapest model the router judges sufficient
Cross-model routing Opt-in (`openrouter/auto`, NotDiamond-backed) Yes, that is the product Yes, default with `model="auto"` or disclosed downgrade
Fee model 0% inference markup; 5.5% Stripe credit fee ($0.80 min) $0.05 per 1M tokens routed, on top of your own provider bills Provider list price + 3% on first $500/mo, 1% after
Added latency Not published Not published Not published
Provider failover Yes, automatic + fallback arrays Developer-owned No; 502, safe to retry, not charged
Anthropic /v1/messages Yes N/A (not a proxy) Not implemented
Cost per request visible Billed model in response You see your own bills `cost_usd` + `direct_equivalent_usd` in every response
Overhead on the 500k-task workload (below) $82.50 $37.50 $25.00
Best fit Multi-provider reliability, open-weight model access Coding agents, custom-trained routing Cost-cutting agent plumbing with auditabilityFee sources: OpenRouter docs (FAQ page), Not Diamond pricing, and the Vynaris pricing page (linked in the pitch section below), all verified 2026-07-13.
Architecture 1: OpenRouter, the provider load-balancer
OpenRouter's default router answers a question most people don't realize they are asking: which host should serve the model you already chose. Per its provider-routing docs page, it first filters out providers that saw significant outages in the last 30 seconds, then load-balances the rest weighted by the inverse square of price. A provider serving your model at $1/M tokens is 9x more likely to get the request than one at $3/M. Latency and throughput are tracked as p50/p75/p90/p99 percentiles over a rolling 5-minute window, and you can sort on them with :nitro (throughput) or :floor (price) suffixes.
Note what is absent from the default path: no learned quality model, no cross-model decision. If you send claude-sonnet-5, you get Claude Sonnet 5, just from whichever supported provider is up and cheap. Cross-model routing exists but is opt-in via openrouter/auto, which per the model-routing docs page uses NotDiamond under the hood with a 0-10 cost_quality_tradeoff dial (default 7). You can also pass a models fallback array that fires on rate limits, moderation flags, context-length errors, and downtime, with billing against the model that actually served.
The pricing is inverted relative to the other two: zero markup on inference, monetized through a 5.5% fee (minimum $0.80) on Stripe credit purchases and a 5% BYOK fee after 1M free requests per month, per the FAQ page. Scale is the moat: the homepage claims 100T monthly tokens and 400+ models, though the public models API returned 343 entries when we queried it on 2026-07-13.
Architecture 2: Not Diamond, the recommendation engine
Not Diamond is not a proxy. The quickstart in its docs is explicit: modelSelect returns a session ID and a chosen provider/model, then you "call the selected model using your preferred SDK (OpenAI, Anthropic, etc.)." Your traffic never flows through Not Diamond. That is a real architectural difference, not a detail. It means your prompts stay closer to home, but it also means retries, failover, and streaming plumbing stay your problem. The quickstart documents no fallback or timeout parameters on the modelSelect endpoint; provider failure handling lives in your own dispatch code.
The routing itself is the most sophisticated of the three on paper: a learned model that, per Not Diamond's routing docs, predicts which model will give the highest-quality response for a given query while lowering cost, with quality/cost/latency tradeoff modes and custom routers you train on your own eval data. Positioning has narrowed to coding agents specifically, with a published Rootly case study on its site.
Costs: $0.05 per million tokens routed on the pay-as-you-go tier, and a hard 50 requests/second default rate limit per the rate-limits docs page. One friction point: pay-as-you-go access is application-gated, not self-serve.
Architecture 3: Vynaris, the right-sizing proxy with receipts
Vynaris takes the proxy shape of OpenRouter and the cross-model decision of Not Diamond, and points both at one job: downgrade the request when a cheaper model will do. Per the Vynaris docs (verified 2026-07-13; live link in the pitch section), each request is "right-sized with a receipt": routed to a cheaper model when the router judges it sufficient. Send model="auto", or send a frontier model name, which the router treats as intent and may serve with a cheaper equivalent. When nothing cheaper fits, the request escalates to the exact model you asked for.
The receipt is the differentiator, and Vynaris's homepage says so plainly: "Every response names the model that served it and what it cost, in the headers and in your ledger." Every response body carries cost_usd, direct_equivalent_usd (what your requested model would have cost at list price), served_model, and requested_model, mirrored in x-vynaris-* headers. There is no silent substitution; the serving model is always named. The homepage claims 96-98% measured savings on live routed requests, but read that carefully: the baseline is the requested model at list price, so heavily downgraded traffic inflates the headline. Task-level examples on the homepage are more grounded: ~78% on order field extraction ($0.0004 vs $0.0018 per request).
Pricing is pass-through: provider list price plus a convenience fee of 3% on your first $500 of usage each calendar month and 1% past it, prepaid credits with a $5 minimum, refundable on request, per the Vynaris pricing page (verified 2026-07-13; linked below). Enterprise is a $5,000/yr flat fee, billed by your providers directly with no convenience fee.
The fee math, computed
Take a concrete workload: agent plumbing tasks of 1,200 input + 300 output tokens on a $1.00/$6.00 per-M-token model (gpt-5.6-luna class). Per-task compute cost is (1,200 x $1.00 + 300 x $6.00) / 1,000,000 = $0.003. For heavier agent workloads, the same method scales up; we walked a full plan/edit/verify loop through it in what an AI coding agent costs per task. The overhead formulas: OpenRouter = 5.5% of credits purchased; Not Diamond = $0.05 x total tokens in millions; Vynaris = 3% x min(spend, $500) + 1% x max(spend - $500, 0).
Tasks/mo Compute spend OpenRouter fee Not Diamond fee Vynaris fee
--------- ------------- -------------- --------------- -----------
50,000 $150 $8.25 $3.75 $4.50
500,000 $1,500 $82.50 $37.50 $25.00
5,000,000 $15,000 $825.00 $375.00 $160.00Two assumptions behind the columns. The OpenRouter column assumes you buy credits via Stripe exactly matching your spend, with no unused balance and no BYOK path. The Not Diamond column assumes "tokens routed" counts all input plus output tokens (750M at 500k tasks); Not Diamond's pricing page does not spell out the counting basis.
Two caveats that matter more than the fees. First, these are overhead-only numbers on identical model choices. The real savings lever for Not Diamond and Vynaris is the downgrade: dropping from a 5x-priced frontier model ($5/$30 per M tokens gives $0.015/task, or $15.00 per 1,000 tasks) to the $3.00-per-1,000 floor saves $12 per 1,000 tasks. Every fee above is noise next to that; our July 2026 per-task pricing comparison shows how wide those per-task gaps run across 14 models. Second, OpenRouter's fee buys something the other two don't sell: automatic multi-provider failover. Run your own token mix through the cost calculator before deciding whether the downgrade delta is real for your workload.
When NOT to pick Vynaris
Be honest about the gaps, because they are structural, not roadmap footnotes.
You need automatic provider failover. Vynaris returns a 502 on upstream failure, marks it safe to retry, and does not charge you. That is clean accounting, not resilience. OpenRouter's default router reroutes around 30-second outage windows automatically and supports explicit fallback arrays. If a provider outage taking down your product is unacceptable, OpenRouter is the mature answer.
You are Anthropic-native. Vynaris's own docs state the /v1/messages wire format is not yet implemented; Anthropic-shaped traffic must go through the OpenAI-compatible endpoint, and the Claude Code integration is described as "environment setup for future compatibility." OpenRouter supports the Anthropic-compatible endpoint today.
You need latency-percentile routing or published operational commitments. OpenRouter routes on p50-p99 latency and throughput; Vynaris documents no latency-based signal, no rate limits, no uptime SLA, and no status page. OpenRouter's status page showed 99.97-100% component uptime when we checked on 2026-07-13.
You want a router trained on your own evals. Not Diamond's custom routers, trained on your data and able to target your own fine-tuned endpoints, are a capability neither proxy offers on self-serve.
You are tiny. At 100 requests a day, all three fee columns round to pocket change and a direct provider key is one less dependency.
Where Vynaris fits
This section is the pitch, labeled as such. If your workload is high-volume agent plumbing (extraction, classification, tool-argument formatting) currently running on a frontier model by default, the right-sized downgrade is where the money is. The per-request receipt is what lets you audit it instead of trusting a savings claim. Integration is a base URL swap to https://api.vynaris.com/v1 on the OpenAI SDK, leaving is the same swap back, and the fee is 1-3% pass-through rather than a purchase fee. The mechanics are documented at vynaris.com/docs and the fee schedule at vynaris.com/pricing. Get a key at vynaris.com.
FAQ
What is the difference between OpenRouter and Not Diamond?
OpenRouter is a proxy that load-balances providers of the model you chose (cross-model routing is opt-in); Not Diamond is a recommendation API that predicts the best model per prompt and leaves the actual API call to you, at $0.05 per 1M tokens routed.
Does OpenRouter charge a markup on tokens?
No. Inference is at provider list price; OpenRouter monetizes via a 5.5% Stripe credit-purchase fee ($0.80 minimum), 5% for crypto, and a 5% BYOK fee after 1M free requests/month.
Is Not Diamond a proxy like OpenRouter?
No. Its modelSelect endpoint returns a recommended provider/model and session ID; your code dispatches the completion with your own SDK and keys, so failover and retries are yours to build.
How does Vynaris routing work?
Vynaris right-sizes each request: it serves a cheaper model when the router judges it sufficient and escalates to the exact model you asked for when not, per its docs. Every response discloses served_model, cost_usd, and direct_equivalent_usd; there is no silent substitution.
Which LLM router is cheapest at $1,500/month of model spend?
On overhead alone (our 500k-task scenario): Vynaris $25 (3%/1% tiered fee), Not Diamond $37.50 ($0.05/M on 750M tokens), OpenRouter $82.50 (5.5% credit fee). But routing downgrades and failover needs usually matter more than the fee delta; verify against your own token mix.