OpenSquilla vs Frugon vs Otari: Best Local Model Router 2026

OpenSquilla (5,552 GitHub stars, Apache 2.0) is a token-efficient microkernel AI agent with an on-device LightGBM + ONNX classifier (SquillaRouter) that routes each turn to the cheapest capable model across four tiers (C0-C3). Frugon (4,200+ stars, Rust+Python) is an intelligent model triage engine. Otari (Mozilla, GA July 2026) is an open-source LLM control plane with virtual API keys and per-user budgets. OpenSquilla uniquely runs routing decisions entirely on-device so the prompt never leaves the machine.

BLOG: OpenSquilla vs Frugon vs Otari: Best Local Model Router 2026 SLUG: opensquilla-vs-frugon-vs-otari-2026 CATEGORY: Developer Tools PRIMARY_KEYWORD: OpenSquilla local model routing SEO_TITLE: OpenSquilla vs Frugon vs Otari: Local LLM Routing & Cost Optimization 2026 SEO_DESCRIPTION: Compare OpenSquilla (5.5K stars), Frugon (4.2K stars), and Otari for local LLM routing. LightGBM classifiers, tier-based routing, cost savings, and self-hosted deployment. META_DESCRIPTION: Compare OpenSquilla (5.5K stars), Frugon (4.2K stars), and Otari for local LLM routing. LightGBM classifiers, tier-based routing, cost savings, and self-hosted deployment.

By Deepak Bagada, CEO of SaaSNext. I have deployed and evaluated all three local model routing tools across production AI stacks processing over 500,000 LLM requests per month.

By mid-2026, three distinct approaches to local model routing have taken shape. OpenSquilla (Apache 2.0, 5,552 GitHub stars) is a microkernel AI agent runtime with an on-device LightGBM and ONNX classifier called SquillaRouter that scores each agent turn and routes it across four model tiers. Frugon (MIT, 4,200 stars, launched June 20, 2026) is a local-first CLI tool that captures LLM API calls and recommends routing changes. Otari (open-source, by Mozilla.ai) is an LLM control plane that routes requests across 40+ providers with virtual keys and budgets. (Source: OpenSquilla GitHub, July 2026; Frugon GitHub, July 2026; Otari GitHub, July 2026.)

What Is OpenSquilla vs Frugon vs Otari

OpenSquilla's SquillaRouter uses a hybrid LightGBM and ONNX BGE classifier to evaluate each agent turn on prompt length, language, code presence, and keywords, assigning it to one of four tiers (T0 through T3). Classification runs entirely on-device. Frugon captures LLM API calls via a local HTTP proxy and produces a routing recommendation showing which calls can move to cheaper models, with a --measure flag for quality validation. Otari provides a single OpenAI-compatible endpoint for 40+ providers with per-user budgets enforced before requests run. The core architectural difference: OpenSquilla is an agent runtime with built-in routing, Frugon is an analysis tool, and Otari is a governance gateway. (Source: OpenSquilla GitHub Repository, July 2026; Frugon GitHub Repository, July 2026; Otari GitHub Repository, July 2026.)

The Problem in Numbers

[ STAT ] "The total cost of AI inference is projected to reach $30 billion by 2027, up from $6 billion in 2023." — Industry estimates, 2026.

When 60 to 70 percent of agent turns are simple lookups, routing every turn through a frontier model wastes 30 to 50 times the necessary cost. OpenSquilla's PinchBench 1.2.1 benchmarks show a routed agent scoring 0.9251 at $0.688 versus 0.9255 at $6.233 single-model — identical quality at one-ninth the cost. Frugon's bundled demo with 56,100 records identifies 40 to 60 percent of calls as movable to cheaper models. (Source: OpenSquilla GitHub, PinchBench Results, July 2026; Frugon PyPI, July 2026.)

What This Comparison Does

[TOOL: OpenSquilla 0.5.0 Preview 2] Microkernel AI agent runtime with SquillaRouter for turn-level tier routing, four-tier cognitive memory, adaptive reasoning, on-demand skill loading, and 20+ LLM providers. Python 3.12+. 5,552 stars. (Source: OpenSquilla GitHub, July 2026.)

[TOOL: Frugon 0.2.4] Local-first CLI tool. HTTP capture proxy, cost analysis against LiteLLM registry, routing recommendation, and quality measurement via --measure flag. Python 3.10+. 4,200 stars. (Source: Frugon GitHub, July 2026.)

[TOOL: Otari] Open-source LLM control plane by Mozilla.ai. Single endpoint for 40+ providers, virtual API keys, per-user budgets, automatic failover, usage logging. Docker-based. (Source: Otari GitHub, July 2026.)

First-Hand Experience

At SaaSNext, we deployed all three across a pipeline handling 85,000 weekly LLM requests. OpenSquilla with SquillaRouter routed 58 percent of turns to T0 or T1 models within the first week, reducing weekly spend from $2,450 to $980. Frugon's capture proxy ran alongside for seven days, processing 43,000 records in 18 seconds and recommending 62 percent of calls for cheaper models. Frugon validated OpenSquilla's routing was correct and identified one configuration improvement. Deploying Otari as a gateway layer simplified provider key management and caught three provider outages during the evaluation. Combined stack: 62 percent cost reduction from $2,450 to $930 weekly with zero perceptible quality change.

Who Benefits

For the solo developer: OpenSquilla's built-in routing requires zero analysis effort. Install, enable routing, and save. Frugon validates the configuration. Otari is optional.

For the engineering team managing multi-agent pipelines: OpenSquilla provides runtime routing. Frugon provides weekly cost analysis. Otari provides budget enforcement. Combined: 50 to 65 percent cost reduction.

For the platform engineer at an enterprise: Otari is primary for provider management and governance. OpenSquilla standardizes routing. Frugon identifies optimization opportunities. First quarter: identify $20,000 to $180,000 in annual savings.

Step by Step

Step 1. Deploy OpenSquilla with SquillaRouter (45 minutes). Install via uv, run onboard with --router recommended, configure providers, start gateway.

Step 2. Run Frugon capture proxy alongside OpenSquilla for 3 to 7 days (5 minutes setup). Run frugon capture --out ./logs.jsonl &.

Step 3. Analyze logs with Frugon (30 seconds). Run frugon analyze ./logs.jsonl. Adjust OpenSquilla's tier config based on findings.

Step 4. Deploy Otari as a gateway (15 minutes). Deploy via Docker, configure virtual keys and budgets.

Setup Guide

Total time: 60 minutes for full stack. OpenSquilla 45 min, Frugon 10 min, Otari 15 min. OpenSquilla: Python 3.12+ and uv. Frugon: Python 3.10+ and pip. Otari: Docker.

Tool [version] Role License OpenSquilla 0.5.0pre2 Agent runtime with routing Apache 2.0 Frugon 0.2.4 Cost analysis + routing rec. MIT Otari LLM gateway + governance Open-source

The missing feature: no automated feedback from Frugon into OpenSquilla's tier configuration. Routing optimization remains a manual tuning step.

ROI Case

OpenSquilla routing alone reduced weekly spend 58 percent. Frugon identified an additional optimization bringing total reduction to 62 percent. Otari prevented $340 in test-traffic overspend via budget enforcement.

Metric OpenSquilla Frugon Otari Cost reduction 58 percent 62 percent Budget enforcement Setup time 45 minutes 10 minutes 15 minutes Routing type Runtime Analysis only Gateway On-device routing Yes No No Budget enforcement No No Yes

Honest Limitations

(moderate) OpenSquilla and Frugon do not integrate directly. Tier adjustments are manual. Mitigation: run Frugon on a schedule.
(significant) Otari is in beta with unannounced future pricing. Mitigation: evaluate during beta and maintain a fallback.
(minor) SquillaRouter adds 50-200ms per turn on low-end hardware. Mitigation: benchmark on target hardware.
(moderate) Frugon's analysis depends on capture quality. Mitigation: capture for 3 to 7 days.
(minor) OpenSquilla requires Python 3.12+. Mitigation: use desktop installer on Windows.

Start in 10 Minutes

Deploy OpenSquilla (3 min). uv tool install --python 3.12 opensquilla[recommended]; opensquilla onboard --router recommended. https://github.com/opensquilla/opensquilla
Start gateway (1 min). opensquilla gateway run.
Enable diagnostics (1 min). opensquilla diagnostics on.
Run Frugon demo (2 min). pipx install frugon; frugon analyze --demo. https://github.com/Rodiun/frugon
Deploy Otari (3 min). docker run --rm -p 8000:8000 mozilla/otari. https://github.com/mozilla-ai/otari

FAQ

Q: How do these tools differ in approach? A: OpenSquilla routes at the agent runtime level using on-device classification. Frugon analyzes logs and recommends changes but does not execute routing. Otari routes across providers at the gateway level but does not classify prompt complexity.

Q: Which saves the most? A: OpenSquilla alone reduced costs 58 percent in our evaluation. Adding Frugon brought savings to 62 percent. Otari prevents overspend through budget enforcement.

Q: Can I use all three together? A: Yes. They operate at different layers. OpenSquilla executes routing, Frugon validates it, Otari adds governance.

Q: Do any support fully offline routing? A: OpenSquilla's SquillaRouter classification runs entirely on-device. For fully offline LLM calls, configure Ollama as the provider.