Mobile Harness

The complete autonomous AI development workspace for Android.

Chat with coding agents, edit projects, execute real Linux commands, and preview live web servers — all directly on your phone.

Download Online APK  •  Download Offline APK  •  Watch Walkthrough (3 min)  •  Quickstart Guide  •  Architecture  •  Build from Source

---

---

[!IMPORTANT] Environment Security Notice
Mobile Harness runs on ARM64 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.

Download Mobile Harness

Capabilities

Mobile Harness 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.

Workspace Interface

Quickstart

Get up and running in 3 guided steps:

1. Download & Install

Download the latest signed release APK from GitHub Releases.

Target Architecture : ARM64 (arm64-v8a)
Package Version     : latest release
Minimum OS Level    : Android 9.0 (API 28)

2. Guided Bootstrap (~10 Minutes)

Launch the application and follow the interactive setup wizard:

3. Create & Build

1. Tap New Project or launch an instant Quick Project.
2. Open the AI Workspace and describe what you want to build.
3. Watch the agent inspect files, draft code, run builds, and launch local web previews.

Model Providers

Mobile Harness 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
OpenRouter	Gateway	Supported	Supported	Supported	Routes compatible models through one API key
DeepSeek	Direct Key	Supported	Supported	Supported	Anthropic-compatible endpoint
Kimi	Direct Key	Supported	Supported	Supported	Anthropic-compatible Moonshot endpoint
Custom API	Endpoint Override	Compatible	Compatible	Experimental	User-configured gateway

[!NOTE] API keys are stored with hardware-backed Android Keystore AES-256-GCM encryption. Antigravity Google OAuth credentials are created and retained only by the official agy CLI in its persistent Linux home; Mobile Harness never reads or copies its tokens.

Coding agents

Agent	Authentication	Installation	Isolation
Claude Code	Claude account or API-key providers	Included in Core	Existing Claude bridge and settings
DeepSeek Harness	API-key providers	On demand	Existing DSH bridge and settings
Antigravity CLI	Official Google OAuth flow	Version-pinned online download	Dedicated agy bridge, model, effort, and conversation IDs

For Antigravity, select Antigravity CLI, install it, and tap Sign in with Google. Mobile Harness starts the official CLI login, opens the freshly generated Google URL in the system browser, and sends the returned one-time code back to that waiting process. The app does not embed Google login in a WebView and does not construct its own OAuth request.

[!WARNING] Antigravity tasks currently launch with --dangerously-skip-permissions. This gives the official agent permission to run tools without individual PocketDev approval prompts. Use it only with projects and prompts you trust. Account quotas and service limits still apply; signing in does not provide unlimited usage.

When Android is selected during onboarding, Mobile Harness installs that complete toolchain into its private Ubuntu environment. Android projects can then be built with the workspace play button. The resulting debug APK is passed directly to Android's system package installer and launched after installation; USB debugging, wireless debugging, an ADB port, and a pairing code are not required. Android still requires the user to allow installs from Mobile Harness and confirm each installation.

Architecture

Mobile Harness 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) "]
        Ubuntu["Ubuntu 20.04 LTS Subsystem<br/>Rootless Userspace Environment"]
        Agent["Agent Registry<br/>Claude • DeepSeek • Antigravity"]
        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 / API Gateways"]
        Gateways["Google Antigravity Service"]
    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;

Core Runtime Components

• Base Environment: Ubuntu 20.04 ARM64 verified rootfs
• Agent Engine: Registry-selected, isolated drivers for Claude Code, DeepSeek Harness, and the official Antigravity CLI
• Native Tooling: Node.js LTS, npm, Git, OpenSSL, curl, and GNU coreutils
• Process Virtualization: PRoot user-space architecture emulation with zero kernel modifications

System Requirements

Metric	Minimum Specification	Recommended Specification
Operating System	Android 9.0 (API level 28)	Android 13.0+ (API level 33+)
CPU Architecture	64-bit ARM (arm64-v8a)	High-performance 8-Core ARM64 (Snapdragon 8 Gen 1+ / Dimensity)
RAM	4 GB	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

---

Developer Guides

Prerequisites

• 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 & Build Debug APK

# Clone the repository
git clone https://github.com/techjarves/Mobile-Harness.git
cd Mobile-Harness

# Build the standard ARM64 debug binary
./gradlew assembleDebug

# Deploy directly to a connected test device
adb install -r app/build/outputs/apk/debug/app-debug.apk

Quality Assurance & Testing

# Run unit tests
./gradlew testDebugUnitTest

# Run static analysis linter
./gradlew lintDebug

Target Profiles

• Direct Sideload APK (Default): Targets API 28 to preserve proven userspace execution paths under Android 10-14.
• Google Play Compliance Build:

  ./gradlew -PplayBuild=true assembleDebug
  

  Refer to the Google Play Release Checklist for signing and permission policies.

Mobile Harness 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.

Mobile-Harness/
├── app/src/main/
│   ├── java/com/jarves/mh/
│   │   ├── data/       # Preferences, Keystore AES encryption, SQLite persistence
│   │   ├── model/      # Data entities: Projects, Chats, Files, 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

• Zero Cloud Intermediaries: Mobile Harness 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 CLI packages are verified via SHA-256 checksums prior to extraction.
• Encrypted Secrets: API tokens are encrypted in hardware-backed storage via Android Keystore.

• ARM64 phones only
• No hardened isolation for hostile code
• Terminal input/output currently uses a process bridge rather than a complete PTY emulator; full-screen interactive programs may render incorrectly
• Background tasks are subject to Android process and battery policies
• Custom providers may lack Claude-compatible thinking, tool use, token counting, or streaming behavior
• Large builds can be slow and memory-intensive under PRoot
• Runtime installation requires a substantial download and free storage
• Project-specific Android libraries may still be downloaded by Gradle when they are not already in the bundled Maven cache

Read our complete Privacy Policy.

Mobile Harness is currently intended for signed direct APK distribution and private testing. Its Android-project workflow requests permission to submit user-built APKs to Android's package installer, which requires a dedicated Google Play policy declaration and approval if distributed through Play.

Current Limitations

• Architecture: Exclusively supports 64-bit ARM (arm64-v8a) hardware.
• 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 Harness from battery optimization in device settings.

Legal & Trademarks

• Mobile Harness 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.

License

This project is licensed under the MIT License. Third-party runtime binaries and packages remain governed by their respective upstream licenses.

---