Sovereign AI for companies.

Built and tested; publication-pending. Routing and the capture path run today; the distillation classifier and fine-tune training on top are still in build. Source private today, available for review on request.

• Learned per-prompt routing. Each call is scored on cost and quality and sent to a frontier API or a local model, chosen per request rather than by a static rule.
• No hosted control plane. A single Go binary against a single SQLite file. No Postgres, no Redis, no call-home, no network at decision time. The router sits on your side of the line, and it stays there.
• Self-hostable gateway and embeddable library. A drop-in, OpenAI-compatible endpoint you run on your own hardware, or the same routing as a small Go package with nothing to provision.
• Capture off the request path. Routing decisions are traced and a cheaper model shadows the request out of band, writing training datasets from your own traffic without adding latency to the live call.
• Reproducible evaluation. An offline eval harness, so a cost-quality claim is a measured number you can rerun, not an assertion.

For a company, this is the first concrete step off rented intelligence. Keep spending on the frontier where the frontier is worth it, move the rest onto hardware you hold, and let the traffic you already pay for accrue into a corpus that trains a model you own. The savings land first and are measurable offline; the owned model is what the captured corpus is for. Run inside your own perimeter, the same loop turns a frontier-AI budget into capability that stays yours, on your data, behind your walls.

llm-router is the route-and-capture half of that owned-runtime loop: it decides where each call runs and turns that usage into a corpus you keep. The train half is the distributed-training work: the collective-communication math in mlx-go-ccl, moved over the mlx-go-iroh transport and surfaced as mlx-mesh. Local inference runs on mlx-go. The classifier that decides what to distill and the fine-tune training that closes the loop are the pieces still in build; the first proof is a measured loop on one scorable task, released with a reproducible eval harness.