ClawPhone: running agent CLIs on a spare Android phone through Termux

A recipe book for Termux, not a packaged app

ClawPhone describes itself as scripts, tweaks, and notes for running agent CLIs on Android phones through Termux. That framing matters, because it sets expectations about what you get: shell scripts, a Python daemon at the repository root, and a docs directory. The stated goal is to keep things as native to Termux as possible, using proot or heavier compatibility layers only when Android's userspace makes that unavoidable. That is a deliberate stance against the common pattern of running a full Linux container on a phone. The intended audience is a person with a cheap prepaid Android phone or an old Android 8 or newer device, running an agent in the background as a sandbox, and interacting with it remotely. The README also states that the work is based on an original working Termux setup shared by another person, with the goal of turning those manual steps into one script that is easier to install, update and uninstall.

The Antigravity installer and its TCMalloc patch

The first packaged script is an installer for Google's Antigravity CLI, referred to as agy, aimed at ARM64 Android running Termux. According to the README, the script installs and checks dependencies, installs the official Linux ARM64 binary, patches the TCMalloc VA assumptions for common Android devices, creates a glibc wrapper, adds shell shortcuts, and supports uninstall. That list describes the shape of the problem: a Linux binary built for glibc and a modern allocator does not simply run inside Termux's Android userspace, so the script rewrites allocator assumptions and wraps the binary. The documented usage pipes the script into bash, then reloads the shell and asks the tool for its version:

curl -fsSL https://raw.githubusercontent.com/marshallrichards/ClawPhone/main/scripts/install-antigravity-termux.sh | bash
source ~/.bashrc
agy --version

Note what that usage does not include: no checksum, no pinned version, no dry run. The script is fetched over the network and executed immediately, so anyone running it trusts the repository at that moment. Further details live in a separate document, docs/antigravity-termux.md, which the README points to rather than inlining.

Why the npm install path is preferred over the bash installer

The OpenClaw notes are the most detailed part of the repository, written as numbered steps that read like a transcript of solving real problems. The recommendation is to install Termux first, together with tmux, a text editor such as nvim, nodejs-lts and python, plus the Termux:API and Termux:GUI apps if hardware and UI access are wanted. For OpenClaw itself the instruction is specific and has a reason attached: install it with npm rather than the bash installer, because the bash installer can fail on Android. If dependencies fail during the install, the note says to install the missing packages with pkg and rerun the install:

npm install -g openclaw@latest

The other notes are equally concrete about what goes wrong. llama.cpp may compile from source because Termux lacks normal desktop glibc behaviour, which the README says can take 15 to 30 minutes. Errors about missing systemd are expected, and the fix is to run the OpenClaw Gateway in the foreground or inside tmux rather than as a service. The session runs in the background inside a tmux session, which is also how the author interacts with it, over Discord, as with a normal OpenClaw agent.

Repointing the temp directory away from /tmp

One configuration change carries most of the weight. OpenClaw expects a path at /tmp/openclaw, but raw Termux does not have that layout, so the notes say to use $PREFIX/tmp instead and to export it in ~/.bashrc so it survives new shells:

export TMPDIR="$PREFIX/tmp"
export TMP="$TMPDIR"
export TEMP="$TMPDIR"

The same idea drives the logging configuration, which the notes add to openclaw.json as a logging block with a level of info and a file path under the Termux prefix, with the date in the filename. The directory has to exist first, which is a separate step:

mkdir -p /data/data/com.termux/files/usr/tmp/openclaw

After that the sequence is to source ~/.bashrc, run openclaw gateway, and then run openclaw onboard to add a model token. The order matters, since onboarding is where the credentials come from.

Binding the dashboard to the LAN and telling the agent where it lives

Two final OpenClaw settings decide whether the phone is usable as a sandbox. The first is to set gateway.bind to lan, so the dashboard listens on 0.0.0.0 and can be reached from the phone's address on the local network. That is convenient and it is also a real exposure, because the note does not mention authentication on that listener or a firewall rule, and the phone is a cheap prepaid device on a home network. The second setting is descriptive rather than technical: tell OpenClaw that it is running inside Termux on Android, and that Termux:API and Termux:GUI are installed, so the agent knows it can reach the phone's hardware and user interface. The hardware access runs through the separate Termux:API app, which is why the notes treat it as an install step rather than a library.

Overlays through overlay_daemon.py in a second tmux pane

The repository goes beyond running an agent. There is an overlay_daemon.py file at the repository root, and the notes explain a way to let OpenClaw write on the screen. The steps are to install the Termux:GUI app, install the termux-gui package with pkg, start overlay_daemon.py in another tmux pane or window, and then tell OpenClaw it can use that daemon when it needs to display something to the user. The agent is not drawing anything by itself; it hands text to a separate Python process that owns the drawing, and that process is supervised the same way as the agent session. The design keeps the agent inside its own environment and gives it one narrow channel to the display, which is a reasonable shape for a phone used as a remote sandbox.

No releases, no stated licence, and a last push in May 2026

The maintenance picture is thin, and the README does nothing to disguise it. The repository has no GitHub releases, there is no homepage given, and no licence is stated for the code, even though the project is largely shell scripts that people are encouraged to fetch and execute. The last push was on 2026-05-25, and the repository is not archived. The top level of the repository holds a small set of entries: the README, a docs directory, scripts, the overlay daemon and a .gitattributes file. That thinness has direct consequences. The installer patches an allocator and wraps a glibc binary, and it fetches the upstream Antigravity binary, so the behaviour depends on third-party artefacts that this repository does not pin. If the upstream CLI changes, the script has no release history to fall back on.

Editorial conclusion

ClawPhone suits a developer with a spare Android 8 or newer phone who wants an isolated sandbox for an agent CLI and is willing to read each script before running it. It does not suit a team that needs a supported, licensed, reproducible deployment, since the repository has no releases, no stated licence and a last push on 2026-05-25. Verify first that your device is ARM64 and that the script's download and install steps still match the upstream Antigravity CLI, then follow the OpenClaw setup notes in order so the TMPDIR and logging keys are set before the first gateway run.

Frequently asked questions

Official sources

1. Issues
2. marshallrichards/ClawPhone on GitHub
3. README