Kai is a free, open source ai interaction & interfaces project written in Kotlin and released under Apache-2.0. It has 1,330 GitHub stars, 211 forks and 127 open issues, and was last pushed 10 days ago. On this registry it ranks #126 of 156 tracked projects in AI Interaction & Interfaces, with 5 head-to-head comparisons available. It gained 62 stars over the last 30 tracked days.

What is Kai?

Kai 9000 is an Apache-2.0 licensed, open-source AI assistant written in Kotlin that runs with persistent memory across Android, iOS, Windows, macOS, Linux, and the web, built for people who want a personal assistant that keeps its context and works on their own devices.

What it is

Kai 9000 is a Kotlin Multiplatform application, built with Jetpack Compose on the Android side and shipped as a native app for Android, iOS, Windows, macOS, and Linux, plus a browser client at kai9000.com/app. It behaves as a chat assistant with a persistent memory store: conversations and remembered details are kept locally under encryption, and memories are stored and recalled automatically once a memory reaches a hit count of five. An editable system prompt, called the soul in the project's own vocabulary, defines the assistant's personality and behaviour.

The concrete problem it addresses is the chat-only, vendor-hosted assistant. Kai connects to 29 LLM providers through an OpenAI-compatible interface with automatic failover, so a single provider outage or missing credential does not end the session, and it can run inference entirely on-device on Android through LiteRT with no internet connection. It is positioned as an alternative to OpenClaw, and it goes past text generation by letting the model call tools, render interactive screens, and on Android execute real shell commands inside a sandboxed Linux userland.

Key capabilities

  • Persistent memory that stores important details during conversations and applies them automatically in later ones, triggered once a memory's hit count reaches five.
  • Multi-service fallback across 29 LLM providers with automatic failover, exposed through an OpenAI-compatible interface.
  • On-device inference on Android using LiteRT, so models can run locally without a network connection.
  • Tool execution covering web search, notifications, calendar events, and shell commands, plus connections to remote tool servers over the Model Context Protocol (MCP).
  • Linux Sandbox on Android: an Alpine Linux userland of roughly 3 MB installed via proot without root, with one-tap optional packages for bash, curl, wget, git, jq, python3, pip, and Node.js, and a built-in interactive terminal.
  • Interactive UI that generates full screens such as quizzes, dashboards, recipes, and brainstorms, navigated by tapping buttons rather than scrolling chat.
  • Encrypted local conversation storage, text to speech, image attachments, an autonomous heartbeat that surfaces anything needing attention, and settings export and import as a JSON file.

Who uses it and how

  • Android users who want a private assistant with local model inference via LiteRT and no dependency on a live connection.
  • Mobile users installing from the Play Store, the App Store, or F-Droid, including F-Droid users who need the build distributed outside proprietary stores.
  • Desktop users installing through package managers or direct downloads: Homebrew cask for macOS, Winget for Windows, AUR for Arch Linux, and DMG, MSI, DEB, RPM, or AppImage artefacts from GitHub Releases.
  • Browser users who run the same assistant through the hosted web client at kai9000.com/app without installing anything.
  • Power users who connect remote MCP tool servers and use the Android Linux Sandbox to install packages, run Python scripts, and process data as part of an assistant workflow.

Getting started

Install from a store or package manager: brew install --cask simonschubert/tap/kai, yay -S kai-bin, or winget install SimonSchubert.Kai, or use the App Store, Play Store, F-Droid, or the web app at kai9000.com/app. Direct downloads are published on GitHub Releases as APK, DMG, MSI, DEB, RPM, and AppImage, and the Linux Sandbox is enabled under Settings > Linux Sandbox.

How it compares

The project defines itself as an OpenClaw alternative, and the two occupy the same slot as a self-directed assistant rather than a hosted chat product. Kai differentiates along portability and provider neutrality: the same client targets Android, iOS, Windows, macOS, Linux, and the web, it speaks an OpenAI-compatible interface so it is not tied to one model vendor, and it can run inference on-device on Android with LiteRT instead of depending on a remote endpoint.

When to use it — and when not to

Choose Kai if the assistant should live on the user's own hardware with encrypted local conversation storage and provider failover across many LLM backends, and if Android is an acceptable target for local inference and the Linux Sandbox. Do not choose it expecting those agentic capabilities everywhere: LiteRT on-device inference and the proot-based Linux environment are Android-only, and the sandbox adds a download plus optional package installs before it does anything useful. The repository also carries 127 open issues, so features around memory and tool execution should be treated as active work rather than settled ground.

project readme (upstream, from github) — read inline

Kai 9000

Web Android iOS Platform JVM




An open-source AI assistant with persistent memory that runs on Android, iOS, Windows, Mac, Linux, and Web.

Website - Documentation


Sponsor: Atlas Cloud

Atlas Cloud

Installation

App Store Play Store F-Droid Web

Homebrew (macOS):

brew install --cask simonschubert/tap/kai

AUR (Arch Linux):

yay -S kai-bin

Winget (Windows):

winget install SimonSchubert.Kai

Direct Downloads

Platform Format Download
Android APK GitHub Releases
macOS DMG GitHub Releases
Windows MSI GitHub Releases
Linux DEB GitHub Releases
Linux RPM GitHub Releases
Linux AppImage GitHub Releases

AI That Builds Screens, Not Just Text

Kai 9000's Interactive UI lets the AI generate full interactive screens — quizzes, dashboards, recipes, brainstorms, and more. Navigate by tapping buttons instead of scrolling through chat.

Features

  • Persistent memory — Kai remembers important details across conversations and uses them automatically
  • Customizable soul — Define the AI's personality and behavior with an editable system prompt
  • Multi-service fallback — 29 LLM providers with automatic failover
  • On-device inference — Run AI models locally on Android using LiteRT, no internet needed
  • Tool execution — Web search, notifications, calendar events, shell commands, and more
  • MCP server support — Connect to remote tool servers via the Model Context Protocol
  • Autonomous heartbeat — Periodic self-checks that surface anything needing attention
  • Settings export/import — Backup and restore all settings as a JSON file
  • Encrypted storage — Conversations stored locally with encryption
  • Text to speech — Listen to AI responses
  • Linux Sandbox — On Android, the AI can run shell commands, scripts, and tools in a secure sandboxed Linux environment
  • Image attachments — Attach images to any conversation

Linux Sandbox (Android)

On Android, Kai includes a built-in Linux environment that the AI can use to execute shell commands, run scripts, and operate tools on your behalf. This turns Kai from a chat-only assistant into one that can take real action — installing packages, processing data, running Python scripts, and more.

  • Powered by Alpine Linux — A lightweight ~3 MB download sets up a full Linux userland via proot, no root required
  • Optional packages — One tap installs bash, curl, wget, git, jq, python3, pip, and Node.js
  • Interactive terminal — A built-in terminal lets you run commands manually alongside the AI
  • Secure — Everything runs sandboxed inside the app with no access to the host system

Enable it in Settings > Linux Sandbox.

Screenshots

Desktop

Web

Mobile

How It Works

                        ┌────────┐
                        │  User  │
                        └───┬────┘
                            │ message
                            ▼
               ┌─────────────────────────┐
               │          Chat           │
               │                         │
               │  prompt + memories      │
               │        │                │
               │        ▼                │
               │    ┌────────┐           │
               │    │   AI   │◀─┐        │
               │    └───┬────┘  │        │
               │        │   tool calls   │
               │        │   & results    │
               │        ▼      │        │
               │    ┌────────┐ │        │
               │    │ Tools  │─┘        │
               │    └───┬────┘          │
               │        │               │
               └────────┼───────────────┘
                        │ store / recall
                        ▼
               ┌─────────────────┐    hitCount >= 5
               │     Memory      │───────────────────┐
               │                 │                   │
               │  facts, prefs,  │                   ▼
               │  learnings      │          ┌────────────────┐
               │                 │◀─delete──│ Promote into   │
               └─────────────────┘          │ System Prompt  │
                        ▲                   └────────────────┘
                        │ reviews
                        │
               ┌─────────────────┐
               │    Heartbeat    │
               │                 │
               │  autonomous     │
               │  self-check     │
               │  every 30 min   │
               │  (8am–10pm)     │
               │                 │
               │  all good?      │
               │  → stays silent │
               │  needs action?  │
               │  → notifies user│
               └─────────────────┘
  • Chat — User sends a message. The AI responds, calling tools (memory, web search, shell, etc.) in a loop until it has a final answer.
  • Memory — The AI stores and recalls facts, preferences, and learnings. Memories that prove useful (5+ hits) can be promoted into the system prompt permanently.
  • Heartbeat — A background self-check runs every 30 minutes. It reviews memories, pending tasks, and emails. If something needs attention, it notifies the user. Otherwise, it stays silent.

Supported Services

Atlas Cloud · Anthropic · OpenAI · Gemini · DeepSeek · Mistral · xAI · OpenRouter · Groq · NVIDIA · Cerebras · Ollama Cloud · LongCat · Together AI · Hugging Face · Venice AI · Moonshot AI · Z.AI · MiniMax · AIHubMix · Deep Infra · Fireworks AI · OpenCode · AI Horde · Perplexity · OpenAI-Compatible API · LiteRT On-Device (Android) · Free tier (no API key needed)

MCP Servers

Kai supports the Model Context Protocol for connecting to external tool servers. Go to Settings > Tools > Add MCP Server to connect to any Streamable HTTP MCP endpoint, or pick from a curated list of popular free servers:

Server Description
Context7 Up-to-date library and framework docs
MDN Web docs, search, and browser compatibility
DeepWiki AI-powered docs for any GitHub repo
Parallel Search Realtime web search and content extraction
Yahoo Finance Stock data, market news, and price history
CoinGecko Real-time crypto prices and market data
Jina AI Convert URLs to markdown, web search, image search
Open-Meteo Weather Global weather forecasts and air quality
Kiwi.com Flexible flight search across airlines
Malwarebytes Check links, phones, and emails for scams
tldraw Diagrams and whiteboards
Find-A-Domain Domain availability across 1,444+ TLDs
SubwayInfo NYC Real-time NYC transit info

All popular servers are free. Most require no API key (one-tap add); Jina AI can be added without a key, with an optional free API key from jina.ai for search tools. MCP servers auto-reconnect on app startup.

Integrations

Splinterlands Auto-Battle (Android & Desktop)

Kai can automatically play Splinterlands Wild Ranked battles. Configure one or more LLM services in priority order, add your Hive account, and hit Start -- Kai will continuously find matches, pick teams using LLM-powered strategy, and submit them on-chain. Falls back to a simple greedy picker if all LLM services fail. Available in Settings > Integrations.

Supported Languages

Afrikaans, Albanian, Amharic, Arabic, Belarusian, Bengali, Bulgarian, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Filipino, Finnish, French, German, Greek, Gujarati, Hebrew, Hindi, Hungarian, Indonesian, Italian, Japanese, Kazakh, Korean, Latvian, Lithuanian, Malay, Marathi, Norwegian, Persian, Polish, Portuguese, Punjabi, Romanian, Romansh, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Vietnamese, Zulu

Contributing

Screenshot Automation

Two separate screenshot pipelines exist, both using Compose screenshot tests:

README screenshots — Used for this README. CI runs this automatically on every push and auto-commits any changes.

./gradlew :screenshotTests:updateScreenshots

Store screenshots — Generates localized screenshots for the Play Store in all supported locales. Upload via fastlane.

./gradlew :screenshotTests:generateStoreScreenshots
bundle exec fastlane android upload_screenshots

Kai UI component screenshots — Records golden images for KaiUiScreenshotTest only. Faster than recording the full suite when iterating on Kai UI components.

./gradlew :screenshotTests:recordKaiUiScreenshots

Sponsors

This project is open-source and maintained by a single developer. If you find this app useful, please consider sponsoring to help take it to the next level with more features and faster updates.

Credits

Frequently asked questions

Is Kai free to use?

Kai is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Kai do?

OpenClaw alternative in your pocket

What is Kai written in?

Kai is primarily written in Kotlin. Its source is publicly available at https://github.com/SimonSchubert/Kai, and it has 1,330 GitHub stars.