← Back to Blog

OpenSquilla — Token-Efficient AI Agent with Smart Model Routing

2026-05-28

OpenSquilla — Token-Efficient AI Agent with Smart Model Routing

LLM API costs add up fast. Every agent turn hits your wallet, and most frameworks use the same expensive model for trivial lookups and complex reasoning alike. OpenSquilla takes a different approach: a microkernel AI agent with a local model router that scores each turn and dispatches it to the cheapest capable model.

Launched in early May 2026, OpenSquilla already has over 2,000 stars on GitHub. It's Apache 2.0 licensed, written in Python 3.12+, and works on Windows, macOS, and Linux. In PinchBench benchmarks, it scored 0.9251 (nearly identical to Claude Opus 4.7 at 0.9255) while using 56% fewer input tokens — costing $0.69 instead of $6.23 for the same workload.

Why It's Trending

Three things make OpenSquilla stand out in the crowded AI agent space:

  1. Token-efficient routing — SquillaRouter, a local LightGBM + ONNX classifier, evaluates each turn on length, language, code presence, keywords, and semantic embeddings, then routes to one of four tiers (T0–T3). The prompt never leaves your machine for this decision.
  2. 20+ LLM providers — OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Groq, Mistral, vLLM, LM Studio, and more. Primary-plus-fallback selection keeps your agent running even when one provider is down.
  3. Unified gateway — Web UI, CLI, Telegram, Slack, Discord, Matrix, and 10+ other channels all share the same turn loop. Write one config, deploy everywhere.

Architecture Overview

OpenSquilla Architecture

The architecture follows a microkernel design. A central TurnRunner orchestrates all interactions, with pluggable components for routing, memory, tools, security, and channels.

  • Gateway Layer — ASGI server (Starlette) on 127.0.0.1:18791 accepts WebSocket RPC and HTTP connections. CLI, Web UI (/control/), and all messaging channels connect here.
  • TurnRunner — The shared turn loop. Every entry point — chat, agent one-shot, cron job, channel message — runs through this same loop. Tool dispatch, retries, decision logging, and subagent spawning all follow identical paths.
  • SquillaRouter — Local on-device classifier (LightGBM + ONNX). Scores each turn across four tiers (T0–T3) and picks the cheapest model that can handle it. Runs entirely on your machine — no data leaves for routing decisions.
  • Provider Registry — Pluggable adapter layer for 20+ LLM backends. Each provider has primary and fallback models configured.
  • Memory System — Persistent local storage via a curated MEMORY.md plus dated Markdown notes. SQLite full-text search + sqlite-vec for semantic recall. Embeddings run on-device via bundled ONNX or via OpenAI/Ollama.
  • Layered Security Sandbox — Three policy tiers (Standard / Strict / Locked) with a permission matrix. Bubblewrap isolates code execution on Linux. A denial ledger auto-pauses autonomous runs after repeated denials.
  • Scheduler Engine — Built-in cron parser for recurring jobs. opensquilla cron manages scheduled tasks.
  • Skill System — 15 bundled skills (coding, GitHub, cron, document authoring, summarization, weather, and more) load on demand. OpenSquilla is also an MCP client and can run as an MCP server.

Prerequisites

  • Python 3.12+ (bundled in Windows portable)
  • uv (recommended) — curl -LsSf https://astral.sh/uv/install.sh | sh
  • Git + Git LFS (only for source install)
  • An LLM provider API key (OpenRouter, OpenAI, Anthropic, etc.)

Installation

OpenSquilla offers four installation paths. The Quick terminal install is recommended for most users.

Quick Terminal Install (Recommended)

# Step 1: Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh
. "$HOME/.local/bin/env"

# Step 2: Install OpenSquilla
uv tool install --python 3.12 "opensquilla[recommended] @ https://github.com/opensquilla/opensquilla/releases/download/v0.2.1/opensquilla-0.2.1-py3-none-any.whl"

# Step 3: Configure and run
opensquilla onboard
opensquilla gateway run

Open http://127.0.0.1:18791/control/ in your browser to access the Web UI.

Windows Portable (No Python Required)

Download the portable zip from the releases page, extract it, and run Start OpenSquilla.cmd as administrator.

Docker

git clone https://github.com/opensquilla/opensquilla.git
cd opensquilla
git lfs pull --include="src/opensquilla/squilla_router/models/**"
docker build -t opensquilla:local .
./start.sh

Configuration

The first-run wizard (opensquilla onboard) walks you through provider setup, router configuration, channels, and security policies.

Non-Interactive Setup (SSH / CI)

export OPENROUTER_API_KEY="sk-..."
opensquilla onboard --provider openrouter --api-key-env OPENROUTER_API_KEY

Reconfigure Individual Sections

opensquilla configure provider --provider openai --model gpt-4o --api-key-env OPENAI_API_KEY
opensquilla configure router --router recommended
opensquilla configure search --search-provider brave --api-key-env BRAVE_SEARCH_API_KEY

Config Load Order

OPENSQUILLA_GATEWAY_CONFIG_PATH → ./opensquilla.toml → ~/.opensquilla/config.toml → built-in defaults. Environment variables always win over file values.

Usage

Start the Gateway

opensquilla gateway run          # foreground, 127.0.0.1:18791
opensquilla gateway start --json # background + health wait

Interact

opensquilla chat                 # interactive REPL
opensquilla agent -m "your prompt" # one-shot, automation-friendly

Check Cost

opensquilla cost

Benchmark Results

PinchBench 1.2.1 average results across 25 tasks:

OpenSquilla: Model router (Opus4.7, GLM5.1, DS4 Flash) — 0.9251 score, 1,721,328 input tokens, 61,475 output tokens, $0.688 OpenClaw (baseline): Claude Opus 4.7 — 0.9255 score, 3,066,243 input tokens, 50,890 output tokens, $6.233

OpenSquilla achieves nearly identical scores while consuming 56% fewer input tokens and costing 89% less.

Key Features

  • SquillaRouter — Local LightGBM + ONNX classifier routes each turn across four tiers (T0–T3) to the cheapest capable model. Classification runs on-device.
  • Adaptive reasoning — Extended reasoning only for complex turns. System prompt scales with task complexity.
  • 20+ providers — OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Groq, Mistral, vLLM, LM Studio, and more, with primary-plus-fallback.
  • 15 bundled skills — Load only when needed. Also MCP client + MCP server.
  • Persistent memory — SQLite full-text + semantic recall via sqlite-vec. On-device embeddings.
  • 3-tier sandbox — Standard / Strict / Locked. Bubblewrap isolation on Linux.
  • 10+ channels — Terminal, Web UI, Slack, Telegram, Discord, Feishu, Matrix, and more.

Resources

← Retour au Blog

OpenSquilla — Agent IA à Routage Intelligent pour Économiser vos Tokens

2026-05-28

OpenSquilla — Agent IA à Routage Intelligent pour Économiser vos Tokens

Les coûts des API LLM s'accumulent vite. Chaque tour d'agent sollicite votre budget, et la plupart des frameworks utilisent le même modèle onéreux pour les recherches simples comme pour les raisonnements complexes. OpenSquilla adopte une approche différente : un agent IA microkernel avec un routeur local qui évalue chaque requête et l'envoie au modèle le moins cher capable de la traiter.

Lancé début mai 2026, OpenSquilla compte déjà plus de 2 000 étoiles sur GitHub. Sous licence Apache 2.0, écrit en Python 3.12+, il fonctionne sur Windows, macOS et Linux. Dans les benchmarks PinchBench, il a obtenu un score de 0,9251 (quasiment identique à Claude Opus 4.7 avec 0,9255) tout en utilisant 56 % de tokens d'entrée en moins — pour un coût de 0,69 $ au lieu de 6,23 $ pour la même charge de travail.

Pourquoi OpenSquilla fait le Buzz

Trois caractéristiques distinguent OpenSquilla dans l'univers très fréquenté des agents IA :

  1. Routage économique — SquillaRouter, un classifieur local LightGBM + ONNX, analyse chaque tour selon la longueur, la langue, la présence de code, les mots-clés et les embeddings sémantiques, puis le dirige vers l'un des quatre niveaux (T0–T3). La requête ne quitte jamais votre machine pour cette décision.
  2. Plus de 20 fournisseurs LLM — OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Groq, Mistral, vLLM, LM Studio, et bien d'autres. La sélection primaire-plus-repli garantit que votre agent reste opérationnel même si un fournisseur est indisponible.
  3. Passerelle unifiée — Interface Web, CLI, Telegram, Slack, Discord, Matrix et plus de 10 autres canaux partagent tous la même boucle de traitement. Écrivez une configuration, déployez partout.

Architecture

Architecture OpenSquilla

L'architecture suit un design microkernel. Un TurnRunner central orchestre toutes les interactions, avec des composants enfichables pour le routage, la mémoire, les outils, la sécurité et les canaux.

  • Couche Passerelle — Serveur ASGI (Starlette) sur 127.0.0.1:18791 qui accepte les connexions WebSocket RPC et HTTP. La CLI, l'interface Web (/control/) et tous les canaux de messagerie s'y connectent.
  • TurnRunner — La boucle de traitement partagée. Chaque point d'entrée — chat, agent one-shot, tâche cron, message de canal — passe par cette même boucle. La répartition des outils, les tentatives, la journalisation et le lancement de sous-agents suivent tous des chemins identiques.
  • SquillaRouter — Classifieur local sur machine (LightGBM + ONNX). Évalue chaque tour sur quatre niveaux (T0–T3) et choisit le modèle le moins cher capable de le traiter. Fonctionne entièrement sur votre machine.
  • Registre de fournisseurs — Couche d'adaptation pour plus de 20 backends LLM. Chaque fournisseur a des modèles primaires et de repli.
  • Système de mémoire — Stockage local persistant via un MEMORY.md organisé et des notes Markdown datées. Recherche plein texte SQLite + rappel sémantique via sqlite-vec. Embeddings sur machine via ONNX ou via OpenAI/Ollama.
  • Sandbox de sécurité — Trois niveaux de politique (Standard / Strict / Verrouillé) avec une matrice de permissions. Bubblewrap isole l'exécution de code sur Linux.
  • Moteur de planification — Analyseur cron intégré pour les tâches récurrentes via opensquilla cron.
  • Système de compétences — 15 compétences incluses (codage, GitHub, cron, création de documents, résumé, météo, etc.) chargées à la demande. OpenSquilla est également client MCP et peut fonctionner comme serveur MCP.

Prérequis

  • Python 3.12+ (intégré dans la version Windows portable)
  • uv (recommandé) — curl -LsSf https://astral.sh/uv/install.sh | sh
  • Git + Git LFS (uniquement pour l'installation depuis les sources)
  • Une clé API d'un fournisseur LLM (OpenRouter, OpenAI, Anthropic, etc.)

Installation

OpenSquilla propose quatre méthodes d'installation. L'installation rapide en terminal est recommandée.

Installation Rapide en Terminal (Recommandé)

# Étape 1 : Installer uv
curl -LsSf https://astral.sh/uv/install.sh | sh
. "$HOME/.local/bin/env"

# Étape 2 : Installer OpenSquilla
uv tool install --python 3.12 "opensquilla[recommended] @ https://github.com/opensquilla/opensquilla/releases/download/v0.2.1/opensquilla-0.2.1-py3-none-any.whl"

# Étape 3 : Configurer et lancer
opensquilla onboard
opensquilla gateway run

Ouvrez http://127.0.0.1:18791/control/ dans votre navigateur pour accéder à l'interface Web.

Version Portable Windows (Sans Python)

Téléchargez l'archive portable depuis la page des versions, extrayez-la et exécutez Start OpenSquilla.cmd en tant qu'administrateur.

Docker

git clone https://github.com/opensquilla/opensquilla.git
cd opensquilla
git lfs pull --include="src/opensquilla/squilla_router/models/**"
docker build -t opensquilla:local .
./start.sh

Configuration

L'assistant de premier démarrage (opensquilla onboard) vous guide à travers la configuration du fournisseur, du routeur, des canaux et des politiques de sécurité.

Configuration Non-Interactive (SSH / CI)

export OPENROUTER_API_KEY="sk-..."
opensquilla onboard --provider openrouter --api-key-env OPENROUTER_API_KEY

Reconfigurer des Sections Individuelles

opensquilla configure provider --provider openai --model gpt-4o --api-key-env OPENAI_API_KEY
opensquilla configure router --router recommended
opensquilla configure search --search-provider brave --api-key-env BRAVE_SEARCH_API_KEY

Utilisation

Démarrer la Passerelle

opensquilla gateway run          # premier plan, 127.0.0.1:18791
opensquilla gateway start --json # arrière-plan + attente de santé

Interagir

opensquilla chat                 # REPL interactif
opensquilla agent -m "votre instruction" # one-shot, idéal pour l'automatisation

Vérifier les Coûts

opensquilla cost

Résultats des Benchmarks

PinchBench 1.2.1 — résultats moyens sur 25 tâches :

OpenSquilla : Routeur (Opus4.7, GLM5.1, DS4 Flash) — 0,9251 score, 1 721 328 tokens d'entrée, 61 475 tokens de sortie, 0,688 $ OpenClaw (référence) : Claude Opus 4.7 — 0,9255 score, 3 066 243 tokens d'entrée, 50 890 tokens de sortie, 6,233 $

OpenSquilla atteint des scores quasi identiques tout en consommant 56 % de tokens d'entrée en moins et en coûtant 89 % moins cher.

Fonctionnalités Clés

  • SquillaRouter — Classifieur local LightGBM + ONNX qui route chaque tour sur quatre niveaux (T0–T3) vers le modèle le moins cher capable de le traiter. Classification sur machine.
  • Raisonnement adaptatif — Raisonnement étendu uniquement pour les tours complexes. Le prompt système s'adapte à la complexité de la tâche.
  • 20+ fournisseurs — OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Groq, Mistral, vLLM, LM Studio, etc., avec primaire + repli.
  • 15 compétences incluses — Chargement à la demande. Également client MCP et serveur MCP.
  • Mémoire persistante — Recherche plein texte SQLite + rappel sémantique via sqlite-vec. Embeddings sur machine.
  • Sandbox à 3 niveaux — Standard / Strict / Verrouillé. Isolation Bubblewrap sur Linux.
  • 10+ canaux — Terminal, interface Web, Slack, Telegram, Discord, Feishu, Matrix, et plus.

Ressources