OpenSquilla - An open-source microkernel AI Agent framework that reduces Token costs

What is OpenSquilla

OpenSquilla is an open-source, self-hostable Token-efficient microkernel AI Agent runtime, focused on "the same budget, higher intelligence density." It adopts a minimalist microkernel architecture (the core is only about 100 lines of code) and, through local ML model routing, adaptive reasoning depth, a four-layer cognitive memory system, and on-demand skill loading, can reduce Token costs by 60-80%. It supports 20+ mainstream LLM providers such as OpenAI, Anthropic, DeepSeek, and Gemini, and includes a layered security sandbox, a multi-channel unified gateway (Web/Slack/Feishu/DingTalk, etc.) and a rich toolset, and also provides migration tools from OpenClaw and Hermes Agent.

Main features of OpenSquilla

• SquillaRouter intelligent routing: A local LightGBM + ONNX classifier that combines message length, language, code blocks, keywords, and semantic embedding scores to automatically route tasks to the cheapest available model among the four tiers T0-T3, with the classification process completed entirely locally on the device.
• Adaptive reasoning depth: Enables deep reasoning only for complex queries, while simple questions do not consume reasoning Tokens; the system Prompt automatically scales according to task complexity to avoid excessive consumption.
• Unified access to multiple LLM providers: Supports 20+ providers such as OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Qwen/DashScope, Moonshot, Mistral, and Groq, and supports automatic switching between a primary model and a backup model.
• Four-layer cognitive memory architecture: Working memory, episodic memory, semantic memory, and raw memory, supporting vector semantic retrieval (sqlite-vec) + BM25 keyword search + automatic memory decay and "bubbling" promotion + dream mode (automatically distilling new skill candidates when idle).
• MetaSkills composable workflows: Supports composable workflow orchestration, self-service creation with meta-skill-creator, automatic retrieval of 10+ built-in and N+ community Skills, and supports Replay playback and self-evolution in Dream mode.
• Layered security sandbox: Three policy levels, Standard/Strict/Locked. On Linux it uses Bubblewrap system-call-level isolation (CPU/memory/duration/network), and can be deployed to Serverless environments without Docker.
• Unified gateway and multi-channel access: A local gateway based on Starlette ASGI (default127.0.0.1:18791), with Web UI, CLI, Slack, Discord, Telegram, Feishu, DingTalk, WeCom, QQ, Matrix, etc. sharing the same TurnRunner loop.
• Rich built-in toolset: File reading, writing, and editing, Shell and background processes, Git, web search (Brave/DuckDuckGo), SSRF protection, PPT/Word/Excel/PDF generation, image generation, TTS, etc.
• Cost tracking and quota management: Summarizes Tokens and costs per turn/session, and built-in quota hooks can automatically throttle to prevent overspending, enabling fine-grained cost control.
• Microkernel plugin architecture: The core orchestrator is only about 100 lines of code, responsible for the state machine and pipeline orchestration; all capabilities (Provider, Memory, Channels, Tools, Sandbox, etc.) run as plugins in "user space," and plugin crashes do not affect the core.

Follow WeChat and reply "Open Source”" to join theAI Open Source Project Communication Group

How to use OpenSquilla

• Environment preparation and installation: Make sure the system has Python 3.12+ installed, and via uv One-click tool installation of OpenSquilla (current version 0.3.1), supporting Windows, macOS, and Linux across all platforms.
• Initialize configuration: run opensquilla onboard to complete the first-time guided setup, including setting the default LLM provider, API Key, memory storage path, and security sandbox policy (Standard/Strict/Locked).
• Start the local gateway: execute opensquilla gateway run to start the unified gateway based on Starlette ASGI, listening by default on 127.0.0.1:18791, and visit in the browser http://127.0.0.1:18791/control/ to enter the Web console.
• Configure multiple LLM providers: add API Keys for 20+ providers such as OpenAI, Anthropic, DeepSeek, Gemini, Qwen, and Moonshot in the console or configuration file, set the primary and backup models, and enable automatic routing by SquillaRouter.
• Interact via the Web UI: enter tasks directly in the console; the system automatically completes model routing, reasoning depth determination, memory retrieval, and tool invocation, and displays real-time token consumption and cost for each round.
• Connect multi-channel platforms: configure Webhooks or Bot Tokens for channels such as Slack, Discord, Telegram, Feishu, DingTalk, WeCom, QQ, and Matrix to enable multiple platforms to share the same Agent capabilities.
• Use and create MetaSkills: call built-in Skills to handle common tasks, or use meta-skill-creator to self-create composable workflows; enable Dream mode to let the system automatically distill new skill candidates when idle.
• Manage memory and context: the system automatically maintains a four-layer architecture of working memory, episodic memory, semantic memory, and raw memory; it supports manually viewing and editing memory entries, and configuring automatic decay and bubble promotion strategies.
• Configure the security sandbox: in a Linux environment, enable Bubblewrap system-call-level isolation to limit CPU, memory, execution time, and network access, allowing Shell and file operations to be executed safely without Docker.
• Monitoring and quota management: view token and cost summaries per round/session in the console, and set quota thresholds to automatically throttle and prevent budget overruns.
• Data migration (optional): if migrating from OpenClaw or Hermes Agent, use the official migration tool to import memories, persona files, Skills, and channel configurations, preview and handle conflicts.

OpenSquilla's official website address

• Project official website：https://opensquilla.ai/zh/ or https://opensquilla.ai/
• GitHub repository：https://github.com/opensquilla/opensquilla

OpenSquilla's core advantages

• 60-80% reduction in Token cost: through local ML intelligent routing, adaptive reasoning depth, automatic Prompt scaling, and on-demand skill loading, it achieves higher intelligence density under the same budget.
• Minimal microkernel architecture: the core orchestrator is only about 100 lines of code, and all capabilities run in user space as plugins; a single plugin crash does not affect the core, and core upgrades do not break plugins.
• Local intelligent model routing: SquillaRouter completes scoring locally on the device based on a LightGBM+ONNX classifier, automatically assigning tasks to the cheapest available model among the four tiers T0-T3, with zero cloud routing overhead.
• Four-layer cognitive memory system: Layered management of working memory, episodic memory, semantic memory, and raw memory, supporting vector retrieval + BM25 keyword search + automatic decay and "bubbling" promotion, so memory becomes more accurate the more it is used.
• Adaptive Reasoning and Prompt: Deep reasoning is enabled only for complex queries, with zero reasoning token consumption for simple questions; the system Prompt automatically scales according to task complexity, avoiding excessive invocation.
• System-level secure sandbox: On Linux, Bubblewrap is used to achieve syscall-level isolation of CPU/memory/duration/network, enabling secure deployment to Serverless environments without Docker.
• Multi-channel unified gateway: A local gateway based on Starlette ASGI; Web UI, CLI, Slack, Discord, Telegram, Feishu, DingTalk, WeCom, etc. share the same TurnRunner loop, covering all platforms with a single deployment.
• MetaSkills self-evolution: Supports composable workflows, self-service creation, and automatic community retrieval, and works with dream mode to automatically distill new skill candidates during idle time, enabling continuous evolution of Agent capabilities.

Comparison of OpenSquilla's similar competitors

OpenSquilla's application scenarios

• Low-cost AI assistant for individuals and developers: Using SquillaRouter intelligent routing and adaptive reasoning, it reduces token costs by 60-80%, making it suitable as a daily AI assistant for programming, writing, and Q&A for budget-constrained individual developers, independent creators, or students.
• Enterprise multi-platform intelligent customer service and office assistant: Through the unified gateway, it simultaneously connects to multiple channels such as Feishu, DingTalk, WeCom, Slack, and Discord. One set of Agent capabilities covers the entire company's communication platforms, automatically handling internal inquiries, ticket routing, and knowledge Q&A.
• Private AI deployment for highly sensitive data scenarios: Supports fully self-hosted and local operation, with four-layer memory data stored locally. Combined with the Bubblewrap system-level secure sandbox, it is suitable for industries such as finance, healthcare, and law that have extremely high requirements for data privacy and compliance.
• Automated Workflows and Task Orchestration: With MetaSkills composable workflows and built-in toolset (file editing, Git, web search, document generation), automate repetitive work such as automatic report generation, code review, data scraping, and batch PPT/Excel processing.
• Multi-Model Strategy Management and A/B Testing: Connect to 20+ LLM providers simultaneously and configure primary and backup models. Enterprises can dynamically allocate model resources based on task complexity, and it can also be used for performance comparison and cost optimization experiments between different models.
• Serverless and Edge Computing Deployment: The microkernel architecture is lightweight, and the secure sandbox can run without Docker, making it suitable for deployment on Serverless function computing or edge devices as a low-resource embedded AI service.