# PhoneClaw: Rootless Android Automation with Vision-Assisted Script Generation

> PhoneClaw is an Android automation app that runs on-device workflows without requiring root access. It embeds ClawScript, a JavaScript-based language, and uses vision-assisted helpers to locate UI elements and read screen content by natural language description. The project is inspired by Claude Code's agent loop and targets developers and power users who want programmable phone automation without device modification.

**rohanarun/phoneclaw** — A version of openClaw/Clawdbot that automates android phones entirely without root, including all apps from a side-loaded APK. Acts as your 24/7 personal assistant on your phone. 

- Repository: https://github.com/rohanarun/phoneclaw
- Stars: 571 · Forks: 99
- Language: Kotlin
- License: MIT
- Published: 2026-09-15 · Updated: 2026-09-15 · Language: en
- Canonical page: https://hysenlabs.com/projects/rohanarun-phoneclaw

## The Problem PhoneClaw Solves

Android automation without root access has long been constrained to the Accessibility service, which lets applications observe and interact with other apps' UI elements through a standardised accessibility tree. Most tools that use this API require hardcoded coordinates or fixed UI element IDs, which break when the app updates or the user changes their device size or language.

PhoneClaw takes a different approach. Its magicClicker helper uses a screenshot combined with a vision model to find a UI element described in natural language, then taps the best-matching element through the Accessibility service. Its magicScraper helper uses the same screenshot-plus-vision approach to answer a targeted question about what is currently visible on screen, returning a string the script can branch on. This makes flows resilient to UI changes: instead of tapping at pixel coordinates, a script says "tap the blue post button" and the vision model finds it.

The README states the project is inspired by Claude Bot and Claude Code and attempts to rebuild the agent loop for Android phones natively. The result is an app that can run multi-step workflows across any installed app, including social media, messaging, browsers, and media apps, all without root, using the same Accessibility service that screen readers use.

## ClawScript: The On-Device JavaScript Automation Language

ClawScript is a JavaScript-based scripting language embedded in PhoneClaw. It is designed for fast iteration: scripts can be written or generated at runtime, executed immediately, and adjusted based on UI feedback. The README describes it as running inside PhoneClaw using an embedded JS engine.

The core API exposed by ClawScript includes eight documented helpers. speakText reads out text using on-device text-to-speech to confirm state or report progress. delay pauses execution for a specified number of milliseconds. schedule registers a task string to run on a cron-like schedule. clearSchedule removes all scheduled tasks. magicClicker finds a UI element by natural-language description and taps it. magicScraper answers a targeted question about what is visible on screen. sendAgentEmail sends an email from the device for notifications or handoffs. safeInt safely parses values to integers with a fallback default.

The README provides a representative example of a script that creates an account on an app, waits for a 2FA OTP to appear in a notification, and reads it:

```js
magicClicker("Create account")
delay(1500)
magicClicker("Email address field")
magicClicker("Next")
const otp = magicScraper("The 2FA code shown in the SMS notification")
```

The magicClicker calls find elements by their visual description. The magicScraper call reads text from the notification. Both rely on the Moondream vision model, which requires an authentication token supplied at build time.

## Installing PhoneClaw via Android Studio

PhoneClaw does not distribute a prebuilt APK. Users build it from source using Android Studio. The README outlines the steps:

First, enable developer mode on the Android device. Root is not required. Second, download Android Studio and open the repository. Third, build the APK through Build, then Generate Bundles or APKs, then Generate APKs. Fourth, transfer the APK to the Android device and install it by tapping the file and allowing installation from unknown sources.

The OpenClaw component, which is the npm-based remote control layer, has its own install path:

```bash
npm install -g superpowers-ai
superpowers --help
```

Running superpowers-ai opens a URL that allows controlling a streamed view of the device from a browser. The npm package is published at npmjs.com/package/superpowers-ai and a Chrome Extension is available from the Chrome Web Store.

The Moondream vision model requires an authentication token. The README specifies storing it in either the project's local.properties file or in the user's Gradle properties:

```properties
MOONDREAM_AUTH=YOUR_TOKEN_HERE
```

Obtaining a Moondream auth token is a separate step outside the repository. Without it, the magicClicker and magicScraper helpers cannot function, since they depend on the vision model to interpret screenshots.

The README recommends a Motorola Moto G Play as the cheapest compatible device, available in the United States for approximately $30. The demos in the project use this device.

## magicClicker and magicScraper: How Vision-Assisted Automation Works

magicClicker takes a natural-language description of a UI element and taps it. Internally, it captures a screenshot of the current screen, sends the image and description to the Moondream vision model, and receives back coordinates or an element reference that it then taps through the Accessibility service. The README notes it is best suited for repeatable flows where the UI layout may shift between devices, because the description survives layout changes that would break hardcoded coordinates.

magicScraper operates similarly but instead of tapping, it returns a concise string answering a question about what is visible. The question can target specific on-screen text such as OTP codes, status labels, or field values. The returned string is available in ClawScript and can be used for branching logic, validation, or passing data to subsequent steps.

Both helpers depend on network access to the Moondream model endpoint. Scripts that chain multiple magicClicker and magicScraper calls introduce latency proportional to the number of model calls. The delay helper exists to manage that latency by pausing between actions to allow animations and page transitions to complete before the next vision call.

For flows that run on a known, fixed UI, writing a vision-based script is more verbose and slower than using hardcoded coordinates. magicClicker and magicScraper provide a trade-off: more resilient and readable scripts at the cost of per-action network latency and the additional Moondream token dependency.

## Scheduling, Multi-Step Flows, and Use Cases

The schedule helper in ClawScript enables cron-style recurring tasks. The README describes the voice-command flow for setting up a recurring automation: speaking a command such as "open Twitter and click the blue post button every hour" causes the app to run the agent loop, schedule the task, and output a ClawScript file that the user can then edit. The README describes the output as editable in plain language.

The demonstrated use cases in the README span several categories. Social media automation tasks include posting, moderation, and community management. E-commerce tasks include uploading product videos to TikTok. Account management tasks include creating accounts with 2FA verification. Drone control automation is shown in a video linked from the README. The README also mentions automating tasks while inside a Waymo vehicle using Android XR.

The Solana token integration mentioned in the README, referenced as $phoneclaw, is an aspect of the project's community and not directly related to the automation functionality.

The iOS App for SuperPowers AI is listed with an App Store link, and there is a note about a Vision Pro demo. The core PhoneClaw Android repository targets Android only; the iOS product is a separate distribution.

## Limitations and Alternatives

The primary limitation is the dependency on the Moondream vision API for the key automation primitives. magicClicker and magicScraper are both network calls. A device without stable internet access, or a Moondream token that expires, stops these helpers from working. The Accessibility service calls themselves are on-device, but the vision layer is not.

Building from source via Android Studio is a higher barrier than installing from an app store. Teams that want to deploy PhoneClaw at scale across multiple devices need a CI pipeline to build and sign APKs, and a sideloading distribution mechanism. There is no mechanism for over-the-air updates from the project.

The last push to the rohanarun/phoneclaw repository was on 2026-08-14. No GitHub releases have been published. There is no versioning in the repository, and the codebase reflects ongoing development without stability guarantees.

For use cases that do not need vision-assisted element finding, Tasker is a widely used alternative on Android that provides rule-based automation through a GUI. Tasker does not require building from source and supports a large library of community-created scripts, but it does not provide natural-language UI targeting. For developers who need scriptable automation with vision capabilities, PhoneClaw is one of the few rootless options that exposes that combination.

## Conclusion

PhoneClaw is for developers and technical users who want to automate Android workflows programmatically without rooting a device. The vision-assisted magicClicker and magicScraper helpers make it genuinely different from coordinate-hardcoded macro tools. Teams that need stable enterprise automation on controlled devices should evaluate whether a Moondream API token dependency and a sideloaded APK distribution model fit their security requirements. The last push to the repository was on 2026-08-14, and no releases have been published to GitHub, so production deployments should pin to a specific commit.

## FAQ

### Does PhoneClaw require rooting the Android device?

No. PhoneClaw automates Android using the Accessibility service, which does not require root. The README explicitly states that root is not needed and describes enabling developer mode as the only device preparation step.

### What is ClawScript and how is it different from a standard JavaScript automation script?

ClawScript is a JavaScript dialect embedded in PhoneClaw that exposes Android-specific helpers like magicClicker for vision-assisted tapping and schedule for cron-like task registration. Unlike a plain JS environment, it runs inside the PhoneClaw app and has access to the device's Accessibility service and screenshot pipeline through those helpers.

### What is the cheapest device I can use to run PhoneClaw?

The README recommends a Motorola Moto G Play as the cheapest compatible device, which it notes is available in the United States for approximately $30. The demos in the repository were recorded on this device.

## Sources

- [Issues](https://github.com/rohanarun/phoneclaw/issues)
- [License: MIT](https://github.com/rohanarun/phoneclaw/blob/main/LICENSE)
- [README](https://github.com/rohanarun/phoneclaw/blob/main/README.md)
- [rohanarun/phoneclaw on GitHub](https://github.com/rohanarun/phoneclaw)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rohanarun-phoneclaw