Skip to content

PalmClaw: A Native On-Device Agent Framework for Mobile Phones

🕒 Published (v1): 2026-07-14 00:00 UTC · Source: HuggingFace · link

Why this paper was selected

Native on-device LLM agent framework for mobile; infrastructure-level, enables edge deployment of agent harnesses

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

PalmClaw is an open-source agent framework that runs natively on Android phones, replacing GUI-action-based mobile agents with explicit device tool calls. It hosts the full agent loop, memory, skills, and session state on-device, achieving a 97.1% task success rate with 94.9% faster completion than the strongest baseline.

Problem

Existing mobile LLM agents operate via GUI actions (taps, swipes, typing) executed from an external desktop or server host. This creates three problems: (1) high-level tasks expand into long, layout-sensitive action sequences; (2) agents cannot directly access device resources (files, sensors, contacts); and (3) GUI control provides no well-defined execution boundaries or access limits per task.

Method

PalmClaw runs all agent components—sessions, memory, skills, tools, and the agent loop—as a native Android application. Instead of GUI actions, it exposes device tools: registered functions with explicit JSON argument schemas, structured return values, and three-layer execution boundaries enforced before any device operation: 1. Schema check: validates required arguments, types, and allowed ranges. 2. Permission/confirmation check: invokes Android permission flows or requires user confirmation for sensitive actions. 3. Workspace boundary check: resolves file paths within session workspaces; rejects or requires confirmation for out-of-scope paths.

The agent loop calls a remote LLM API (DeepSeek-V4-Flash in experiments) for reasoning, while context assembly, tool execution, and session state remain on-device. Memory uses two layers: shared long-term memory (across sessions) and per-session summaries, consolidated via a separate LLM call when unconsolidated messages exceed a configurable window. Skills are stored as SKILL.md files and loaded selectively via keyword matching against recent messages.

Key Contributions

  • Native on-device agent framework for Android: agent loop, memory, skills, and sessions run on the phone without a desktop/server bridge.
  • Device tool abstraction: each tool has a model-facing JSON schema and a device-facing function with schema, permission, and workspace checks enforced at execution time.
  • Demonstrated 11.5% relative improvement in task success and 94.9% reduction in completion time over the strongest GUI-based baseline.
  • Reduced deployment burden: 2-step setup (~2 minutes) vs. 3–8 steps and up to ~25 minutes for baselines; no external computer, CLI, or bridge required.
  • Open-source release under AGPLv3.

Results

  • MobileTask (70 tasks): PalmClaw 97.1% success vs. ApkClaw 87.1% (strongest baseline) — 11.5% relative improvement; completion time 17.7s vs. 348.8s (94.9% reduction); 2.8 actions/task vs. 51.4–103.9; 50.4K tokens/task vs. 466.4K–2.06M.
  • AssistantBench (19-task dev subset): PalmClaw 36.85% accuracy vs. ApkClaw 25.79%, ClawMobile 10.49%, MobileClaw 5.26%.
  • All experiments on Xiaomi Redmi (Android 13) using DeepSeek-V4-Flash; GUI baselines additionally use qwen3.7-plus for visual grounding.

Limitations

  • Evaluated only on Android; iOS or cross-platform coverage is not addressed.
  • AssistantBench evaluation uses a 19-task development subset (test split lacks gold answers); subset may not be representative.
  • Remote LLM API is still required for inference; on-device inference is not explored, so prompt/tool-result data is transmitted to an external provider.
  • No ablation isolating the contribution of individual components (memory, skill selection, boundary checks) to task success.
  • Execution boundary analysis is trace-based and qualitative rather than quantified.

Relevance to Agentic AI / LLM Agents

PalmClaw demonstrates that the tool-based, boundary-enforced execution model pioneered by terminal-native agents (Claude Code, Codex CLI) can be transplanted to mobile environments without GUI intermediation. For researchers tracking LLM agent frameworks, it establishes a concrete alternative to screen-grounding approaches and shows that structured device-tool APIs dramatically reduce action count and latency while enabling finer-grained access control. The three-layer boundary enforcement (schema → permission → workspace) is a directly transferable safety pattern for any agent framework operating in resource-constrained or user-sensitive environments. The efficiency gap (2.8 vs. ~75 average actions) quantifies the overhead imposed by GUI-action abstractions, providing a useful reference point for evaluating action-space design choices in future agentic systems.