OpenSquilla Routes Every AI Task to the Cheapest Model That Can Finish It
Honestly, Smart Routing Is Element Rhythm's Game
After using AI for this long, I suddenly realized a problem.
There are too many AI vendors. Both big and small companies keep releasing new models, and most releases are clustered. DeepSeek finishes releasing, GLM releases, and before GLM can even be tested, Qwen and Kimi jump in. Almost every month there's a new version, and every company claims their code ability improved another notch.
But which model actually does good work, and which model is cheap? Testing them one by one yourself is simply impossible.
The ideal state would be: simple tasks go to cheap models, hard tasks go to strong models, and each task gets exactly the model that's just good enough. But how to judge "just good enough" and which model each tier should use is generally hard to figure out on your own.
I found a GitHub project that does exactly this.

This GitHub project's approach: you don't pick models yourself. Every month they test the mainstream models and push the best config for that month directly to your client.
First, a quick explanation of what OpenSquilla is. It's an Agent framework open-sourced by Element Rhythm (基元律动). Daily use is similar to common Agent platforms: give it a task, it breaks it down, calls tools, and gets the job done.
The difference is in the underlying smart routing. Ordinary Agent platforms fix a single model, while OpenSquilla automatically switches models based on task difficulty.
OpenSquilla uses a microkernel architecture. The core engine only does orchestration scheduling and state management; other capabilities are added as plugins. Isn't this quite similar to DSH's Cordits microkernel pattern?

Model routing is mainly divided into three layers.
1. Four tiers C0 to C3, the local router decides which tier a task belongs to.
OpenSquilla classifies tasks into four difficulty tiers: C0, C1, C2, C3. C0 is the simplest, C3 the most complex. Each time you launch a task, the local router first judges which tier it belongs to, then hands it to the model for that tier.
2. One request calls only one model.
Some smart routing models, to pick accurately, run multiple models at the same time and pick the best result. The result may be good, but token costs multiply several times over.
OpenSquilla doesn't do that. One request only calls the single selected model. This is also the key to its cost efficiency.
3. Continuing the same task keeps the original tier; only when rework is needed does it upgrade.
When continuing the same task, the original tier is kept, and it doesn't re-judge each round.
Only when the current result is unsatisfactory and needs rework does it upgrade a tier and switch to a stronger model.
November model recommendation list
So which model goes in each tier? That's what OpenSquilla's monthly recommendation list solves.
The recommendation list is the optimal config from Element Rhythm's internal experiments. Each month they put new models in various combinations on multiple public Agent benchmarks for comprehensive testing, such as:
- Claw-SWE-Bench: code repair tasks;
- AppWorld: cross-app transaction tasks.
Testing looks at both quality and spend, comparing current config, prior config, and single-model-only approaches, and finally selects the group on the Pareto frontier. In plain words: best result at the same cost, lowest cost at the same result.
November is the first month. The four tiers are:
| Tier | Model |
|---|---|
| C0 | Qwen3.8-Flash |
| C1 | DeepSeek-V4.1-Flash |
| C2 | GLM-5.3 |
| C3 | Kimi K3 |
Benchmark results
Comparing November config with prior configs:
| Benchmark | Score change | Avg per-task generation cost change |
|---|---|---|
| Claw-SWE-Bench (code repair) | +32.41% | -22.10% |
| AppWorld (cross-app tasks) | +9.39% | +2.96% |
On code repair, score up 32%, cost down 22% — both faster and cheaper.
The AppWorld result needs clarification: score improved about 9%, but average per-task cost rose about 3%. This is a trade-off. Cross-app tasks have long chains and many steps; to push success rate up, a bit more cost is needed.
Updates don't wait for client releases
One thing I like: recommended configs and the client are updated separately.
There are two sets of recommended configs (TokenRhythm and OpenRouter). OpenSquilla checks at startup, then every 24 hours. When there's a new config, it first shows you the diff between old and new, and applies only after you confirm.
This means when new models come out and the list updates, you can use them without waiting for a client version bump, and the model won't be switched behind your back without your knowledge.
Hands-on test
Numbers alone aren't enough. I downloaded it and ran it to see how it actually performs.
Download and install
OpenSquilla supports Windows, Mac, Linux. There are several install methods; pick what fits your habits.
Method 1: Desktop client (recommended for ordinary users)
This is the easiest, no need for Git, Python, etc. The desktop installer currently offers Mac and Windows versions. Just install it following the prompts. For Mac, drag it into Applications. Note: the TokenRhythm account login feature is desktop-only for now.
Method 2: Terminal install (recommended for Linux and command-line users)
Linux users, or those who prefer the terminal and want to deploy on servers, can use uv to install the released version directly. No need to install Python first; uv handles it.
First install uv (skip if already installed):
# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows PowerShell
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
Then install OpenSquilla, the command is the same for all three platforms:
uv tool install --python 3.12 "opensquilla[recommended] @ https://github.com/TokenRhythm/opensquilla/releases/download/v0.5.8/opensquilla-0.5.8-py3-none-any.whl"
The recommended extra installs the local router SquillaRouter, which is what powers smart routing.
After install, run the init wizard, configure model source and API keys, then start the Gateway:
opensquilla onboard # first-time config wizard
opensquilla gateway run # start service, default 127.0.0.1:18791
opensquilla chat # or just chat in the terminal
If you hit problems, run opensquilla doctor, which checks whether the environment is ready.
The official Docker image (ghcr.io/tokenrhythm/opensquilla:v0.5.8) supports amd64 and arm64, also useful for server deployment.
Method 3: Source install (for tracking the latest main branch)
Source install needs Git, Git LFS, Node.js 22.12+ and uv installed beforehand. The router's model files are stored in Git LFS, so after clone, remember to pull the LFS files:
git lfs install
git clone https://github.com/TokenRhythm/opensquilla.git
cd opensquilla
git lfs pull --include="src/opensquilla/squilla_router/models/**"
Then run the install script:
# macOS / Linux
bash scripts/install_source.sh
# Windows PowerShell
powershell -ExecutionPolicy Bypass -File ./scripts/install_source.ps1
The script also builds the Vue-based web console. Same as before, run opensquilla onboard to initialize.
I went with the desktop client for convenience.

OpenSquilla's models are provided by Element Rhythm's multi-model API platform TokenRhythm, so you need to register a TokenRhythm account first. After real-name verification, you get 18 yuan of trial credit, enough for several test tasks. I also see a limited-time buy-one-get-one-free promotion.

OK, download complete, let's start the test.
Opening the home page still requires logging into the TokenRhythm account.

After login, the interface looks like this. Left side has Task, Skills & Channels, scheduled tasks, and usage info.

The Skills & Channels on the left support built-in and custom entries, and you can install from the marketplace.

The scheduled tasks section offers several runnable templates, which is nice.

Pay attention to the model selection area here.

Currently there are three model selection modes. The first is fixed model, which you can freely switch.
The second is smart model routing, which routes to a cost-effective model according to actual needs, achieving just enough to get the job done.
The third is multi-model fusion, where multiple candidate models work in parallel and one model summarizes. This guarantees the best result but consumes more tokens.

I picked smart model routing to see the actual result and cost.
I assigned a programming tool cost survey task: "Comprehensively research all current mainstream AI coding tools domestically and abroad, and build a Chinese interactive dashboard to understand the market, compare products, and arrange trials."
Smart model routing routed it to Kimi K3.

After it finished, check the result.

The task basically covered all mainstream AI coding tools on the market.

Actual cost and token consumption are shown below.

Finally, my impressions.
Models iterate this fast. Instead of spending time every month testing and agonizing over which one to use, better to hand it to people who specialize in evaluation.
OpenSquilla's approach: every task gets a just-good-enough model; the config is updated monthly based on evaluation. Each month's new model combination also syncs to your local model list.
If you don't want to chase model changes, OpenSquilla's smart routing is the low-effort, low-token option.
If you're interested, give it a try. Looks like today is the last day of the Double 11 (11.11) sale period.