Skip to content

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

🕒 Published (v1): 2026-07-14 17:58 UTC · Source: Arxiv · link

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 the full agent loop, session management, memory, skills, and tool execution natively on a mobile phone rather than on an external desktop or server. It exposes device capabilities as structured "device tools" with explicit JSON arguments, structured results, and layered execution-boundary checks. On 70 mobile tasks it achieves 97.1% success rate and 17.7 s average completion time, compared to 87.1% and 348.8 s for the strongest GUI-based baseline.

Problem

Existing mobile agents operate via GUI actions (tap, swipe, type) orchestrated from a desktop or cloud host, producing three compounding problems: (1) high-level tasks inflate into long, layout-sensitive action sequences; (2) the approach cannot directly access device resources (files, sensors, calendar, contacts); and (3) GUI control grants unbounded access to any reachable screen without task-specific execution boundaries. The agent framework, tool execution, and session state all live off-device, creating deployment friction and latency.

Method

PalmClaw integrates five agent components directly into a mobile application:

Sessions route inputs from three sources—local chat, remote channels, and scheduled wakeups—into isolated workspaces with per-session conversation history and artifact storage.

Memory maintains two persistent layers: (1) shared long-term memory included in every agent turn, and (2) per-session summaries generated by a separate LLM call when unconsolidated messages exceed a configurable window.

Skills are reusable task instructions stored in SKILL.md files. Per turn, PalmClaw adds a skill summary to context, loads always-active skills in full, and dynamically selects additional skills by matching recent user messages against skill names, descriptions, and keywords.

Device tools each bundle a model-facing JSON argument schema (name, description, types, ranges) with a device-facing function. Built-in groups cover device/media, personal data (calendar, contacts), workspace/files, web, and channels/automation.

Tool execution is gated by three sequential checks: (1) Schema—validates required arguments, types, and allowed ranges; (2) Permissions—triggers the Android permission flow or requires explicit user confirmation for sensitive actions; (3) Workspace—resolves file paths against the session workspace or approved storage, rejects foreign session paths, and requires confirmation for external writes.

Context assembly for each turn concatenates six sources: system instructions (AGENT.md, SOUL.md, USER.md), runtime context (time, timezone, session ID, workspace paths), shared long-term memory, active skill instructions, recent conversation history with tool traces, and tool specifications sent alongside model messages to the remote LLM API.

The agent loop is a bounded multi-round cycle: assemble context → call remote LLM → store assistant message → if tool calls present, execute on-device and append results → repeat; loop ends on no tool calls, a task-completion signal, or round limit.

Key Contributions

  • PalmClaw framework: open-source (AGPLv3) mobile-native agent harness hosting loop, memory, skills, tools, and sessions on-device.
  • Device tools: structured tool interface pattern with explicit JSON schemas, structured results, and three-layer execution boundaries (schema → permissions → workspace).
  • Empirical evaluation: 11.5% relative improvement in task success and 94.9% reduction in completion time over the strongest baseline on MobileTask; highest accuracy on AssistantBench dev subset.
  • Deployment analysis: setup reduced to 2 steps / ~2 min with no external computer, CLI, or bridge required, versus 3–8 steps and 5–25 min for compared systems.

Results

  • MobileTask success rate (70 tasks): PalmClaw 97.1% vs. ApkClaw 87.1%, ClawMobile 77.1%, MobileClaw 60.0%.
  • Average completion time: PalmClaw 17.7 s vs. ApkClaw 348.8 s (−94.9%), ClawMobile 451.1 s, MobileClaw 1197.0 s.
  • Average actions per task: PalmClaw 2.8 vs. ApkClaw 103.9, ClawMobile 51.4, MobileClaw 94.3.
  • Average tokens per task: PalmClaw 50.4 K vs. ApkClaw 2.06 M, ClawMobile 466.4 K, MobileClaw 1.30 M.
  • AssistantBench accuracy (19-task dev subset): PalmClaw 36.85% vs. ApkClaw 25.79%, ClawMobile 10.49%, MobileClaw 5.26%.
  • Backbone LLM: DeepSeek-V4-Flash for all systems; MobileClaw additionally uses qwen3.7-plus for visual grounding.

Limitations

  • LLM inference remains remote: task context, prompts, and tool results are sent to an external API provider, preserving a privacy exposure the paper acknowledges but does not mitigate technically.
  • Evaluated only on Android 13 (Xiaomi Redmi); no iOS evaluation or portability claims.
  • AssistantBench evaluation uses only a 19-task dev subset because the local test split lacks gold answers and some tasks contain unstable real-time values—limiting the generalizability of web-task accuracy numbers.
  • GUI actions are entirely absent from PalmClaw's action space; tasks requiring screen interaction with arbitrary third-party apps cannot be handled.
  • Round limits differ between PalmClaw (30) and GUI baselines (100) in AssistantBench, complicating direct comparison.

Relevance to Harnesses / Meta-Harnesses

PalmClaw is a full harness instantiation, making it directly relevant as a concrete reference implementation: it enumerates the canonical harness components (agent loop, session management, two-tier memory, skill loader, tool registry, context assembly pipeline) and maps each to a mobile-specific design choice. Its skill system—SKILL.md files dynamically selected per turn—mirrors the file-based skill loading pattern common in desktop harnesses (e.g., Claude Code's own SKILL.md convention), providing a cross-platform data point on portability of that pattern. The three-layer tool execution boundary (schema → permissions → workspace) is a novel contribution to harness safety architecture, formalizing execution control that most desktop harnesses leave implicit. For researchers studying harness design, PalmClaw also provides a controlled deployment comparison showing how externalizing vs. internalizing the agent loop affects latency, token cost, and setup complexity.