ExactRoute — Not all LLM calls need an LLM

36%

Enterprise LLM API spend grew in one year — $63K to $85.5K/month average

CloudZero, State of AI Costs, 2025

75–85%

Cost reduction from intelligent model routing, at 95% of frontier-model quality

RouteLLM, ICLR 2025

34%

Of companies have mature AI cost management — the rest still track spend by hand

Benchmarkit / Mavvrik, 2025

Not another router

OpenRouter, LiteLLM, and similar gateways decide which LLM handles a call — cheap model vs. frontier, this provider vs. that one — but every path still ends in an LLM call, made live, in the request path. ExactRoute asks a different question upstream: does this call need an LLM at all? A rule or classifier costs nothing and calls no model — an option no router is built to propose. Because ExactRoute analyzes historical traffic rather than sitting inline, proposals are reviewed and approved before anything changes, not decided autonomously on every request.

See what ExactRoute finds — right now, in your browser

Nine real datasets, nine different kinds of tasks. Click one to see what ExactRoute detects — nothing is uploaded, detection runs entirely on your device.

ExactRoute can also evaluate multi-turn agentic traces — where cost usually hides in one or two steps of a longer chain, not the whole thing. Not shown here since it needs a different kind of input than a single-column example; ask us about it directly.

Recommendation

Estimated saving

Signals used

Sample input → output

This is Tier 1 detection — identifying the type of task. Field-level analysis and the full recommendation engine are part of ExactRoute's advanced tiers.

Two ways to use this

Same detection either way — just a different starting point.

Already in production

You have real call logs

Paste or upload actual outputs from an LLM you're already running. See which of your live calls are paying frontier prices for something a rule, a lookup, or a lighter model could handle just as well.

Try it on your real logs →

Still designing

You haven't built it yet

Planning a new feature and sketching out what you'd ask an LLM to return? Paste a handful of example outputs — even hand-written ones — and see what kind of task this actually is before you architect around a full LLM call.

Try it on a sketch →

Want to try it on your own data? →

Try it on your own data

Nothing is uploaded anywhere. Detection runs entirely on your device.

Paste a few of your own LLM outputs (one per line, at least 3)

We only need what your LLM returned — not the input prompt, cost, or any other columns. If you upload a file with more than one column, we'll automatically find the one that looks like LLM output.

or ⬇ Download a template (.xlsx)

Recommendation

Estimated saving

Signals used

Data analyzed

This is Tier 1 detection — identifying the type of task. Field-level analysis and the full recommendation engine are part of ExactRoute's advanced tiers.

How it works

ExactRoute tries the cheapest, most deterministic method first — and only falls back to an LLM for what genuinely needs one.

Getting data in — four ways

Live telemetry

OpenTelemetry, Langfuse

CSV / XLS upload

Any export, any shape

Formatted XLS

Structured, mapped directly

Design sketch

Pre-production examples

↓

Detection

Checked against 9 output shapes, in order of specificity — the first real match wins

↓

Hybrid tiering — cheapest method first

Rule matching

Vocabulary lookup

Non-LLM NER

LLM call

Only for what needs it

rule ✓ — free, instant vocabulary NER LLM

↓

Test against real models

Your API key, your logged data

Export & act

Proposals, breakdowns, re-upload-ready sheets

Beyond detection

What's shown above is the entry point. The full dashboard covers a lot more ground.

Bring your own data, however you have it

A raw call log, a formatted spreadsheet, a live telemetry connection, or just a handful of examples before you've built anything — all four are first-class ways in.

Nothing changes without your review

Every proposal is generated for you to inspect and approve — not applied automatically. You see exactly what would change and why, before it does.

Test recommendations against real models

Compare multiple LLM providers directly against a proposed rule or lighter model, field by field — see the actual tradeoff before committing to it.

See and tune the generated logic

Rules and classifiers aren't a black box — inspect the actual generated code and adjust it directly if it doesn't quite match your judgment.

Export everything

Proposals, field-level breakdowns, and comparison results all export to a real spreadsheet — take the analysis with you, share it, act on it.

Runs on your data, your terms

The same local-first principle as the demo above extends through the full product — your call logs are analyzed without leaving your own environment.

All features

The full picture, for anyone who wants it before requesting access.

Getting your data in — four ways, all client-side

▾

Use whichever matches what you already have:

Connect Telemetry — a live fetch from an OpenTelemetry GenAI-standard backend (Jaeger, Grafana Tempo, or a self-hosted Langfuse instance).
Bring Your Own Log — upload a CSV or XLSX export from any logging setup, no live endpoint needed. If your platform is Langfuse Cloud, Datadog, or Honeycomb, this is the path — those don't allow direct browser connections.
Load a formatted XLS — a structured spreadsheet, mapped directly.
Design Validation — for pre-production work: paste a handful of expected input/output examples before any real logs exist.

Reviewing before you analyze

▾

Every path above lands on a Results view before anything gets analyzed — nothing runs automatically. Review the loaded rows, filter by row type, workflow, or search text, then run analysis when you're ready.

How detection works, and reading a proposal

▾

Every dataset is checked against nine possible output shapes, in order of specificity — the first real match wins (this is exactly the logic running in the demo above). Each detected result becomes a proposal: a tier badge, the detected reason, a recommendation, and — where real measured data exists — a proven saving percentage, kept clearly separate from anything still modeled or unproven. For structured extraction (JSON) specifically, the breakdown goes one level deeper, field by field.

Testing recommendations against your own models

▾

A "Test with your own models" option appears on proposals that could genuinely benefit from real evidence. For structured extraction, this checks whether a cheaper model actually holds up on the fields flagged as needing an LLM — using your own API key, scored against your own real logged data, never a modeled estimate. Fields already proven deterministic are listed too, unchecked and tagged "proven," so you can independently verify that claim as well. Summarisation and long-generation tasks get their own whole-task version of the same idea.

Tunable parameters and analysis code

▾

The actual detection logic and current threshold values are shown directly — generated live from the real configuration, not a static description that can drift out of date. Nothing here is a black box; the logic can be inspected and tuned for your specific data.

Agentic loops

▾

For multi-turn traces, ExactRoute finds which turns in an episode concentrate most of the cost — often just two or three turns out of many — and checks each of those heavy turns against optimization strategies of its own, rather than treating the whole episode as one uniform unit.

Exporting your work

▾

Every export is labeled by what it actually contains, not a generic "download" — including a "re-upload ready" sheet formatted with the exact column headers Design Validation and Bring Your Own Log already expect, so a tested result can feed straight back in. Any recommendation can also be generated as a standalone, printable explanation for sharing outside the dashboard.

Data and security principles

▾

Analysis runs inside your own environment — only anonymized proposal metadata, never call content, is designed to leave it. API keys used for model-testing are held in browser memory only for that session, never sent to any ExactRoute server, and cleared when the session ends. Every cost or quality number shown is either measured against your real logged data, or explicitly labeled as modeled/unproven — the two are never presented as if they were the same kind of claim.

Current scope and known limitations

▾

Being upfront about where things stand today, not just what works:

The field-level breakdown is built for structured extraction (JSON output) specifically — classification has its own cluster-based system instead.
The whole-task harness's matching method (word overlap) doesn't yet have a calibrated threshold, unlike the field-level harness's tested cutoff.
Agentic loop analysis can misfire when real cost/token data isn't present in the logs.
Entity extraction's current recommendation hasn't yet been through the same verification rigor as structured extraction.
Vocabulary-tier matching only recognizes terms already seen in its own sample — it doesn't generalize to genuinely new values the way a trained model would.

We'd rather you know this going in than find out later — this list will keep changing as the product does.

Want field-level analysis, or the full dashboard?

We're looking for a small number of early users willing to try ExactRoute on their real call logs and tell us honestly what's missing. In exchange, you get access before anyone else.

This is reviewed by a person, not automated — we'll email you directly, usually within a few days, with a private link to the full dashboard. No account or signup needed on your end.

Prefer to just email us? SANCVAILLC@gmail.com

Not all LLM calls need an LLM.