mobile-easy-use

Mobile Easy Use is designed to provide AI coding agents with runtime access to Android and iOS apps, implemented based on Frida. Through the MCP protocol, it enables agents to observe and control mobile apps, not just the UI layer.

Purpose

In complex projects, app behavior often depends on runtime data, configuration, caching, and call timing. Source code explains the implementation, while runtime exploration reveals the branches actually executed, object states, and where failures occur. Together, they provide evidence for agents' coding decisions. Runtime observation runs throughout the coding loop: research and coding before coding, validating technical approaches, investigating issues, and verification after coding.

Main capabilities

• Inspect native objects and state.
• Trace and override method calls, including temporarily modifying configuration, fields, or method return values, which can be restored afterward.
• Control the UI and interact with the running app.
• Serve as an enhanced UI automation testing tool: it can combine UI, screenshots, and native business state for deeper assertions; temporarily override fields or method return values to simulate empty data, failures, or specific configuration branches; clearly diagnose failure causes by connecting actual method calls, parameters, return values, and state changes.
• Provide Skills and MCP tools, supporting the generation and execution of test scripts.
• Improve integration with minimal changes through the Observable Skill (optional).
• Support turning findings into Presets for easy reuse.

How to use

Prepare Node.js 20+. Android requires ADB and an available device or emulator; iOS requires macOS, Xcode and its command-line tools, and physical devices also require iproxy and development signing for the XCTest Runner needed for input operations.

1. Install Skills: run the command in the root directory of the target app project, select all Skills, and follow the prompts to choose the agent and installation scope. Skills and MCP are installed separately.
2. Integrate into the app: in the target app project, have the agent use the platform's Integrate Skill. Integrate will obtain and verify the Release artifact, update the project configuration, and return a compatible MCP startup command. Android integrates an AAR that automatically starts the Runtime; iOS embeds the bridge and Runtime, which are loaded when MCP connects. The integration scope should be limited to internal debug builds, then build and install the app on the target device.
3. Install and configure MCP: Add mobile-easy-use to the agent's MCP configuration, using the compatible MCP version returned by Integrate Skill. Use npx to fetch and start the selected version, with no separate global installation required. Set the working directory to the target application project root so that MCP can resolve the project Presets. The agent and MCP need to share local file system access. Reload the MCP configuration and confirm that tools such as get_sdk_declarations and connect are visible. A new connection checks the compatibility between the application Runtime Release and the MCP version, and suggests adjustments when they do not match.
4. Start probing or testing: After integration, build a debug version of the application containing the Mobile Easy Use Runtime and install it on the target device or simulator. Connect the device, identify the target application, and describe the problem to start Probe. Probe uses the source code and existing Presets to generate an investigation, connects to the application through MCP, performs operations and collects relevant evidence, answers the original question without writing probe scripts, and distinguishes observed facts, source-code-based explanations, and unverified behavior. Use separate Skills to generate and run tests: use to-android-test for Android, and to-ios-test-script and to-ios-test for iOS.

Applicable Scenarios

• An AI agent needs to deeply understand application runtime behavior during coding.
• Validate technical solution assumptions.
• Investigate and locate problems.
• Verify results after coding, and turn confirmed expectations into regression tests.
• Enhance UI automation testing for deeper assertions, scenario control, and failure diagnosis.

Limitations

iOS platform requires macOS, Xcode, and command line tools, and physical devices require additional configuration. Integration should be limited to internal debug builds. Some operations depend on device availability, and certain behaviors may not be verifiable without a device. Compatibility requires matching the Runtime Release and MCP version.