# Nanobot | Artificialus > For the complete content index, see [llms.txt](https://artificialus.com/llms.txt). Markdown versions of all pages are available by appending `.md` to any URL. - Home - / - Agents - / - Nanobot NA # Nanobot Ultra-lightweight personal AI agent — WebUI, 10+ chat channels, MCP, model routing, memory, and skills HKUDS (project started by Xubin Ren) Open source Since 2026 Visit Website Repository Docs Share X Facebook Reddit Telegram Bluesky Email Nanobot is an ultra-lightweight, open-source (MIT) personal AI agent that ships with WebUI, multi-channel chat (Telegram, Discord, WeChat, Slack, Feishu, email), MCP support, memory, model routing with fallbacks, cron automation, and a plugin skill system — all pip-installable in seconds. Built on a deliberately small and readable Python core, it lets you truly own your AI agent stack. ## + Pros - Ultra-lightweight design — pip-installable in seconds with a deliberately small Python core that's readable and hackable (78% Python, ~3,000 commits of clean architecture) - Channel-first approach — native integration with 10+ chat platforms (Telegram, Discord, WeChat, Slack, Feishu, email, Matrix, DingTalk, QQ, WhatsApp, Signal) lets agents operate where you already work - Model routing with automatic fallbacks — configure multiple providers (OpenAI, Anthropic, Google, DeepSeek, local Ollama, and 20+ more) with cascading fallback models for resilience - Fully self-hosted and MIT licensed — complete ownership of your data, agent runtime, and infrastructure with no vendor lock-in, no usage quotas, no paid tiers - Built-in MCP (Model Context Protocol) support with extension registry for connecting external tools, APIs, and data sources ## − Cons - Very young project (first commit Feb 2026) — still in rapid pre-1.0 development with frequent breaking changes (v0.2.1 as of June 2026) - Configuration complexity — setting up providers, channels, and MCP requires editing JSON config files; the wizard helps but power-user features demand manual configuration - Python runtime dependency — requires Python 3.11+, which may be heavier than Go or Rust alternatives for lightweight deployments - Documentation spans both the GitHub repo docs and nanobot.wiki — can be disorienting to navigate between the two sources - No native mobile app — relies on chat channel integrations (Telegram, Discord, etc.) for mobile access; the WebUI is desktop-optimized ## Pricing ### Free (Open Source) $0 Full MIT-licensed self-hosted agent — no paid tiers, no usage limits, no feature gates. Requires your own API keys for LLM providers. ## Introduction Nanobot is an ultra-lightweight, open-source personal AI agent designed to be small, readable, and fully ownable. First committed in February 2026 and released under the MIT license, it has climbed to 44.2k GitHub stars, 7.8k forks, and over 2,900 commits in under five months — making it the fastest-growing personal AI agent framework. Nanobot's philosophy is deliberately contrarian. Instead of building a heavyweight orchestration layer, it centers everything on a small Python core where messages come in from chat apps, the LLM decides when tools are needed, and memory or skills are pulled in only as context. This keeps the core path readable and easy to extend. Channels, tools, memory, MCP, and deployment options are all optional plugins — not mandatory infrastructure. You get an agent you can `pip install` in seconds, configure in minutes, and run across 10+ chat platforms simultaneously — all from a single codebase you can fully inspect and modify. Nanobot doesn't lock you into a proprietary cloud or a single provider. You own the stack, you choose the models (with automatic fallbacks), and you decide where it runs. > "Small core, everything else is optional." — Nanobot's design philosophy. ## Key Features ### Ultra-Lightweight Python Core Nanobot's core agent loop is intentionally minimal. Messages flow in from any channel, the LLM processes them with access to tools and memory, and responses stream back. The core path is ~a few hundred lines of Python — readable enough for a single developer to understand and modify in an afternoon. The entire package is pip-installable: ``` `pip install nanobot-ai` ``` No Docker required. No Node.js. No heavy framework dependencies. The WebUI ships inside the published wheel — no separate build step. ### Multi-Channel Chat — "Agent as Coworker" Nanobot's channel-first approach is its key differentiator. Instead of forcing you into a specific interface, the agent operates where you already work: Channel Integration Telegram Full bot API, inline buttons, draft streaming, media messages Discord Thread sessions, channel allow-lists, long-message splitting WeChat QR/media resilience, voice, typing indicators Slack Thread isolation, file sending, reaction on completion Feishu (Lark) CardKit streaming, rich-text parsing, reply threading Email Send/receive via configured accounts, attachments Matrix End-to-end encrypted communication DingTalk Rich media, message replies Signal Secure messaging with media support QQ Group chats, media messages WhatsApp Media messages, deduplication WeCom (WeChat Work) Business communication Each channel maintains unified cross-channel sessions — conversations persist and context carries over no matter which platform you're using. ### Model Routing with Automatic Fallbacks Nanobot supports 20+ LLM providers and lets you configure model presets with cascading fallbacks: ``` `{ "modelPresets": { "primary": { " label ": "Primary" , "provider" : "openrouter" , "model" : "anthropic/claude-opus-4.5" , "maxTokens" : 8192 , "contextWindowTokens" : 65536 , "temperature" : 0.1 , "fallbackModels" : [ {"provider": "openai" , "model" : "gpt-5.4" }, {"provider": "anthropic" , "model" : "claude-sonnet-4.5" } ] } } }` ``` Supported providers include OpenAI, Anthropic, Google Gemini, DeepSeek, Mistral, Groq, xAI, Kimi, MiniMax, Moonshot, Hugging Face, Ollama, vLLM, Azure OpenAI, AWS Bedrock, OpenRouter, VolcEngine, StepFun, Zhipu, NVIDIA NIM, LM Studio, and more. Switch models mid-session without losing context. If the primary model is rate-limited, down, or slow, Nanobot automatically falls through to the next available model in the cascade. This makes it resilient for production and always-on use cases. ### MCP (Model Context Protocol) Support Nanobot supports MCP (Model Context Protocol) for connecting external tools, APIs, and data sources. Configure multiple MCP servers with custom authentication, SSE support, and an extension registry: - Connect databases, search engines, internal APIs - Register custom tools that the agent can discover and invoke - MCP resources and prompts are exposed as first-class tools - Works across all chat channels, not just the CLI The Unified CLI Apps and MCP system (introduced in v0.2.1) lets you register standalone command-line applications as agent-accessible tools, bridging the gap between traditional CLI utilities and the MCP ecosystem. ### Memory, Automation & Persistent Goals Nanobot is built for long-running, sustained workflows: - Token-based memory — relevant context persists across conversations without bloating the prompt - Dream two-stage memory — discovered skills and learned patterns are stored and recalled automatically - Cron automation — schedule recurring tasks in natural language ("Remind me every morning at 8 AM to review GitHub issues") - /goal system — set sustained objectives that the agent holds across multiple conversation turns, even across different channels and sessions - Context compaction — long conversations are automatically summarized and compressed to stay within context windows ### Built-in WebUI The WebUI ships inside the pip wheel and requires zero build steps: ``` ` { "channels" : { "websocket" : { "enabled" : true } } } ` ``` ``` ` nanobot gateway ` ``` Open http://127.0.0.1:8765 for a full chat interface with Thought/response timelines, file-edit activity, project workspaces, and model/context controls. The WebUI is i18n-ready with locale switching and supports LAN access. ### Skill Plugin System & Extensibility Nanobot's skill plugin system lets you add capabilities as on-demand packages: - Skill discovery — agents can find and learn new skills at runtime - ClawHub integration — search and install public agent skills from the ClawHub registry - Python SDK — programmatically interact with Nanobot from your own Python applications - OpenAI-compatible API — integrate Nanobot with any tool that speaks the OpenAI API format - Response templates — Jinja2-based templating for custom response formatting - Lifecycle hooks — composable hooks for agent start, turn, and tool events ## Architecture — The Small Core Philosophy Nanobot's architecture follows a deliberate "small core, everything else is optional" design philosophy. The runtime is organized around a minimal agent loop: ``` `Chat Channel (Telegram, Discord, WebUI, etc.) │ ▼ ┌──────────┐ │ Gateway │ Unified entry point , routes messages to the agent loop └────┬─────┘ │ ▼ ┌──────────┐ ┌──────────┐ │ Agent │────▶│ LLM │ Model routing + fallbacks │ Loop │◀────│ Provider │ └────┬─────┘ └──────────┘ │ ├──────────────────┬──────────────────┐ ▼ ▼ ▼ ┌────────┐ ┌────────────┐ ┌────────────┐ │ Tools │ │ Memory │ │ Skills │ │ (MCP, │ │ (Token/ │ │ (Plugins, │ │ CLI) │ │ Dream) │ │ ClawHub) │ └────────┘ └────────────┘ └────────────┘ │ ▼ ┌──────────┐ │ Channel │ Response streamed back to the originating channel │ Output │ └──────────┘` ``` > Key architectural principles: - > Minimal core — the agent loop is deliberately small and readable. Messages arrive, the LLM processes them with tools, and responses are streamed out. - > Everything is optional — channels, memory, MCP, skills, the WebUI. Each is a plug-in module that the core discovers and loads. You add only what you need. - > No heavy orchestration — unlike multi-agent frameworks with complex coordinator hierarchies, Nanobot keeps one agent loop with tool access. Latency stays low and code stays readable. - > Stateless gateway — the gateway streams requests to LLM providers over standard protocols. Your data stays local; only relevant context is sent to APIs. - > Unified channel sessions — cross-channel context means you can start a conversation in Telegram, continue it in the WebUI, and check results via email. The project structure reflects this philosophy: the `nanobot/` core package is small, while `bridge/` contains channel adapters, `webui/` contains the frontend, and `docs/` contains documentation. Each major subsystem is independently testable and replaceable. ## Use Cases ### Always-On Personal Assistant Deploy Nanobot on a VPS or Raspberry Pi and connect it to Telegram, Discord, and Slack. Use it as your always-on personal assistant — researching topics, managing schedules, monitoring GitHub issues, and answering questions across all your chat platforms simultaneously. ### Multi-Platform Engineering Companion Software teams run Nanobot connected to Slack and email, configured with GitHub and MCP tools. Developers ask questions about codebases, trigger CI/CD pipelines, and get code reviews — all from within their existing chat channels without switching context. ### Automated News & Research Monitor Configure Nanobot with web search tools, RSS-reading skills, and cron automation for daily digests. The agent fetches, summarizes, and delivers personalized news briefings to your preferred channel every morning — and can dive deeper on request. ### Personal Knowledge Base With Dream memory and persistent sessions, Nanobot functions as an extensible knowledge base. Feed it documents, have conversations about them, and revisit insights weeks later. The memory system preserves context without manual tagging or folder management. ### Home Automation Hub Run Nanobot alongside local LLMs via Ollama or vLLM . Connect it to home automation MCP servers, schedule reminders, control smart devices through natural language, and manage your daily routine — all from a single agent runtime. ## Pricing Nanobot is 100% free and open source under the MIT license. There are no paid tiers, no feature gates, no usage quotas, no cloud subscription, and no enterprise upsell. The only cost is the infrastructure you choose: - LLM API costs — you pay for the models you use (your own API keys for OpenAI, Anthropic, Google, etc., or run local models via Ollama for free) - Hosting — run on your own machine, a $5/mo VPS, or a Raspberry Pi - No hidden costs — no per-seat pricing, no message quotas, no premium features This is a genuinely open-source project started by Xubin Ren as a personal endeavor and sustained by community contributions. The MIT license means you can use, modify, and distribute Nanobot for any purpose — personal, commercial, or otherwise. ## Getting Started ### Prerequisites - Python 3.11 or newer - An API key from your preferred LLM provider ( OpenRouter recommended for easy multi-model access) - Git (only needed for source install) ### One-Command Setup (macOS/Linux) ``` `sh -c " $(curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh) " ` ``` ### One-Command Setup (Windows PowerShell) ``` `irm https: // raw.githubusercontent.com /HKUDS/ nanobot /main/ scripts/install.ps1 | iex` ``` ### Install from PyPI ``` `pip install nanobot-ai` ``` ### Initialize and Configure ``` ` # Run the interactive setup wizard nanobot onboard --wizard # Or initialize manually nanobot onboard` ``` The wizard walks you through selecting a provider, entering your API key, and choosing a model. Configuration is saved to `~/.nanobot/config.json`. ### Test the Agent ``` ` # Check status nanobot status # Send a single message nanobot agent -m "Hello! What can you do?" # Start an interactive CLI session nanobot agent` ``` ### Enable the WebUI Add this to `~/.nanobot/config.json`: ``` ` { "channels" : { "websocket" : { "enabled" : true } } } ` ``` Then start the gateway: ``` ` nanobot gateway ` ``` Open http://127.0.0.1:8765 in your browser. ### Connect a Chat Channel Each channel has specific configuration. For example, to connect Telegram: ``` ` { "channels" : { "telegram" : { "enabled" : true , "botToken" : "your-bot-token-from-BotFather" } } } ` ``` See the Chat Apps documentation for full channel setup guides. ### Upgrade ``` `pip install --upgrade nanobot-ai ` ``` Or use the one-command installer again for automatic upgrades. ## Further Reading - Nanobot GitHub Repository — Source code, issues, discussions, and community contributions - Nanobot Documentation — Official docs with guides, concepts, and configuration reference - Install and Quick Start — Detailed setup walkthrough for developers - Start Without Technical Background — Guided setup for non-developers - Chat Apps Documentation — Full channel integration guides - Configuration Reference — Providers, MCP, web search, security, and runtime settings - Architecture Overview — Source-level map of the codebase - Provider Cookbook — Pasteable provider setup recipes - Python SDK Documentation — Programmatic integration for Python applications - Nanobot on X (Twitter) — Project announcements and updates - Nanobot Discord Community — Community discussions and support ## Version History v0.2.1 Jun 1, 2026 The Workbench Release — packaged WebUI becomes a daily agent workbench with clearer Thought/response timelines, live file-edit activity, project workspaces, model and context controls, CLI Apps + MCP extensions, and broader provider/channel support v0.2.0 May 15, 2026 The /goal Release — sustained objectives across turns, WebUI ships inside the wheel, image generation end to end, 5 new providers with fallback_models, agent-loop refactor v0.1.5.post3 Apr 29, 2026 Smarter threads on Feishu, Discord, Slack, and Teams; DeepSeek-V4 support; Hugging Face and Olostep providers; /history command v0.1.5 Apr 5, 2026 Sturdier long-running tasks, Dream two-stage memory, production-ready sandboxing and programming Agent SDK v0.1.4.post6 Mar 27, 2026 Architecture decoupling, litellm removal, end-to-end streaming, WeChat channel, security fix v0.1.4 Feb 17, 2026 MCP support, progress streaming, new providers, multiple channel improvements Best for Developers and power users who want a self-hosted, channel-native personal AI agent they can inspect, customize, and own Capability Ultra-lightweight Python core (pip install in seconds) · Multi-channel chat (Telegram, Discord, WeChat, Slack, Feishu, email, and more) · MCP support with extension registry · Model routing with automatic fallbacks · Built-in WebUI, memory, cron automation, and skill plugins · 44.2k GitHub stars in under 5 months Runs on CLI · WebUI · Telegram · Discord · WeChat · Slack · Feishu · Email · Matrix · DingTalk · QQ · WhatsApp · Signal · WeCom Signature Snippet Copy ``` `pip install nanobot-ai\nnanobot onboard --wizard\n# Configure API key for your preferred provider\nnanobot agent -m \"Summarize the latest AI research papers about agent frameworks\"\n\n# Or start an interactive session\nnanobot agent\n\n# Enable WebUI\nnanobot gateway\n# Open http://127.0.0.1:8765 in your browser\n\n# Connect Telegram or Discord\n# Edit ~/.nanobot/config.json, add channel config, restart\nnanobot gateway` ``` ## More in this Space PA ### Paca Open source Paca is a free, open-source, self-hosted Scrum board where AI agents work as equal teammates — assigned to sprints, picking up tasks, and collaborating on BDD specs alongside humans. Built as an alternative to Jira and Linear, it treats AI agents as first-class Scrum members. View profile AI ### AionUi Open source AionUi is a free, open-source Cowork desktop app that runs Claude Code, Codex, Gemini CLI, OpenClaw, Hermes Agent, and 20+ more coding agents side-by-side within a unified Electron interface. It auto-detects installed CLI agents, provides a built-in AI engine with 30+ provider support, and adds Team Mode for multi-agent orchestration — all from one desktop workspace. View profile CU ### Cua Open source Cua is an open-source (MIT) infrastructure platform for building, benchmarking, and deploying computer-use agents. It provides background desktop control via Cua Driver, ephemeral multi-OS sandboxes via Cua Sandbox, standardized benchmarks via Cua Bench, and macOS virtualization via Lume — all accessible through a unified Python/TypeScript SDK, MCP server, and CLI. View profile