One Open Source Project a Day (No. 255): Mika — An AI Agent for Android That Operates Your Apps and the Web on a Hidden Background Screen

Introduction

"No app APIs, no per-app integration."

This is the 255th article in the "One Open Source Project a Day" series. Today's project is Mika, an AI agent that runs on an Android phone.

There are two usual ways to have AI operate a phone: rely on each app's public interface (most apps have none), or write an adapter for every app (impossible to maintain). Mika takes a third path: look at the screen, find buttons, tap, and type, the way a person would. The README's wording is "no app APIs, no per-app integration."

One practical design choice: tasks run on a hidden background screen, so your main display stays usable. The repo was created on 2026-10-29 and already has about 7.2k Stars, but it is very new, and everything below follows the README rather than hands-on testing.

What You Will Learn

How Mika operates a phone without depending on app interfaces
How to choose a model: it has no server of its own, so where does your data go
How Ask mode and Autonomous mode control risk, and what gets handed back to you
The extras: built-in browser, scheduled tasks, Linux sandbox, skill learning
Install requirements and a few limits worth knowing

Prerequisites

Comfort installing an APK and using Android developer options
Basic familiarity with LLM API keys
Optional: some background on MCP

Project Background

What It Is

Mika is an Android AI assistant app: you give an instruction, and it carries out the task across apps and the web. The repo description calls it an on-device AI agent for Android that operates apps and the web for you. "On-device" refers to the agent itself running on the phone; whether the model is local depends on how you configure it (see below).

Project Stats

⭐ GitHub Stars: about 7,240
🍴 Forks: about 1,655
💻 Language: Kotlin
📅 Created: 2026-10-29
📄 License: Apache-2.0 (with a NOTICE file and third-party notices)
👤 Author: wangzan101 (@wangzan101 on X), with a community X group chat
🌐 UI available in 10 languages, including English, Chinese, Japanese, Korean, Spanish, and Arabic

What It Does

The Problem It Solves

Common obstacles to AI operating a phone:
  Most apps have no open interface
  Per-app adapters are unmaintainable
  If the agent holds the main screen, you can't use your phone
 
Mika's approach:
  Look at the screen, find buttons, tap and type like a person
  ↓ run on a hidden background display
  ↑ the main screen stays yours; logins, codes, and payments get handed back

What It Can Do

Operate apps: read long lists and chats, tap, type, share text
Built-in browser: stays signed in, reads pages, handles downloads and uploads
Floating capsule: double-tap to send your current screen to it
Scheduled and conditional tasks: reminders and recurring jobs
Interject anytime: interrupt or stop mid-task, then say "continue" later
Hold-to-talk voice input: uses the phone's built-in recognition, or a provider's speech model if the phone has none
Linux sandbox: one per conversation, running Python, Node, and shell (arm64 devices only)
Computer-side access: AI tools on your computer can hand it tasks through CLI + Skill or MCP
Learning: remembers preferences and turns finished tasks into skills
Built-in app knowledge: covers many apps and sites, mostly Chinese platforms plus Amazon, Gmail, Uber, YouTube, and others; anything unlisted still works

Quick Start

Download the APK from the GitHub Releases page
In Settings › Model, choose a provider and enter a key, or sign in
To control other apps on the phone, run the "Set up phone control" wizard and pair wireless debugging once

The README gives no build-from-source commands, only mentioning a ./gradlew updateReadme task that generates README sections. A computer-based agent install is available through a guide linked from the README.

Requirements

Capability	Requirement
Chat, web, files	Android 11+
Operating other apps	Android 12+, 14+ recommended
Linux sandbox	arm64 devices

A compatibility self-check lives under Settings › Recovery & repair.

A Deeper Look

No Mika Server: Data Goes Only to the Model You Choose

The README says plainly that there is no Mika server; your requests and screen content go only to the model provider you configure. That defines the privacy boundary:

Presets: DeepSeek, Qwen, Kimi, Zhipu, SiliconFlow, Volcano Ark, MiniMax, OpenRouter, Anthropic, Gemini, OpenAI, xAI, Mistral, Groq, Ollama, LM Studio, and others
Custom: accepts OpenAI-compatible, Anthropic, Gemini, or OpenAI Responses endpoints, including a model on your own computer via a local network address
Sign-in options: use your own API key, or sign in with a ChatGPT (Plus/Pro), xAI/Grok, or OpenRouter account

So if you want screen content to stay local, point it at Ollama or LM Studio running on your own machine; with a cloud model, screen content goes to that vendor. Think that through before use.

On-device storage: API keys and memories are stored encrypted, conversations and run records stay local, and update checks contact only GitHub.

Risk Control: Two Modes and Active Handover

Ask mode (default): confirms only before spending money
Autonomous mode: fewer interruptions
Handover: logins, verification codes, and payments always go to you; screens that block screenshots, such as payment and password pages, also trigger a handover

The README also warns that automating third-party apps may breach their terms of service, so use your own judgment and prefer Ask mode for important tasks. A disclaimer document is linked in the repo.

How It Actually Controls the Phone

The README only says phone control is set up by pairing wireless debugging once through a wizard. It does not state whether an accessibility service is used, or spell out whether a vision model is involved. "Looking at the screen and finding buttons" implies some form of screen reading, but the details aren't given, and the README has no architecture or project structure section. To understand the implementation you'd have to read the source.

Limits and Cautions

Wireless debugging can switch off when Wi-Fi changes or the phone restarts; some phone systems omit it, in which case you fall back to a USB setup with a computer
Some screens can't be captured, which limits what it can do there
The built-in app knowledge is written in Chinese, though you can talk to Mika in English
The project is very new and the README has no roadmap, so judge maturity yourself
Contributions are welcome, either usage knowledge or code, per the contributing guide

Project Links and Resources

🌟 GitHub: https://github.com/wangzan101/Mika
📦 Download: the GitHub Releases page
📄 License: Apache-2.0
🐦 Author: @wangzan101 on X

Summary

Key Takeaways

Idea: skip app interfaces and operate by looking at the screen like a person
Hidden background display: tasks don't take over your main screen
Clear data flow: no Mika server, only the model you configure; local models are possible
Risk control: confirms before spending money by default, and hands logins, codes, and payments back to you
Extensibility: built-in browser, scheduled tasks, Linux sandbox, skill learning, and MCP/CLI access

Who This Is For

Android users who want AI to handle repetitive phone tasks
Developers who want phone capabilities inside a computer-side agent workflow
People curious about how mobile GUI agents are built

Suggested First Steps

Install it on a spare phone first and try a few harmless tasks in Ask mode, watching for when it hands control back. If privacy matters, test with a local model through Ollama or LM Studio first. Leave account and payment tasks until you know how it behaves.

Check out PrimeSkills — a curated marketplace of AI agents and skills that have been validated in real-world, enterprise-grade workflows. No fluff, just what actually works.

Find more useful knowledge and interesting products on my Homepage