Chat with coding agents, edit projects, execute real Linux commands, inspect diffs, and preview live web servers — all directly on your phone.
Releases • 32-bit support • Quickstart Guide • Architecture • Build from Source
Walkthrough of the upstream project | Setting up Ubuntu, connecting Claude Code, and building an app on Android
Important
Environment Security Notice
Mobile Agent runs on ARM64 and ARMv7 (32-bit) Android devices using a private userspace PRoot layer. While isolated from other apps via standard Android sandbox permissions, PRoot is not a virtualization boundary or hardened security jail. Only execute projects and dependencies you own or trust.
Mobile Agent unites modern Jetpack Compose UI with a self-contained Ubuntu 20.04 LTS subsystem. It gives you a desktop-class software development environment in your pocket without requiring root access, unlocked bootloaders, or external applications like Termux.
|
Native integration with Claude Code CLI. Stream step-by-step reasoning, automated file manipulation, and terminal commands across persistent project sessions. |
A full Ubuntu 20.04 userspace running inside PRoot — arm64 or armhf, matched to your CPU. Includes Node.js, npm, Git, OpenSSL, and essential shell tooling out of the box. |
|
Spun up a Vite, Next.js, or Express server? Test web interfaces in real-time within a restricted, sandboxed mobile WebView with console telemetry. |
Your API keys and credentials are encrypted using Android Keystore-backed AES-256 GCM. No telemetry, no remote proxies, and zero plain-text leaks. |
|
Review rich visual diffs of agent-authored code. Accept changes, roll back broken states, or branch checkpoints before testing complex edits. |
Choose during setup where projects live — private app storage, or a real folder in phone storage that your file manager can see. When granted, your whole device storage is mounted inside the Linux guest at |
|
A |
Anthropic, OpenAI, Kimi, an LLM router, or any Anthropic-compatible endpoint you point it at. Models are discovered from the provider, not hardcoded. |
| Projects | Terminal | Settings |
|---|---|---|
|
|
|
| Create, organize, and resume isolated workspace sessions. | Execute real Linux commands and scripts with instant output. | Manage AI providers, installed toolchains, themes, and runtime health. |
Get up and running in 3 guided steps:
Download the latest signed release APK from GitHub Releases, or build it yourself with the instructions below.
Target Architecture : ARM64 (arm64-v8a) and ARMv7 (armeabi-v7a)
Package Version : v1.0.2
Minimum OS Level : Android 9.0 (API 28)
On 32-bit ARM the agent runs the JavaScript build of Claude Code, because Anthropic publishes no
linux-armnative binary. See 32-bit support for the full picture.
Important
On Android 13, 14 and 15 you will see "This app was built for an older version of Android". This is expected. Tap More details → Install anyway and everything works normally.
Mobile Agent targets API 28 deliberately. Since Android 10, apps targeting API 29 or higher cannot execute files in their own data directory — and the Ubuntu environment, Node.js and Claude Code all live there. Targeting 28 is the only way to keep the Linux runtime working. Termux targets 28 for exactly the same reason.
If you don't see an "Install anyway" option
Google Play Protect is blocking the install rather than Android itself. Either:
- Play Store → your profile → Play Protect → ⚙️ → turn off "Scan apps with Play Protect", install, then turn it back on; or
- Install over ADB from a computer:
adb install mobile-agent.apk
Android's own hard install block only applies below API 23, so an API 28 build is never rejected by the OS itself.
Launch the application and follow the interactive setup wizard:
| 1 · System Readiness | 2 · Toolchains | 3 · AI Provider |
|---|---|---|
|
|
|
| Verifies device storage, CPU architecture, and background service permissions. | Select core Ubuntu runtime and optional development stacks. | Securely store your API keys in Android Keystore. |
- Tap New Project or launch an instant Quick Project.
- Open the AI Workspace and describe what you want to build.
- Watch the agent inspect files, draft code, run builds, and launch local web previews.
Mobile Agent uses Claude Code's Anthropic-compatible API protocol. You can connect official endpoints or route requests through compatible translation proxies:
| Provider | Integration Type | Streaming | Tool Calling | Status | Notes |
|---|---|---|---|---|---|
| Anthropic API | Direct Key | Supported | Supported | Recommended |
Primary supported backend |
| LLMrouter | Gateway | Supported | Supported | Supported |
Anthropic-compatible proxy |
| Custom API | Endpoint Override | Compatible | Compatible | Experimental |
User-configured gateway |
| OpenAI / Kimi Gateway | Pocket Adapter | Translated | Translated | Beta |
Requires protocol adapter |
Note
All credentials are stored with hardware-backed Android Keystore AES-256-GCM encryption. Keys are decrypted solely in-memory during active bridge operations.
Mobile Agent bridges native Android Jetpack Compose to an isolated PRoot Linux execution layer via an optimized C++ JNI bridge:
flowchart TB
subgraph Host[" Android Native Host (Kotlin + Jetpack Compose) "]
UI["Modern UI Layer<br/>Projects • Chat • Terminal • Web Preview"]
Service["Foreground Runtime Service<br/>Process Lifecycle & WakeLocks"]
Keystore["Android Keystore<br/>AES-256 GCM Credentials"]
Bridge["C++ JNI Process Bridge<br/>Native Launcher & Pipe Multiplexer"]
end
subgraph Subsystem[" Private Linux Subsystem (PRoot · arm64 or armhf) "]
Ubuntu["Ubuntu 20.04 LTS Subsystem<br/>Rootless Userspace Environment"]
Agent["Claude Code CLI<br/>Autonomous Agent Harness"]
Tools["Development Toolchains<br/>Node.js • Git • Python • C++"]
Workspace["Local Project Workspace<br/>Files • Git History • Checkpoints"]
end
subgraph Cloud[" Model Providers "]
Anthropic["Anthropic Claude API"]
Gateways["LLMrouter / Pocket Gateways"]
end
UI <--> Service
Service <--> Bridge
Bridge <--> Subsystem
Keystore -.-> UI
Agent <--> Cloud
Agent --> Tools
Tools <--> Workspace
UI -.-> Workspace
classDef hostStyle fill:#0f172a,stroke:#38bdf8,stroke-width:1.5px,color:#f8fafc;
classDef subStyle fill:#1e1b4b,stroke:#818cf8,stroke-width:1.5px,color:#f8fafc;
classDef cloudStyle fill:#18181b,stroke:#f59e0b,stroke-width:1.5px,color:#f8fafc;
class UI,Service,Keystore,Bridge hostStyle;
class Ubuntu,Agent,Tools,Workspace subStyle;
class Anthropic,Gateways cloudStyle;
- Base Environment: Ubuntu 20.04 verified rootfs —
arm64on 64-bit devices,armhfon 32-bit - Agent Engine: Official Claude Code CLI from Anthropic — the signed native binary on ARM64, the npm JavaScript build on ARMv7
- Native Tooling: Node.js LTS, npm, Git, OpenSSL, curl, and GNU coreutils
- Process Virtualization: PRoot user-space architecture emulation with zero kernel modifications
Because PRoot supervises the guest with ptrace, the guest userspace must match
the bitness of the app process — a 32-bit tracer cannot drive a 64-bit tracee.
Everything the installer fetches is therefore selected from the detected
architecture; see docs/32-BIT-SUPPORT.md.
| Metric | Minimum Specification | Recommended Specification |
|---|---|---|
| Operating System | Android 9.0 (API level 28) | Android 13.0+ (API level 33+) |
| CPU Architecture | ARM — arm64-v8a or armeabi-v7a |
High-performance 8-Core ARM64 (Snapdragon 8 Gen 1+ / Dimensity) |
| RAM | 4 GB on ARM64 · 2 GB on ARMv7 | 8 GB or more |
| Free Storage | 2.5 GB (Base Runtime) | 8.0 GB+ (For multi-language toolchains and build caches) |
| Network | Stable connection for setup & API | High-speed Wi-Fi during initial rootfs provisioning |
Building from source (Android Studio & NDK)
- Android Studio: Ladybug / Hedgehog or newer
- Android SDK: API Level 36 (
compileSdk 36) - Java Development Kit: JDK 17 (Eclipse Temurin or OpenJDK)
- Android NDK:
26.1.10909125 - CMake:
3.22.1
# Clone the repository
git clone --recurse-submodules https://github.com/anonamus-man/Sid-agent.git
cd Mobile-agent
# Build the debug binary for both ARM ABIs
./gradlew assembleDebug
# ...or narrow it to one architecture
./gradlew assembleDebug -PmhAbis=armeabi-v7a
# Deploy directly to a connected test device
adb install -r app/build/outputs/apk/debug/app-debug.apk# Run unit tests
./gradlew testDebugUnitTest
# Run static analysis linter
./gradlew lintDebug- Direct Sideload APK (Default): Targets API 28 to preserve proven userspace execution paths under Android 10-14.
- Google Play Compliance Build:
Refer to the Google Play Release Checklist for signing and permission policies.
./gradlew -PplayBuild=true assembleDebug
Optional toolchains and development stacks
Mobile Agent allows downloading optional developer packs on demand to conserve space:
- Python Suite: Python 3.10+, pip, virtualenv, and essential scientific C-extensions.
- Android & JVM: OpenJDK 17 headless runtime and Gradle build tools.
- C / C++ Compiler Suite: GCC/G++, Clang, Make, and CMake for native tool compilation.
- PHP Development: PHP CLI runtime, Composer, and standard database extensions.
Note: Kernel-level virtualization technologies such as Docker, KVM, systemd services, and nested hardware emulators are not supported under PRoot.
Repository directory structure
Mobile-agent/
├── app/src/main/
│ ├── java/com/sid/agent/
│ │ ├── data/ # Preferences, Keystore AES encryption, SQLite persistence
│ │ ├── model/ # Data entities: Projects, Chats, Diffs, Tool calls
│ │ ├── runtime/ # PRoot installer, C++ agent bridge, foreground services
│ │ └── ui/ # Jetpack Compose screens, Material 3 theme, ViewModels
│ ├── cpp/ # Native C++ launcher, pseudo-terminal pipe handler
│ ├── assets/ # Verified rootfs checksums, licenses, base configuration
│ └── res/ # Android icons, XML drawables, vector assets
├── fastlane/ # Play Store metadata, graphics, and release automation
└── docs/ # In-depth architectural notes & Play Store review guides
Security model and data privacy
- Zero Cloud Intermediaries: Mobile Agent connects your device directly to your chosen AI endpoint. No intermediate relays or telemetry servers collect your prompts or code.
- Scoped Storage: Project imports and exports utilize Android's official Storage Access Framework (SAF) instead of broad shared storage access.
- Cryptographic Checksums: Root filesystem archives and Claude Code packages are verified before extraction — SHA-256 for Ubuntu/Node.js/Anthropic downloads, and the registry SHA-512 integrity hash for the npm tarball used on ARMv7.
- Encrypted Secrets: API tokens are encrypted in hardware-backed storage via Android Keystore.
Read our complete Privacy Policy.
- Architecture: ARM only (
arm64-v8a,armeabi-v7a). x86/x86_64 devices and emulators are not supported. - 32-bit agent version: ARMv7 devices run the last Claude Code release that shipped a JavaScript entry point, so the agent trails the ARM64 build. Details.
- Process Isolation: PRoot maps file systems and IDs in user space; it is not a cryptographically hardened container or VM.
- Terminal Emulation: The process bridge handles standard CLI workflows and REPLs; specialized ncurses applications may experience minor layout artifacts.
- OS Process Management: Heavy compilation workloads may be throttled if Android applies aggressive battery optimization. It is recommended to exempt Mobile Agent from battery optimization in device settings.
- Mobile Agent is an independent open-source project and is not affiliated with, endorsed by, or sponsored by Anthropic.
- Claude and Claude Code are trademarks of Anthropic, PBC. Claude Code CLI is downloaded directly from Anthropic's official distribution endpoints during setup and remains governed by Anthropic's license terms.
- Ubuntu, Android, Kotlin, Node.js, Git, and other registered trademarks belong to their respective copyright holders.
- Third-party open-source licenses are compiled in
app/src/main/assets/licenses.
This project is licensed under the MIT License. Third-party runtime binaries and packages remain governed by their respective upstream licenses.
Released under the MIT licence. See LICENSE.
Mobile Agent is a fork of Mobile Harness
by TechJarves, released under the MIT licence and
retained in LICENSE. This fork adds 32-bit ARM (armeabi-v7a) support —
see docs/32-BIT-SUPPORT.md — and the walkthrough video
above is the upstream project's.
Bundled third-party components keep their own licences: PRoot (GPL-2.0), libandroid-shmem (BSD-3-Clause), and talloc (LGPL-3.0-or-later).