Ask most AI agents to do something and the work happens in a data center you will never see: your request goes up, the result comes back, and everything between is someone else's server. A project on GitHub turns that arrangement inside out. wangzan101/Mika installs on your Android phone and does the tapping, typing and scrolling itself, finishing the task on the device in your hand. As of November 10, 2026, a GitHub API snapshot shows 7,938 stars, Kotlin as the primary language, an Apache-2.0 license, and a last push at 04:19 UTC on November 10, 2026 — the project was active within the window. The one-line positioning at the top of the README is blunt: an AI assistant on your phone — you say what you need, and it works your apps and the web until it is done. The project has a homepage at mikaphone.com, and the README ships in English, Chinese, Japanese, Korean, Spanish and more.
How this piece fits the site: it is an open-source column deep dive — one repository, its public facts, read section by section. Separately, the site's GitHub high-star tools metadata comparison from November 7, 2026 gave Mika a single row in its parameter table: 7,489 stars, Kotlin, Apache-2.0. That was metadata registration — one line per repository; this piece is a different genre, and the star change between the two time points is reported as is.
The one-line positioning: an on-device agent with hands on the phone
The repository description reads: "An on-device AI agent for Android that operates apps and the web to get things done for you." The weight sits on "on-device." It does not mean the model necessarily runs on the phone — Mika ships no model of its own — but that the hands must be on the phone. Agents in the wild fall into roughly three shapes: cloud agents executing the whole task on a vendor's servers, desktop agents operating your computer, and Mika's path, operating your phone. That taxonomy is this article's framing device, not a claim from the README; for capability boundaries, everything below sticks to what the README states.
The choice has an immediate consequence: the agent faces real applications on a real screen, with no pre-opened interfaces. One line in the README's "Why Mika" table carries most of the design: it looks at the screen and finds buttons the way a person does — no app APIs, no per-app integration. That sentence shapes nearly every mechanism, requirement and limit below.
Two star counts at two time points, and how to read them
The created_at field shows creation on October 29, 2026 at 14:34 UTC — less than two weeks old at the November 10 snapshot. There are two verifiable star counts: 7,489 in the metadata comparison's snapshot on November 7, 2026, and 7,938 in the GitHub API fetch on November 10, 2026. The two points are three days apart, a net gain of 449 stars. The repository address is https://github.com/wangzan101/Mika and you do not need any secondhand source to check it; one command lists the key fields:
gh api repos/wangzan101/Mika --jq '.stargazers_count, .created_at, .pushed_at, .license.spdx_id'One discipline applies: a star count records a bookmarking action — not activity, not maturity, not a quality verdict — and divorced from its fetch time point it is meaningless. The better activity signal is pushed_at: the last push landed at 04:19 UTC on November 10, 2026, the same day as the second snapshot. Every number here carries its time point; these numbers will change, so record your own fetch date alongside them.
The screen behind the screen: how it does the work
Mika's core mechanism is a hidden background screen. It opens apps, taps, types and scrolls on that separate screen while your main screen stays yours; a small live view shows what it is doing whenever you want to watch. The README's demos make this concrete. Tell it to send a message and it opens WeChat on the background screen, finds the contact, sends the text. Ask what a group chat has been discussing and it scrolls through the history, then sums it up. Give it a budget for a shopping task and it picks the item and stops before checkout; ordering takeout with stacked discounts, it asks before paying.
The operating style settles two things. First, logins, verification codes and payments are handed back to you — the README's capability table states Mika passes these three to you. Second, the default posture is Ask mode: it checks with you only before spending money and just does everything else; you can switch to Autonomous mode instead. The conservative default pairs with the README's own safety note — for anything important, use Ask mode and check the results.
Beyond apps, Mika carries a built-in desktop-class browser: it keeps you signed in, reads pages, uploads and downloads, and hands block pages to you. Double-tapping the floating capsule sends the current screen — "how should I reply?", "note this down." Schedules work too: "remind me at 9 tomorrow," "do this every Friday," running inside the original conversation. While a task runs you can jump in with corrections; an instruction it has not picked up yet can be withdrawn or edited with a long press; after a stop it reports where it got to, and "continue" resumes from there. Voice input uses the phone's built-in speech recognition, or a provider's speech model.
Built-in app knowledge: which interfaces it already knows
Reading screens and finding buttons is the general capability, but Mika additionally ships built-in usage knowledge for common apps and websites, listed in README tables a build script generates automatically. The apps column covers WeChat, Douyin, Xiaohongshu, Bilibili, Weibo, Zhihu, BOSS Zhipin, Feishu, Gmail, Telegram, WhatsApp, X, Uber, Chrome and more; the websites column covers Amazon, GitHub, YouTube, Instagram, Google Maps, Google Calendar, Douban, Baidu Tieba and others. General how-to skills sit alongside: handling PDFs, summarizing content, researching a question, messages and email — even editing Mika's own settings.
The README is explicit that anything not listed still works; the built-in knowledge simply makes common scenarios steadier. Contributing usage knowledge requires plain text, no code, and the community can extend the columns entry by entry under the contributing guide. For a project that works by looking at screens, this accumulating record of where the buttons are is an asset more substantive than any star count.
Where the intelligence comes from: your key, an account, or a local model
There is no Mika server — the README says so plainly. Model access runs along three paths. Path one: bring your own API key. Settings carries presets for DeepSeek, Tongyi Qianwen, Kimi, Zhipu (including its Coding Plan), SiliconFlow, Volcano Ark, MiniMax, StepFun, Tencent Hunyuan, Baidu Qianfan, OpenRouter, Anthropic, Gemini, OpenAI, xAI, Mistral, Groq, Ollama, LM Studio and more; anything else goes under Custom, which accepts any OpenAI-compatible, Anthropic, Gemini or OpenAI Responses endpoint. Path two: skip the key and sign in with a ChatGPT (Plus or Pro), xAI/Grok or OpenRouter account. Path three: a local model on your own computer, entered as a custom provider address — the README's FAQ confirms this path directly.
The architecture is worth spelling out: the phone provides the hands, the model provides the judgment, and the two are decoupled. Swap the model — another vendor, cloud or LAN — and the execution layer does not change. That is the mirror image of this batch's cloud flagships: there, a vendor folds agent capability into the model; here, an open-source project folds the execution layer into the phone, with a replaceable brain. If cost and tier matter, the comparison column's four lightweight models are a useful reference.
Three requirements to check before installing
First, the system version, which the README splits by capability: chat, web and files run on Android 11 or later; operating phone apps requires Android 12 or later, Android 14 or later recommended — the background screen keeps its own input focus, never blocking your typing; the Linux sandbox needs an arm64 device. Second, the install channel: the APK comes from the repository's Releases page, and updates only from those Releases or the in-app check under About. Third, only if you want app operation: run the "Set up phone control" wizard and pair wireless debugging once.
Pairing has two known snags, both in the README's FAQ. Android turns wireless debugging off on Wi-Fi changes or restarts; with your permission Mika turns it back on, and if it still fails you re-pair from the wizard. Some systems remove the wireless debugging entry entirely; the fallback is a computer-side helper over USB. Unsure about your device? Settings carries a compatibility self-check: twelve checks in about a minute, sendable to the project in one tap.
Where the data and safety boundaries sit
The privacy section of the README holds three layers. Layer one: there is no Mika server — what you say and what is on your screen go only to the model provider you configured, with no intermediary. Layer two: storage stays local — API keys and memories are stored encrypted on the phone, conversations and run records stay on the device, and update checks only contact GitHub. Layer three: the limits are stated honestly — automatically operating third-party apps and websites may break their terms of service, the README says to use your own judgment and to use Ask mode for anything important. Payment pages and password entry screens block screenshots at the system level, so Mika asks you to take over there.
These boundaries sketch the fit: Mika suits users who will bring a model key, care where their data goes, and run a qualifying phone. If you want zero configuration, the account sign-in path is the least work, with data flows following that platform's terms. All of this is stated in the README; this piece adds no spin beyond it.
Two extras: a sandbox and computer cooperation
Two capabilities are easy to miss. Files and computing: each conversation gets a Linux sandbox (arm64 devices) that runs Python, Node and shell on files you send — a working command-line environment inside the phone. Control from a computer: AI tools on your computer can hand tasks to the Mika on your phone through CLI plus Skill or MCP — the computer agent supplies the task, the phone supplies the hands. How much sandbox isolation matters is a question the site's CubeSandbox article covers from the server side: agents that run code need isolated environments, and Mika packs a lightweight one into the phone.
Back to the opening question: what do 7,938 stars buy you. An open-source agent that put the execution layer into Android: the background-screen mechanism, screen-reading button finding as a general capability, an app knowledge base the community can extend in plain text, three model access paths, tiered version requirements, and a data boundary with no Mika server in it. It trains no model, runs no cloud service, and publishes all its code under Apache-2.0. You can take it apart all the way down — which is why the open-source column gave it a piece of its own.
FAQ
Q1: Is Mika free? What should commercial use watch for? A1: Open source under Apache-2.0, all code public, and the APK downloads free from the Releases page. For commercial use: the Apache-2.0 terms follow the repository's LICENSE file, and model costs depend on the provider you connect — the ChatGPT, xAI or OpenRouter account path follows that platform's plan terms.
Q2: Will my phone run it? A2: Chat, web and files need Android 11 or later; operating phone apps needs Android 12 or later, with Android 14 or later recommended; the Linux sandbox needs an arm64 device. If unsure, run the compatibility self-check in Settings — twelve checks, about a minute, no root and no system modification.
Q3: Where does my conversation data go? A3: There is no Mika server. What you say and what is on your screen go only to the model provider you configured; API keys and memories are stored encrypted on the phone, conversations and run records stay on the device, and update checks only contact GitHub. With the account sign-in path, data flows follow that platform's terms.
Q4: Which apps can it operate? What about unlisted ones? A4: It ships built-in usage knowledge for apps and websites including WeChat, Douyin, Xiaohongshu, Gmail and Telegram, but unlisted ones still work — it operates by reading the screen and finding buttons like a person, with no per-app API integration. The built-in knowledge just makes common scenarios steadier, and the community can extend it in plain text.
Q5: Are the stars still climbing? How do I verify the numbers? A5: Star counts keep changing with user bookmarks. This piece's 7,489 is the November 7, 2026 snapshot and 7,938 is the November 10, 2026 GitHub API fetch; both are bound to their time points. To verify, query the stargazers_count field through the GitHub API, and record your own fetch date alongside the result.
Related reading
- The Claude Fable 5.2 release record: the cloud flagship's official claims and boundaries.
- Four lightweight execution models compared: a selection reference for the brain you attach to executors like Mika.
- The Seedream 5.5 setup guide: official capabilities versus live entry points for an image tool.
- The GitHub high-star tools metadata comparison: this piece's genre counterpart, five repos as a parameter table.
- CubeSandbox, Tencent's open-source agent sandbox: the isolation problem for agents running code, from the server side.