Your Digital Companion. Not a Tool. A Partner.
Self-hosted, asynchronous Telegram bot that orchestrates multiple AI providers, tools, and sub-agents to get real work done.

🌍 Read this in other languages:
Español • Português (Brasil) • Українська • Bahasa Indonesia • Türkçe • Русский • 日本語 • 繁體中文 • 简体中文

Chibi is built for the moment you realize you need more than “an AI tool.” You need a partner that can coordinate models, run work in the background, and integrate with your systems - without you babysitting prompts.

Chibi is an asynchronous, self-hosted Telegram-based digital companion that orchestrates multiple AI providers and tools to deliver outcomes: code changes, research syntheses, media generation, and operational tasks.

Why Chibi

One interface (Telegram). Mobile/desktop/web, always with you.
Provider-agnostic. Use the best model for each task - without vendor lock-in.
Autonomous execution. Sub-agents work in parallel; long tasks run asynchronously.
Tool-connected. Filesystem + terminal + MCP integrations (GitHub, browser, DBs, etc.).
Self-hosted. Your data, your keys, your rules.

Supported AI providers (and endpoints)

Chibi supports multiple providers behind a single conversation. Add one key or many - Chibi can route per task.

LLM providers

OpenAI (GPT models)
Anthropic (Claude)
Google (Gemini)
DeepSeek
Alibaba Cloud (Qwen)
xAI (Grok)
Mistral AI
Moonshot AI
MiniMax
ZhipuAI (GLM models)
Cloudflare Workers AI (many open-source models)

OpenAI-compatible endpoints (self-host / local)

Ollama
vLLM
LM Studio
Any OpenAI-compatible API

Multimodal providers (optional)

Images: Google (Imagen, Nano Banana), OpenAI (DALL·E), Alibaba (Qwen Image), xAI (Grok Image), Wan, ZhipuAI (CogView), MiniMax
Music: Suno
Voice: ElevenLabs, MiniMax, OpenAI (Whisper)

Exact model availability depends on your configured provider keys and enabled features.

🚀 Quick Start (pip)

Install Chibi via pip and run it as a command-line application:

# Install the package
pip install chibi-bot

# Set up the agent (add API keys, update settings, etc)
chibi config

# Start the bot
chibi start

The bot will run as a background service. Use CLI commands to manage it.

CLI Commands

Command	Description
`chibi start`	Start the bot as a background service
`chibi stop`	Stop the running bot
`chibi restart`	Restart the bot
`chibi config`	Generate or edit configuration
`chibi logs`	View bot logs

🚀 Quick start (Docker)

Create docker-compose.yml:

version: '3.8'

services:
  chibi:
    image: pysergio/chibi:latest
    restart: unless-stopped
    environment:
      TELEGRAM_BOT_TOKEN: ${TELEGRAM_BOT_TOKEN}  # Required
      OPENAI_API_KEY: ${OPENAI_API_KEY}          # Or any other provider
      # Add more API keys as needed
    volumes:
      - chibi_data:/app/data

volumes:
  chibi_data: {}

Get a bot token from @BotFather
Put secrets into .env
Run:

docker-compose up -d

Installation guide: https://chibi.bot/installation
Configuration reference: https://chibi.bot/configuration

🔑 Getting API Keys

Each provider requires its own API key. Here are the direct links:

Major Providers:

OpenAI (GPT, DALL·E): platform.openai.com/api-keys
Anthropic (Claude): console.anthropic.com
Google (Gemini, Nano Banana, Imagen, Voice): aistudio.google.com/apikey
DeepSeek: platform.deepseek.com
xAI (Grok): console.x.ai
Alibaba (Qwen, Wan): modelstudio.console.alibabacloud.com
Mistral AI: console.mistral.ai
Moonshot (Kimi): platform.moonshot.cn
MiniMax (Voice, MiniMax-M2.x): minimax.io
ZhipuAI (GLM, CogView): z.ai/manage-apikey/apikey-list
Cloudflare Workers AI: dash.cloudflare.com/profile/api-tokens

Creative Tools:

ElevenLabs (Voice): elevenlabs.io
Suno (Music, unofficial): sunoapi.org

📖 Full guide with setup instructions: chibi.bot/guides/get-api-keys

Try this in the first 5 minutes

Paste these into Telegram after you deploy.

Planning + execution

Ask me 3 questions to clarify my goal, then propose a plan and execute step 1.

Parallel work (sub-agents)

Spawn 3 sub-agents: one to research options, one to draft a recommendation, one to list risks. Return a single decision.

Agent mode (tools)

Inspect the project files and summarize what this repo does. Then propose 5 improvements and open a checklist.

Background task

Start a background task: gather sources on X and deliver a synthesis in 30 minutes. Keep me updated.

What makes Chibi different

🎭 Multi-provider orchestration

Chibi can keep context while switching providers mid-thread, or choose the best model per step - balancing cost, capability, and speed.

🤖 Autonomous agent capabilities

Recursive delegation: spawn sub-agents that can spawn their own sub-agents
Background processing: long-running tasks execute asynchronously
Filesystem access: read/write/search/organize files
Terminal execution: run commands with LLM-moderated security
Persistent memory: conversation history survives restarts with context management/summarization

🔌 Extensible via MCP (Model Context Protocol)

Connect Chibi to external tools and services (or build your own):

GitHub (PRs, issues, code review)
Browser automation
Docker / cloud services
Databases
Creative tools (Blender, Figma)

If a tool can be exposed via MCP, Chibi can learn to use it.

🎨 Rich content generation

Images: Nano Banana, Imagen, Qwen, Wan, DALL·E, Grok
Music: Suno (including custom mode: style/lyrics/vocals)
Voice: transcription + text-to-speech (ElevenLabs, MiniMax, OpenAI)

Use cases

Developers

You: “Run the tests and fix what’s broken. I’ll work on the frontend.”
Chibi: *spawns sub-agent, executes tests, analyzes failures, proposes fixes*

Researchers

You: “Research the latest developments in quantum computing. I need a synthesis by tomorrow.”
Chibi: *spawns multiple research agents, aggregates sources, delivers a report*

Creators

You: “Generate a cyberpunk cityscape and compose a synthwave track to match.”
Chibi: *generates an image, creates music, delivers both*

Teams

You: “Review this PR and update the documentation accordingly.”
Chibi: *analyzes changes, suggests improvements, updates docs via MCP*

Privacy, control, and safety

Self-hosted: your data stays on your infrastructure
Public Mode: users can bring their own API keys (no shared master key required)
Access control: whitelist users/groups/models
Storage options: local volumes, Redis, or DynamoDB
Tool safety: agent tools are configurable; terminal execution is moderated and can be restricted

Documentation

Start here: https://chibi.bot
Introduction & philosophy: https://chibi.bot/introduction
Installation: https://chibi.bot/installation
Configuration: https://chibi.bot/configuration
Agent mode: https://chibi.bot/agent-mode
MCP guide: https://chibi.bot/guides/mcp
Support / troubleshooting: https://chibi.bot/support

System requirements

Minimum: Raspberry Pi 4 / AWS EC2 t4g.nano (2 vCPU, 512MB RAM)
Architectures: linux/amd64, linux/arm64
Dependencies: Docker (and optionally Docker Compose)

Contributing

Issues: https://github.com/s-nagaev/chibi/issues
PRs: https://github.com/s-nagaev/chibi/pulls
Discussions: https://github.com/s-nagaev/chibi/discussions

Please read CONTRIBUTING.md before submitting.

License

MIT - see LICENSE.

Ready to meet your digital companion?
Get Started →