Videos

Each video is recorded from a script against the real router, its dashboard and Claude Code. Only the models are stand-ins, so every routing decision, cooldown and figure on screen is the router's own. The captions follow the narration, and under each video is a transcript: the narration, and the figures shown on screen that it doesn't say.

SemanticRouter.NET in two minutes

Install the tool, let init find LM Studio and Claude Code, point Claude Code at the router, and watch each turn go to the right model, including what happens when Claude's session limit runs out. Length 1:50.

Download “SemanticRouter.NET in two minutes” (MP4) · Captions for “SemanticRouter.NET in two minutes” (WebVTT)

Transcript

Most of what you ask an AI doesn't need the most expensive model. SemanticRouter.NET looks at each prompt, and sends it to the cheapest model that can handle it. That might be a local model, your Claude subscription, or a paid API.

Getting set up takes about a minute. First, install the .NET tool.

Then run the init command. It looks at what's already on your machine. Here, it finds LM Studio with two local models, and the Claude Code CLI you're already signed in to. Then it writes a config that puts each model on a tier.

Now start the router. It speaks both the OpenAI and the Anthropic API, and it tells you exactly how to connect.

In a second terminal, point Claude Code at the router, and pick semantic router as the model. Claude Code works just like before. The only difference? The router decides which model answers each turn.

Ask something simple, and a small local model answers. That's free, and it never leaves your machine.

A quick coding task? That goes to the local coder.

But a tricky debugging question goes to Claude, where your subscription is actually worth spending.

And when you hit your Claude session limit? The router cools Claude down, and keeps you working on your local models. You don't change a thing.

The dashboard shows every decision as it happens: which route matched, which model answered, and how much of it stayed on your machine. And it's not just Claude Code. Any OpenAI or Anthropic client can use the same endpoint.

That's SemanticRouter.NET. It's open source and MIT licensed. Install it with one command, and stop paying frontier prices for small prompts.

Deep dive: how a prompt gets routed

Routes, the prompt tester, complexity, tiers and strategies; a tool round trip, callouts and secret detection; failover; and the Activity and Evaluate pages that explain every decision. Length 3:05.

Download “Deep dive: how a prompt gets routed” (MP4) · Captions for “Deep dive: how a prompt gets routed” (WebVTT)

Transcript

Let's take a closer look at how SemanticRouter.NET decides where each prompt goes, and what happens when something goes wrong.

Every request comes down to two questions. First: what does this prompt actually need? That's a tier, plus things like code or tools. Second: which of your models is the cheapest one that can handle it?

The first answer comes from routes. A route is just a handful of example prompts, plus the tier that kind of request needs. You start with eight of them, from small talk at the bottom, up to debugging and agentic coding at the top.

When a prompt comes in, the router compares it with every example. This one is closest to complex code, so it needs tier four, and a model that can write code.

Now something smaller: a regular expression for email addresses. That's simple code, so tier two is plenty, and the local coder goes first.

Ask for the same thing, but add a list of things to reason through, and the complexity score goes up. Long prompts, code, structure, and phrases like step by step all push it higher. Past a threshold, the prompt moves up a tier.

Your models sit on tiers too. This page shows which routes need each tier, and which models can serve it. If a tier has nothing that can serve it, you'll see it in red.

Then a strategy ranks the models that qualify. The default is cheapest capable. Local models go first, and the most capable one that's already loaded wins, so nothing waits for a model to load. Then your subscriptions, lowest tier first, to save quota. Paid APIs come last. Switch to auto best, and the same prompt goes straight to your strongest model.

Coding agents send a lot more than prompts. Every Claude Code turn carries its tools, so only models that can call tools are in the running.

Here, the local model asks Claude Code to open a file. Claude Code runs the tool, and sends the result back. And the router hands that result to the same model that asked for it, so a turn never gets split between two models.

And you can always take over. Start a message with at opus, at local, or at tier two, and the router does exactly that.

Some data should never leave your machine. Turn on secret detection, and once a conversation contains a credential, it stays local. Even if you've asked for Opus.

When a model goes down, or runs out of quota, it cools down, and the next one picks up the work. The endpoints table shows what's cooling down, and for how long.

Every decision explains itself. The activity log shows the route, the tier, and every model the request was sent to.

And the evaluate page runs a set of labelled prompts through your configuration. You'll see how often the router gets it right, and exactly where it gets it wrong, before you change anything.

So that's how a prompt gets routed. Next time, we'll tune it for your own models. SemanticRouter.NET is open source, and MIT licensed.

How-to: the settings

Where the settings live, adding a model LM Studio just downloaded and a paid API with its prices, fixing a misroute with Evaluate, a local-only profile, a budget, and doctor. Length 2:10.

Download “How-to: the settings” (MP4) · Captions for “How-to: the settings” (WebVTT)

Transcript

This one's the how-to. After init, you'll want the router to fit your models, your budget and your rules. All of it is on the dashboard, and every change applies live.

Everything lives in one file, and this page shows it. Every other page edits the same file. A change starts as a draft. Apply swaps it in, with no restart, and apply and save writes it to the file too.

Say you just downloaded a new model in LM Studio. On the models page, discover asks LM Studio what it has. It suggests a tier for each model, and what it can do. Gemma reads images, so it gets vision. Add it, then apply and save.

Want a paid API as well? Add a connector. Any OpenAI compatible endpoint works, like OpenRouter, Groq, or a server of your own. The key you type is encrypted into the secret store. The config file only holds a reference to it, never the key itself.

Apply, then discover its models, and add the one you want. Give it its price per million tokens. That's how cheapest capable knows what it costs: local models still go first, then your subscription, and the paid model only when nothing cheaper can do the job.

When prompts land on the wrong tier, don't guess. The evaluate page runs a labelled set through your configuration, and lists every miss. This one needed deep reasoning, but nothing matched it. Add it to the right route, and the set runs again. One more right, and nothing else broke.

Profiles are policies. This one is local only, so nothing it covers ever leaves your machine. A rule picks it for the billing project. And the compare tool shows what each profile would do with a prompt, before you rely on it.

The usage page shows what you spent, and what your subscription use would have cost at API prices. To cap the paid API, add a budget. Here, two dollars a day. Once it's spent, the router skips that connector until tomorrow.

And when something seems off, run doctor. It checks the configuration, the embeddings, and every connector, without calling a model.

That's the tour. Everything you saw is also in the docs. SemanticRouter.NET is open source, and MIT licensed.

What it saves you

A day of traffic across a local model, a Claude subscription and a paid API, then the Usage page and the weekly digest. Every figure is the router's own. Length 0:45.

Download “What it saves you” (MP4) · Captions for “What it saves you” (WebVTT)

Transcript

What does routing actually save you? Here's a day of agentic coding through the router: five long agent sessions in Claude Code, and the quick questions in between.

The quick questions and small edits stayed on this machine. They're free, and they don't touch your Claude limits.

On screen: 16 quick questions answered on this machine: a local model, free, no Claude limits used.

The agent sessions are where the tokens go: every step resends the whole conversation. On your Claude subscription, that's worth this much at API prices.

On screen: $18.59 of Claude use, at API prices: 3 agent sessions, 250 requests, 24M tokens in the day, included in your subscription.

Then the session limit hit. Instead of stopping, the last two sessions moved to a paid API. That's the only money actually spent today.

On screen: $0.73 actually spent: 2 agent sessions after Claude's session limit, on paid-api-deepseek-chat-v3, 73 requests.

Compared with running the whole day on a frontier model through its API, this is what routing saved. And the overview keeps a running total for the week.

On screen: $42.14 saved: $42.86 if all 339 requests went to Opus through its API, minus $0.73 spent (Usage:ReferenceModel).

On screen: The Overview, this week: 339 prompts routed, 5% served locally (16), $42.14 saved against claude-opus-api, $0.7256 spent, $18.59 of subscription use at API prices.

SemanticRouter.NET. Spend frontier money only where it counts. It's open source, and MIT licensed.

Privacy: what reaches the cloud

The memory map of a notes vault, a note read by a local model and then sent to Opus, a credential keeping a conversation local, and Activity as the record. Length 1:00.

Download “Privacy: what reaches the cloud” (MP4) · Captions for “Privacy: what reaches the cloud” (WebVTT)

Transcript

When your AI tools read your notes, where does that text go? The router can tell you, request by request.

Point it at your notes: an Obsidian vault here, or Claude Code's own memory. It maps every note and every link, the way Obsidian's graph view does.

Ask Claude Code about the billing migration, and it reads that note. A local model answers, so the note stays on this machine. The live page shows exactly that.

Now ask Opus to review the plan, and the note goes along with the conversation. The map marks it: this note has been sent to the cloud.

We don't recommend putting secrets in your prompts. But if one slips in, and secret detection is on, the conversation automatically stays local, even if you ask for Opus.

And every request is on the record. The activity log shows which notes each request carried, and which ones a credential kept local.

SemanticRouter.NET. Know what leaves your machine. It's open source, and MIT licensed.

The short version

Claude Code routed turn by turn, with a failover, in one vertical take. Length 0:45.

Download “The short version” (MP4) · Captions for “The short version” (WebVTT)

Transcript

Most of what you ask an AI doesn't need the most expensive model. So why pay for it?

SemanticRouter.NET sends every prompt to the cheapest model that can handle it. A local model, your subscription, or a paid API.

Ask Claude Code something simple, and a free local model answers. It never leaves your machine.

A quick coding task? The local coder takes it.

But a hard debugging question goes to Claude, where your subscription is worth spending.

Hit your session limit, and you keep working on your local models. You don't change a thing.

SemanticRouter.NET. Open source, one command to install. Stop paying frontier prices for small prompts.