OpenSquilla

OpenSquilla is a token-efficient, microkernel AI agent that routes each prompt to the cheapest model that can actually handle it. It came out of the For You feed where a user reported running two fresh projects with fixed-model versus smart-routing setups and seeing token count rise 18.9% while cost still fell 19.2%, because what you pay depends on which tier each turn hits. Under Apache 2.0 and self-hostable, it bundles persistent memory, a layered sandbox, built-in web search, and local embeddings into a single shared turn loop.

Key Features

• Smart routing: an ML router ranks candidate models per turn, sending simple prompts to cheap tiers and complex ones up; hybrid feature analysis combines hand-crafted signals with embedding-based semantic features.
• Multi-model ensemble: hard problems dispatch to several candidates and aggregate their answers, beating any single model; cost-aware fallback skips the ensemble when one model suffices.
• Microkernel architecture: a compact core orchestrator (~100 lines) with 5-layer separation; capabilities are pluggable, and errors auto-skip and roll back.
• Persistent four-tier memory: accumulates context so an agent never starts from zero.
• Local embeddings: ONNX on-device inference (offline, data stays local) with optional OpenAI or Ollama backends.
• Wide channel reach: terminal, web, Slack, Discord, Telegram, MS Teams, Matrix, Lark, DingTalk, WeCom, and QQ from one configured agent.
• Durable scheduling: SQLite-backed sessions and a CronExpression-parsing scheduler for timed tasks.

Use Cases

Who Should Use This Tool?

• On-prem teams that need fully offline routing where data never leaves their network.
• Compliance-heavy orgs that want three-tier policies plus hashed decision logs and human approval gates.
• Budget-constrained builders who run more tasks for the same cost by letting a router pick the most cost-effective model.
• Multi-channel operators who want one agent reachable on many chat platforms at once.

Problems It Solves

1. Wasteful frontier calls: expensive models on easy tasks is the single largest avoidable cost in agent stacks.
2. Single-model ceiling: one model cannot cover both cheap and hard tasks well; routing and ensembling widen the cost-quality frontier.
3. Data-spill risk: local routing and on-device embeddings keep sensitive work inside the perimeter.

Pricing

The 60-80% token-cost-savings figure is the project's own claim, and the OpenSquilla team notes that side-by-side comparisons against OpenClaw and Hermes Agent are their own benchmarks, so treat them as directional rather than audited.

Advantages & Unique Selling Points

1. Content-aware selection: unlike config-pinned fallback chains, OpenSquilla chooses per-turn based on task complexity and harness state.
2. Ensemble with cost fallback: multi-model aggregation raises quality, but skips the heavy run when one model is enough.
3. Self-hostable and offline: the ML router runs locally, so routing decisions can stay inside your network.

Getting Started

1. Clone the repo and install from source or fetch a release package.
2. Configure providers: the provider layer speaks to OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Qwen/DashScope, and roughly twenty others.
3. Start the console: terminal (agent), web UI, or pick a chat channel.
4. Turn on routing: the router decides the tier per turn; optionally enable the ensemble for hard problems.

First-party resources: the OpenSquilla website, the GitHub repository, and the feature catalog.

Frequently Asked Questions

Is OpenSquilla a model or a framework?

It is a framework/runtime. It routes to whatever models you configure; it does not train its own weights.

Can it run fully offline?

Yes. ML routing and ONNX embeddings run locally; the optional web search and hosted providers are the only parts that leave the machine.

How does it compare to OpenClaw?

OpenSquilla's own table positions itself as microkernel with ML routing versus OpenClaw's plugin ecosystem with a config-pinned primary-and-fallback chain. Those are vendor claims; test on your own tasks.

What providers are supported?

OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Qwen/DashScope, and about twenty others, without schema changes.

Alternatives

• LangGraph: a graph-based agent framework for explicit control flow.
• CrewAI: a role-based multi-agent framework.
• OpenCode: an agent CLI focused on coding workflows.

Tips & Best Practices

1. Enable the ensemble only when needed: cost-aware fallback exists so you do not pay for aggregation every turn.
2. Declare a provider budget: routing per-turn is only useful if you also set limits on the spend tiers you are willing to hit.
3. Read the vendor comparisons as direction: the savings and quality deltas come from OpenSquilla's own side-by-sides.

Conclusion

OpenSquilla is for teams who already believe most turns do not need a frontier model. It packages routing, memory, sandboxing, search, and channel support into one self-hostable runtime, with an Apache 2.0 core you can inspect. If your pain is a fixed model plan burning credits on trivial questions, routing is the cheapest structural fix, and OpenSquilla makes it configurable and local.