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

Hongru Cai; Ran Wei; Wenjie Li; Yongqi Li

PalmClaw runs mobile agents natively on-device with explicit device tools, cutting completion time by 94.9% while lifting task success 11.5%.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-15 01:27 UTC pith:N7FXBFTT

load-bearing objection Native on-device mobile agent with tool-level execution boundaries is a real systems idea; the 11.5%/94.9% numbers cannot be audited from the abstract alone. the 3 major comments →

arxiv 2607.13027 v1 pith:N7FXBFTT submitted 2026-07-14 cs.CL cs.AI

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

Hongru Cai , Yongqi Li , Ran Wei , Wenjie Li This is my paper

classification cs.CL cs.AI

keywords mobile agentson-device LLM agentsdevice toolsexecution boundariesGUI agentstask automationPalmClaw

verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Most mobile agents still drive phones the way a human would: by tapping, swiping, and typing through the graphical interface. That produces long, brittle sequences that never touch the device's real capabilities and leave unclear where one action ends and the next begins. PalmClaw is an open-source framework that instead runs the entire agent loop on the phone itself and exposes sensors, apps, and system services as first-class tools with typed arguments, structured return values, and hard execution boundaries. The claim is that this native tool design lets agents complete everyday multi-step tasks more reliably and far faster than GUI-driven baselines, while also reducing the setup work required of the user. If the numbers hold, on-device agents become practical rather than experimental, because each step is short, inspectable, and constrained.

Core claim

A native on-device agent framework that presents phone capabilities as tools with explicit arguments, structured results, and clearly defined execution boundaries produces an 11.5% relative gain in task success and a 94.9% reduction in completion time versus the strongest baseline, while lowering setup burden.

What carries the argument

Device tools: on-phone interfaces that wrap sensors, apps, and system services with typed arguments, structured results, and hard execution boundaries so the agent can call capabilities directly instead of simulating UI gestures.

Load-bearing premise

The measured gains come from the native tool-and-boundary design itself rather than from unequal task suites, different backbone models, unequal tool access, or baseline misconfiguration.

What would settle it

Re-run the same multi-step mobile task suite with identical backbone models and equal tool access for PalmClaw and the strongest GUI baseline; if the success-rate gap and the 94.9% time reduction disappear, the central claim fails.

Watch this falsifier — get emailed when new claim-graph text bears on it.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Desk Editor's Note

Native on-device mobile agent with tool-level execution boundaries is a real systems idea; the 11.5%/94.9% numbers cannot be audited from the abstract alone.

read the letter

The one thing to know: PalmClaw is an open-source native on-device agent stack that treats phone capabilities as tools with explicit arguments, structured results, and defined execution boundaries, instead of long GUI action sequences. That framing is the actual contribution. The abstract claims an 11.5% relative success lift and a 94.9% time cut versus the strongest baseline, plus lower setup burden, and they ship code.

What is new and useful is the systems reification. GUI mobile agents are already a crowded line; making device APIs first-class tools with clear boundaries is a cleaner control surface for multi-step automation and for keeping actions auditable. Running the session, memory, skills, tools, and agent loop on-device is the right target for personal data and sensors. Shipping the repo is real credit; it makes the artifact checkable even when the paper is thin.

The soft spot is exactly the evidence gap the reader flagged. We have only the abstract. No task suite, no baseline identities, no backbone models, no sample sizes, no variance, no ablation that isolates the execution-boundary design from unequal tool access or model differences. So the numbers are stated, not demonstrated here. That is ordinary abstract-only risk, not a contradiction inside the design. Circularity is low; success and latency are external metrics. The stress-test note is right: there is no deeper hidden flaw visible, just missing methods.

Who this is for: people building mobile agents, on-device LLM systems, or OS-level tool APIs. A systems reader who cares about control surfaces and latency will get value; a pure methods reader will want the full eval before citing the percentages. It deserves a serious referee if the full paper and artifacts match the abstract. I would not desk-reject on this abstract; I would send it out and demand the task definitions, baselines, and ablations. Worth a look once the PDF and code are in hand; not yet something I would cite on the numbers alone.

Referee Report

3 major / 4 minor

Summary. The manuscript introduces PalmClaw, an open-source agent framework that runs natively on mobile phones and manages sessions, memory, skills, tools, and the agent loop on-device. It argues that existing mobile agents rely on GUI action sequences (taps, swipes, typing), which are long, interface-dependent, cannot access device capabilities directly, and make execution boundaries hard to define. PalmClaw instead exposes device capabilities as tools with explicit arguments, structured results, and clearly defined execution boundaries. The abstract reports an 11.5% relative improvement in task success and a 94.9% reduction in completion time over the strongest baseline, with lower setup burden, and states that traces illustrate how execution boundaries are applied. Code is linked at a public repository.

Significance. If the empirical claims hold under proper controls, PalmClaw would be a useful systems contribution for on-device mobile agents: native device-tool abstractions with explicit execution boundaries are a plausible alternative to brittle GUI action sequences, and an open-source on-device stack (sessions, memory, skills, tools, agent loop) would lower the barrier for reproducible mobile-agent research. The reported time reduction, if real and not an artifact of unequal tool access or task design, would be practically important for interactive mobile use. Significance is currently provisional because only the abstract is available; the contribution cannot be assessed without methods, task suite, baselines, and ablations.

major comments (3)

The central quantitative claims (11.5% relative success improvement and 94.9% time reduction over the strongest baseline) cannot be audited from the abstract alone. A full methods section is required that specifies: the task suite and success criteria; sample sizes and variance or confidence intervals; backbone model identities and whether they are held fixed across systems; tool-access parity (whether baselines receive equivalent device capabilities or only GUI actions); and how the strongest baseline was selected and configured. Without these, the gains cannot be attributed to the proposed design.
The abstract attributes gains to device tools with explicit arguments, structured results, and clearly defined execution boundaries, but provides no ablation or controlled comparison that isolates this design choice from confounds (native vs. remote execution, different tool sets, unequal setup cost, or different agent loops). The manuscript needs an ablation or controlled experiment that holds the backbone and task suite fixed and varies only the presence of native device-tool boundaries versus GUI-only action sequences.
Execution boundaries are presented as a core contribution (safer/more controlled actions), yet the abstract only states that traces illustrate how they are applied. The paper must define the boundary mechanism formally or operationally (what is allowed, denied, or sandboxed; how arguments and structured results are validated; failure and recovery semantics) and report safety- or control-related metrics, not only success and wall-clock time.

minor comments (4)

Define or cite the evaluation protocol for task success and completion time (e.g., human judgment criteria, automatic checkers, timeout policy) so that the 11.5% and 94.9% figures are reproducible.
Clarify what is meant by lower setup burden (user steps, lines of configuration, permissions, or developer effort) and report a quantitative or qualitative comparison.
When the full text is available, ensure figures or tables list absolute success rates and times for all systems, not only relative improvements, and name the strongest baseline explicitly.
The abstract-only submission leaves open whether related on-device and mobile-agent frameworks are adequately positioned; the related-work section should compare tool-calling mobile agents and GUI-based agents under a common taxonomy.

Circularity Check

0 steps flagged

No significant circularity: empirical systems claim with external success/time metrics; abstract-only review finds no definitional or fitted-input reduction.

full rationale

This is an empirical systems paper proposing PalmClaw, a native on-device mobile agent framework that exposes device capabilities as tools with explicit arguments, structured results, and defined execution boundaries. The central claims are measured outcomes (11.5% relative task-success improvement and 94.9% completion-time reduction versus the strongest baseline, plus lower setup burden). These are external performance metrics, not quantities derived from fitted parameters that are then re-presented as predictions, nor results that reduce by construction to self-defined inputs. No equations, uniqueness theorems, ansatzes imported via self-citation, or renaming of known empirical patterns appear in the available abstract. Self-citation load-bearing is not present. With only the abstract available, experimental design cannot be inspected for confounds, but that is a correctness/verification concern, not circularity. Per the default expectation and hard rules, the honest finding is no significant circularity (score 0); steps remain empty.

Axiom & Free-Parameter Ledger

0 free parameters · 3 axioms · 1 invented entities

Abstract-only systems paper. No free parameters are fitted in a scientific-model sense; the work rests on standard LLM-agent assumptions and the engineering claim that device capabilities can be wrapped as tools with explicit boundaries. No new physical entities are invented.

axioms (3)

domain assumption LLM agents can complete multi-step mobile tasks by iteratively calling tools, observing results, and choosing next actions.
Background premise of the agent-loop design stated in the opening of the abstract.
ad hoc to paper Device capabilities can be exposed as tools with explicit arguments, structured results, and well-defined execution boundaries that are safer/more efficient than GUI action sequences.
Core design premise of PalmClaw; success of the framework depends on this engineering assumption holding for real phone tasks.
domain assumption On-device management of sessions, memory, skills, tools, and the agent loop is feasible under mobile resource constraints.
Implied by the claim that the full agent stack runs natively on phones; not evidenced in the abstract.

invented entities (1)

PalmClaw device-tool abstraction with execution boundaries no independent evidence
purpose: Replace long GUI action sequences with explicit, controlled device capability calls on-phone.
The framework’s central abstraction; independent evidence would be third-party replications and broader task suites, not yet inspectable from the abstract.

pith-pipeline@v1.1.0-grok45 · 6140 in / 2327 out tokens · 22378 ms · 2026-07-15T01:27:06.017962+00:00 · methodology

0 comments

read the original abstract

Large Language Model (LLM) agents have moved beyond generating responses to executing multi-step tasks by calling tools, observing the results, and iteratively deciding the next action. Most agent systems run on desktops or servers, which support tool use and task automation. Mobile devices are also important agent environments because they are widely accessible and contain users' data, sensors, and daily-use applications. Existing mobile agents mainly operate smartphones through graphical user interface (GUI) actions such as tapping, swiping, and typing, which often form long, interface-dependent sequences, cannot directly access device capabilities, and make execution boundaries difficult to define. We present \textbf{PalmClaw}, an open-source agent framework that runs natively on mobile phones and manages the sessions, memory, skills, tools, and agent loop directly on the device. PalmClaw exposes device capabilities as device tools with explicit arguments, structured results, and clearly defined execution boundaries. This design enables agents to use mobile capabilities directly while keeping each action explicit and controlled. Experiments show an 11.5\% relative improvement in task success and a 94.9\% reduction in completion time over the strongest baseline, with lower setup burden and traces illustrating how execution boundaries are applied. Code is available at https://github.com/ModalityDance/PalmClaw.

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

Core claim

What carries the argument

Load-bearing premise

What would settle it

discussion (0)