Mika Runs an Android Agent on a Screen You Never See

An open-source app that drives any installed app on a hidden virtual display, using a wireless-ADB shell and accessibility, with no server and your own model key.

~10 min read • View on GitHub • More from wangzan101

A person in the foreground scrolls their phone while a second, ghosted phone screen floats behind them, where two small mechanical hands tap an icon and type. A dotted line links the physical phone's charging port to the ghost screen, showing that the hidden display is wired into the same device while the person's own screen stays undisturbed.
Mika's whole thesis in one frame: a second screen exists inside the phone, and only the agent is looking at it.

网页可以在任务结束后接着运行。

wangzan101, Project author, release notes · Mika 0.1.27 release notes
Key Takeaways

The Phone Inside Your Phone

Most phone agents behave like someone grabbing the wheel. They take over the screen you are looking at, tap through it, and hope you were not in the middle of anything. Mika does something odder. It asks Android for a second display, one that exists in memory and is never drawn to the glass in your hand, and it does its work there.

The distinction is not cosmetic. A screenshot-and-tap agent competes with you for the same pixels, so every notification, call, and scroll is a hazard it has to survive. Mika's agent operates on a surface your fingers cannot disturb. Your scrolling and its tapping never collide, because they are not happening in the same place.

Under the hood, that surface is a virtual display created through the Android framework. Apps launched onto it render normally, respond to input normally, and report their state through the accessibility tree normally. The only thing missing is a viewer. Nobody is looking at it, so the agent has to look for both of you.

Any app installed on your phone works, with no per-app integration: Mika looks at the screen, finds buttons, taps and types like a person would. If it can see it, it can operate it.

Mika project, Project documentation · Mika feature documentation (English)

One Author, No Server, Your Key

Mika comes from a single developer, wangzan101, and ships as an early public beta. The version string is 0.1.x and the build carries a BETA flag waiting to be flipped. That is not a marketing hedge. It explains almost every design choice that follows.

There is no Mika server. You bring your own model API key, and the phone does the work locally. The browser runs real page interactions with persistent logins. The scripting sandbox is a bundled Alpine Linux userland that defaults to offline. The values are legible in the architecture: your tasks, your keys, your device.

Editorial hedcut-style portrait of wangzan101, the developer of Mika, rendered in black ink on white.

That line from the 0.1.27 release notes says a browser page can keep running after a task ends, which is a small feature and a large signal. Mika is being built as something you leave alone and come back to, not something you sit and watch.

How a Blind Screen Gets Its Privileges

Mika needs powers a normal app does not have. Creating a virtual display and launching activities onto it are operations the shell user performs, and Android does not hand those to apps that were installed by tapping a button. So Mika assembles three layers.

  1. The app process orchestrates. It holds the task state, talks to the model, and decides what to do next.
  2. An accessibility service reads the screen and performs gestures. This is how Mika sees buttons and taps them.
  3. A built-in shell helper runs under shell identity over wireless ADB. It creates the virtual display and launches activities the way a system tool would.

To get shell identity, you pair the phone with itself over wireless debugging, the same mechanism a developer uses to run adb without a cable. That is the trick people notice first.

The helper is kept deliberately separate. It shares none of the app's services, and that process boundary is stated in the code rather than assumed. Privilege is also scoped to the current boot: elevated access is keyed to a boot counter, so a restart revokes it automatically. Trust that expires on reboot is a quiet kind of safety.

The Loop That Makes It Work

Every action an agent takes is a small bet that the interface will respond. On a screen you can see, you check the bet with your eyes. On a hidden screen, the agent has to check it with code. That is the whole problem, and Mika's answer is a loop.

Mika's architecture in one view. The agent's work happens on the right panel, a virtual display, while your screen on the left is never touched. The privilege stack below shows which layer creates the display, which reads it, and which orchestrates.

Read the virtual display, act, wait for the UI to settle, verify the effect against a fingerprint of the control tree, and relocate the target if it moved within a bounded range. The names in the code say it directly: one function checks that typed text actually landed, another re-aims a tap when a control shifted, and the system watches for a different app stealing the foreground.

None of this makes the model smarter. It makes the agent honest. A phone agent that cannot confirm its own actions is just a faster way to be wrong, and the loop is where Mika spends its complexity budget.

The Details That Feel Like Care

Some of the most careful code in Mika is about not breaking things you own. The clipboard is the clearest example. When typing has to fall back to pasting, Mika swaps in its own text, saves your original to an encrypted journal, and restores it on the next launch if the process dies in between. The clipboard is global state, so it is guarded by a shared lock. Your copied text is treated as something the agent borrowed, not something it replaced.

A close-up of a clipboard on a desk. One hand lifts the top sheet into a small locked drawer drawn with fine stipple, while a mechanical hand places a blank replacement sheet onto the clipboard. A small clock face hints at the drawer reopening later. The scene turns an invisible engineering detail, the clipboard swap and its encrypted journal, into a concrete metaphor.
The agent borrows your clipboard but never throws it away. The original goes into an encrypted journal and comes back on the next launch.

Other courtesies are smaller. Gestures default to a human-like pacing profile, with pre-touch pauses, hold durations, and swipe curves, so actions do not look like a bot hammering a screen. An app can be muted before it launches, then unmuted if the launch fails, so openings stay silent. And when two tasks want the same app, Mika can reserve it or clone it under a second Android user, so the two runs do not fight over one window.

These are not headline features. They are the difference between an agent that technically works and one you would leave running.

How Mika Compares

Mika sits in an odd spot, so it helps to name the neighbors. The projects below are not rivals so much as different species. Appium, UIAutomator, and Maestro are test infrastructure. Mobile-Agent and AndroidWorld are research and evaluation. Mika is a product you install, pointed at your own phone.

ProjectWhat it isControl surfaceNatural-language goal?Runs in background?Who it's for
MikaInstallable Android agentHidden virtual display + accessibility + shellYesYes (separate display)End users and tinkerers
AppiumCross-platform automation frameworkDriver API over UI automationNo (scripts/selectors)No (foreground test harness)QA and test engineers
UIAutomatorAndroid UI testing APIAccessibility / UI automationNoNoAndroid test developers
MaestroDeclarative mobile UI flowsYAML flowsNoNoMobile dev teams
Mobile-AgentMultimodal mobile agent researchVision + action planningYesVaries (research setups)Researchers
AndroidWorldAgent evaluation environmentBenchmark harnessN/A (evaluation)N/AResearchers

The differentiator is the bundle, not any single capability. Background display, a real browser, a local sandbox, and bring-your-own-key, shipped as an app you can install today.

What It Doesn't Do Yet

Honesty about limits is part of the review. An independent deep dive credits the virtual-display design, the pacing controls, and the substantial test suite, then flags what a user should know before trusting Mika with their messages.

技术含量远大于商业可行性

Tony's Lab, Independent project reviewer · Mika deep dive review

Roughly translated: the technical depth far exceeds the commercial viability. The same power that makes Mika interesting is the power that warrants caution. Shell identity and a hidden display are exactly what you want an agent to have, and exactly what you want it to use carefully.