2026-7-15
PalmClaw: A Native On-Device Agent Framework for Mobile Phones Hongru Cai1
Yongqi Li1†
1 The Hong Kong Polytechnic University
Ran Wei2
Wenjie Li1
2 Hangzhou Diagens Biotechnology Co., Ltd.
{henry.hongrucai, liyongqi0}@gmail.com
arXiv:2607.13027v1 [cs.CL] 14 Jul 2026
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 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.
§ GitHub: https://github.com/ModalityDance/PalmClaw
execute tools, and feed the resulting observations into subsequent turns. Representative agent frameworks, such as AutoGen [9], AgentScope [5], and OpenClaw [4] host these components on a desktop computer or cloud server. While desktop and server platforms provide a rich and practical environment for agents, we argue that supporting agents natively on mobile devices is also important. First, mobile phones are among the most widely available personal computing devices, with four out of five people aged 10 or older worldwide owning one [10]. This broad availability allows mobile-native agents to reach users who may not have continuous access to a personal computer. Second, smartphones store highly personal data, provide sensors such as cameras, microphones, and location, and host many of the applications used in everyday life [11]. Running agents directly on smartphones can therefore place them closer to the users, their device resources, and the capabilities required for daily tasks.
1 Introduction Recent Large Language Model (LLM) agents have moved beyond generating responses to executing tasks in external environments [1, 2, 3]. Given a complex user instruction, the agent can decompose the task into multiple steps, call tools, observe the results, and iteratively decide what to do next until the task is completed [4, 5]. This iterative interaction enables agents not only to offer advice, but more importantly, to autonomously execute tasks such as information seeking [6], file management [7, 3], and workflow automation [8]. An agent is essentially a framework upon a foundational LLM through the incorporation of instructions, persistent memory, reusable skills, executable tools, session management, and an iterative agent loop. Together, these components allow the agent to retrieve relevant memory and session history, load task-specific instructions and skills, invoke the LLM, † Corresponding author.
1
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
Desktop or Cloud Host GUI State Observation Sessions LLM Call Agent Loop Memory Tools Skills Action GUI Actions
runs the agent loop and manages its memory, skills, tools, and session state on the mobile device. It exposes device resources and capabilities through device tools: device operations with explicit arguments, structured results, and tool-specific execution boundaries. Together, our framework reduces dependence on external desktop or server devices for agent orchestration, allows agents to use mobile capabilities more directly, and keeps each mobile action explicit and bounded. Experiments on representative mobile tasks show that PalmClaw improves task completion success by 11.5% relative to the strongest baseline and reduces average task completion time by 94.9%. Deployment and trace analyses further show lower setup burden and illustrate how execution boundaries are applied. The key contributions are as follows: • We present PalmClaw, an open-source mobilenative agent framework that hosts the agent loop, memory, skills, tools, and session state directly on the mobile device.
Mobile Device Scroll
Swipe
Type
Tap
Zoom
Operation Env. (a) Externally hosted GUI-based mobile agent
Message Sessions
Mobile Device Tool Calls LLM Call
Boundary
Tools
Execution
Agent Loop
Device Media
Files Web Skills Results Response … Resources & Agent Components Tool Execution Capabilities (b) Overview of PalmClaw’s framework
Memory
Figure 1: Overview of PalmClaw. (a) An externally hosted mobile agent exchanges GUI states and GUI actions between a desktop or cloud host and the phone. (b) PalmClaw runs the agent components on the mobile device and connects them to device resources and capabilities through device tools.
• We design device tools that expose mobile resources and capabilities through explicit arguments, structured results, and tool-specific execution boundaries.
Despite this potential, existing mobile agents primarily operate smartphones through GUI actions such as tapping, swiping, and typing (see Figure 1(a)) [11, 12, 13]. Although broadly compatible with existing applications, this approach has three limitations: 1) high-level tasks become long action sequences that are sensitive to layout changes and complex interfaces; 2) it cannot directly access device resources and capabilities, such as local files and sensor data; and 3) GUI control grants broad access to reachable interfaces, without clear task-specific access limits or execution boundaries. GUI interaction is therefore useful for general screen operations, but insufficient as the sole action space for mobile agents. The recent rise of terminal-native agents such as Codex CLI [14], Claude Code [15], and Gemini CLI [16] reflects a broader shift toward explicit and executable tool-based interaction, motivating a similar native on-device design for mobile agents. We present PalmClaw, an open-source agent framework designed to run natively within the mobile environment1 . As shown in Figure 1(b), PalmClaw
• We evaluate PalmClaw on mobile tasks, showing an 11.5% relative improvement in task success and a 94.9% reduction in completion time, with lower setup burden and a trace-based analysis of execution boundaries.
2 Related Work General agent frameworks. LLM agents extend language models with tool use, intermediate observations, and multi-step action loops. ReAct [1] connects reasoning traces with actions, and Toolformer [2] studies API calls as part of language modeling. Frameworks such as AutoGen [9], AgentScope [5], and OpenClaw [4] package these mechanisms into systems for real tasks, hosted on computers or cloud servers. PalmClaw instead hosts the agent components directly on the mobile device. Mobile agents. Mobile agents study how LLMbased systems can complete tasks on smartphones. packages are available at https://github.com/ModalityDance/
1 PalmClaw is released under the AGPLv3 license. Installable
PalmClaw/releases/latest
2
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
On-Device Agent Components Messages Local Message Remote Channel Scheduled Wakeup
Sessions
Device Tool Execution Tool Calls
Memory
Long-term Session
Schema
required type range
Skills LLM Call Agent Loop Tools
Tool Registry
Workspace
Device & Media Personal Data
Permissions
Workspace & Files
Confirm
Web
Device
Execution Results
Response
Resources & Capabilities
Channels & Automations
Figure 2: Overview of the PalmClaw framework. Inputs are assigned to mobile sessions, where context is assembled, and the agent loop is executed. Tool calls are checked and executed on the device before their results are returned to the agent loop.
Existing work has developed mobile agents and benchmarks, including AndroidWorld [17], MobileAgentBench [11], Mobile-Bench [18], AgentCPMGUI [12], and Mobile-Agent-v3.5 [19]. Related systems such as ApkClaw [20], MobileClaw [21], and ClawMobile [22] also explore phone-side task execution with GUI actions. PalmClaw focuses on hosting the agent framework on the phone and exposing device capabilities through device tools.
3.2 Agent Components
PalmClaw maintains sessions, memory, skills, and device tools directly on the mobile device. Sessions. Sessions organize persistent agent interactions from three input sources: local chat messages, messages from connected remote channels, and automated messages generated by scheduled wakeups. Each session stores its conversation history, tool traces, attachments, and a dedicated workspace for documents, temporary files, and generated artifacts. PalmClaw routes each input to an existing or new session, allowing tasks to continue across multiple turns while keeping concurrent tasks separate.
3 Framework This section describes the agent components in PalmClaw and how they work together during on-device execution.
Memory. PalmClaw maintains two persistent memory layers: 1) shared long-term memory, which stores information available across sessions and is included in each agent’s turn, and 2) per-session summaries, which keep compact records of task progress and conclusions. When unconsolidated messages reach a configurable window, a separate LLM call summarizes older messages and updates both layers. Memory tools allow the agent to read or update long-term memory and to read or search the history of a selected session.
3.1 Overview
PalmClaw runs the components needed for multistep agent execution directly on the mobile device. As shown in Figure 2, sessions organize user interactions, memory preserves reusable information, skills provide task-specific instructions, and tools expose device resources and capabilities. The agent loop combines these components through repeated model and tool interactions. LLM inference is provided through a remote LLM API, while context management, tool execution, and session state remain on the mobile device. PalmClaw integrates these components into a mobile application, with representative interfaces shown in Figure 6.
Skills. Skills are reusable task instructions for applying tools and completing common routines, stored in SKILL.md files. PalmClaw provides built-in and user-installed skills. For each turn, it adds a summary of available skills to the context, loads the full instructions of skills marked as always active, and 3
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
Capability Device & Media Personal Data
Skills device media Bluetooth personal
six sources: 1) system instructions from AGENT.md, SOUL.md, and USER.md; 2) runtime context, including the current time, timezone, session ID, and workspace paths; 3) shared long-term memory; 4) active skill instructions and a summary of available skills; 5) recent conversation history, attachments, and tool traces; and 6) available tool specifications, including their names, descriptions, and argument schemas. The first five sources form the model messages, while the tool specifications are provided alongside them to the remote LLM API. Figure 5 shows an example of this context.
Tools device() media() bluetooth() calendar()
contacts()
list() glob() grep() read() write() edit() delete() move()
Workspace
file
Web
weather summarize
search() fetch()
Channels & Automation
channels cron
sessions() message() heartbeat() cron() mcp() runtime()
Memory & Skills
memory skill-creator
memory()
summarize() weather()
Agent loop. PalmClaw runs each agent turn as a bounded multi-round loop that connects remote LLM reasoning with on-device tool execution [1, 2]. In each round, PalmClaw rebuilds the context from the current session state, sends the model messages and available tool specifications to the remote LLM API, and stores the returned assistant message in the session. If the response contains tool calls, PalmClaw executes them, appends their results to the session, and starts the next round with the updated context. If the response contains no tool calls, it becomes the final reply. The loop also ends when a tool signals task completion or the round limit is reached.
Figure 3: Built-in skills and tool groups in PalmClaw. Skills provide reusable task instructions, while tools expose device, personal data, workspace, web, communication, and automation capabilities.
selects other relevant skills by matching recent user messages against their names, descriptions, and keywords. Only always-active and selected skills are loaded in full, providing task-specific guidance without loading every skill into the context. Figure 3 summarizes the built-in skills and tool groups.
Tool execution. Tool calls from the agent loop enter the device tool execution path shown in Figure 2. PalmClaw first matches each call to the tool registry. Before the corresponding operation is executed, the call passes three checks: 1) Schema validates required arguments, types, and allowed ranges. 2) Permissions includes device authorization and user confirmation. Missing permissions invoke the system permission or settings flow, while actions requiring direct user involvement proceed only after the user confirms or completes them. 3) Workspace resolves file paths within the current session workspace or approved shared storage, rejects other session workspaces and unapproved global paths, and requires confirmation before external writes. A call that passes these checks is executed against the corresponding device resource or capability. Its structured result is returned to the session for the next round; if a check fails or the user declines, PalmClaw returns a structured error.
Tools. Device tools connect model-generated tool calls to resources and capabilities available on the phone. Each tool links a model-facing specification containing its name, description, and JSON argument schema and a device-facing function that invokes a mobile service or app-managed operation. PalmClaw sends the specification to the LLM, executes the associated function when called, and returns a structured result or error. Built-in device tools cover device status and permissions, media, Bluetooth, calendar, and contacts, and workspace files; other tool groups support web access, memory, communication, and scheduled automation. 3.3 Agent Execution
These components work together through context assembly, the agent loop, and device tool execution. Context assembly. After an input is assigned to a session, PalmClaw assembles the agent context from 4
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
Table 1: Task-completion results. MobileTask reports success rate and average actions, total tokens, and completion time per task; AssistantBench reports official accuracy on the selected dev subset. Framework
Host
MobileTask
Action space
Actions ↓ Tokens ↓ MobileClaw Desktop GUI actions ClawMobile Termux APIs and GUI actions ApkClaw Mobile app GUI actions PalmClaw Mobile app Device tools
94.3 51.4 103.9 2.8
1.30M 466.4K 2.06M 50.4K
AssistantBench
Time ↓
Success Rate ↑
Accuracy ↑
1197.0s 451.1s 348.8s 17.7s
60.0% 77.1% 87.1% 97.1%
5.26% 10.49% 25.79% 36.85%
external Python runtime and controls the phone through screen observations and GUI actions. 3) ClawMobile [22] places the agent runtime in Termux, an Android terminal environment that provides a Linux-like space on the phone, and executes actions through phone APIs, shell commands, and GUI control.
4 Evaluation We evaluate PalmClaw’s on-device agent framework through three questions: • RQ1: Does PalmClaw support effective mobile task completion through its on-device agent framework and device tools? • RQ2: Does hosting the agent framework on the mobile device reduce external deployment and operation requirements?
Implementation. All mobile experiments are run on Android, using a Xiaomi Redmi 2312DRAABC phone with Android 13 (SDK 33). We use DeepSeek-V4-Flash [24] as the LLM backbone for all systems. MobileClaw additionally requires a visual GUI model for screenshot-based grounding, so we use qwen3.7-plus [25]. For AssistantBench, PalmClaw uses a 30-round limit, and screen-based baselines use a 100-round limit, since GUI agents often spend extra rounds on observation and navigation before taking an action.
• RQ3: How are execution boundaries applied when PalmClaw’s device tools execute mobile actions? 4.1 Experimental Setup
Datasets. We evaluate PalmClaw on two datasets. 1) MobileTask contains 70 mobile tasks adapted from AndroidWorld [17], MobileAgentBench [11], and Mobile-Bench [18]. It covers calendar, weather, contacts, audio, notes, files, Bluetooth, and media tasks, and is evaluated by task success. We use deterministic final-state checks when possible, evidence-grounded judging for answer-based tasks, and manual review for permission- or device-state tasks. 2) AssistantBench [23] evaluates realistic web information-seeking tasks with verifiable answers. We use a 19-task development-set subset because the local test split does not provide gold answers, and some development tasks contain unstable real-time values. AssistantBench is evaluated with the official accuracy metric. Appendix A.2 gives the construction procedure and dataset statistics.
4.2 Task Completion (RQ1)
We first test whether PalmClaw can complete mobile tasks through its on-device agent framework and device tools. In addition to task success, we report the average number of actions, total tokens, and completion time per task. We count one LLM API call as one action. Token counts include all input and output tokens, and completion time is averaged over all tasks. These measures are essential because users are sensitive to response latency when completing tasks on a phone. Results in Table 1 give two findings. 1) PalmClaw differs from the baselines in both framework placement and action space. It runs the agent components on the mobile device and acts through device tools, whereas the baselines rely on GUI actions, combine APIs with GUI control, or host the agent framework on a desktop. 2) On MobileTask, PalmClaw achieves
Baselines. We compare PalmClaw with three representative open-source mobile-agent baselines. 1) ApkClaw [20] is an Android app for natural-language device control and acts through GUI operations such as tapping, swiping, typing, and opening apps. 2) MobileClaw [21] uses a phone-side client with an 5
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
Table 2: Deployment and operation comparison. Computer indicates whether a separate desktop or server is required; CLI indicates command-line setup or operation; Bridge indicates a connection between the phone and another control service. Framework
External Requirements Yes Yes No No No
Yes Optional Yes Yes Yes Optional No No No No
PalmClaw
Setup
Computer CLI Bridge # Steps OpenClaw MobileClaw ClawMobile ApkClaw PalmClaw
Case 1: Calendar Permission Case 2: Workspace Boundary User User “Add a meeting with Alex “Save my shopping list to tomorrow at 10 a.m.” SDCard/list.txt.”
4 8 6 3 2
Time ∼5 min ∼15 min ∼25 min ∼5 min ∼2 min
an 11.5% relative improvement in task success and a 94.9% reduction in average completion time over the strongest baseline, while using fewer actions and tokens. It also obtains the highest accuracy on AssistantBench. These observations show that PalmClaw supports effective and efficient mobile task execution. A key reason for the efficiency gains is that device tools expose mobile resources and capabilities as structured operations, allowing many tasks to avoid long sequences of screen observation, navigation, and GUI actions.
Tool Call: calendar() Result: Permission missing. Send permission request.
User Grant calendar permission. PalmClaw Tool Call: calendar() Result: Permission granted. Event created. Response: “Event created at tomorrow 10 a.m. ”
PalmClaw Tool Call: write() Result: File path outside current workspace. All files access required.
Tool Call: device() Result: Open app settings. Response: “Please grant access to all files to continue.”
User Enable All files access. PalmClaw (Write files and reply.)
Figure 4: Two execution-boundary traces. PalmClaw requests device permissions when possible and gives explicit settings instructions when a workspace boundary requires all files access.
bile application. 2) PalmClaw needs two setup steps and about two minutes before the first instruction, less than the compared frameworks. Because both the user entry point and agent framework are on the phone, setup does not require a separate computer or bridge.
4.3 Deployment and Operation (RQ2)
To examine whether PalmClaw reduces the external environment needed to deploy and operate a mobile agent, we compare two aspects of each framework: external requirements and setup burden. The comparison includes the mobile-agent baselines used above and OpenClaw [4], which serves as a representative desktop-hosted agent framework. Computer records whether deployment or operation requires a separate computer. CLI denotes setup or operation through command-line commands. Bridge denotes a required connection between the phone and another runtime or control service. We then manually deploy each framework and record the visible setup steps and time. Table 2 gives two findings. 1) PalmClaw does not require a separate computer, CLI workflow, or bridge. The agent can therefore be started and used on the mobile device without attaching the task flow to another execution environment. This follows from PalmClaw’s on-device design: its agent components and execution flow are integrated within the same mo-
4.4 Execution Boundaries (RQ3)
We use trace-based case analysis to illustrate how execution boundaries are applied during device tool execution. We collect records where PalmClaw stops, requests user involvement, or returns a failure because a tool call reaches a permission or confirmation boundary, a workspace boundary, or an unsupported operation. The traces show how PalmClaw checks a tool call before it becomes a mobile operation. Each call is matched to the tool registry and then passes the relevant schema, permission or confirmation, and workspace checks before execution. Thus, the agent does not receive an open command channel to the phone. Figure 4 visualizes two representative cases: a calendar permission that can be granted through the platform permission flow, and a workspace bound6
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
ary where a public path requires manual settings access. Table 3 in the appendix lists additional cases.
validated, sensitive actions rely on Android permissions or user confirmation, and file operations follow workspace boundaries. Deployments should still make provider-side data flow clear to users, especially when remote LLM providers receive prompts, tool results, or task context. The experiments in this paper use public or constructed evaluation tasks and do not require collecting private user data.
Case 1: Calendar permission. In the calendarpermission case, the user asks PalmClaw to add a meeting, and the agent reaches the boundary when the calendar tool checks whether calendar access is available. As shown in Figure 4, PalmClaw does not continue with an unchecked calendar operation. It sends a mobile permission request to the user, then continues the same task if access is granted. If access is not granted, the agent reports the permission issue and explains what the user needs to do instead of claiming that the meeting was created.
References [1] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. ReAct: Synergizing reasoning and acting in language models. In International Conference on Learning Representations, 2023. URL https://arxiv.org/abs/2210. 03629. [2] Timo Schick, Jane Dwivedi-Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. In A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine, editors, Advances in Neural Information Processing Systems, volume 36, pages 68539–68551. Curran Associates, Inc., 2023. [3] Xiangyi Li, Kyoung Whan Choe, Yimin Liu, Xiaokun Chen, Chujun Tao, Bingran You, Wenbo Chen, Zonglin Di, Jiankai Sun, Shenghan Zheng, Jiajun Bao, Yuanli Wang, Weixiang Yan, Yiyuan Li, and Han chung Lee. Clawsbench: Evaluating capability and safety of llm productivity agents in simulated workspaces, 2026. URL https://arxiv.org/ abs/2604.05172. [4] OpenClaw. OpenClaw: Personal ai assistant. https: //github.com/openclaw/openclaw, 2026. Software repository. Accessed: 2026-06-29. [5] Dawei Gao, Zitao Li, Yuexiang Xie, Weirui Kuang, Liuyi Yao, Bingchen Qian, Zhijian Ma, Yue Cui, Haohao Luo, Shen Li, Lu Yi, Yi Yu, Shiqi He, Zhiling Luo, Wenmeng Zhou, Zhicheng Zhang, Xuguang He, Ziqian Chen, Weikai Liao, Farruh Isakulovich Kushnazarov, Yaliang Li, Bolin Ding, and Jingren Zhou. Agentscope 1.0: A developer-centric framework for building agentic applications, 2025. URL https://arxiv.org/abs/2508.16279. [6] Yutao Zhu, Xingshuo Zhang, Maosen Zhang, Jiajie Jin, Liancheng Zhang, Xiaoshuai Song, Kangzhi Zhao, Wencong Zeng, Ruiming Tang, Han Li, JiRong Wen, and Zhicheng Dou. Gisa: A benchmark for general information-seeking assistant, 2026. URL https://arxiv.org/abs/2602.08543. [7] Tianbao Xie, Danyang Zhang, Jixuan Chen, Xi-
Case 2: Workspace boundary. In this case, the user asks PalmClaw to save a shopping list outside the current workspace, such as under /sdcard/list.txt. PalmClaw resolves the requested path before completing the file operation, and the file tool returns a boundary result because this public path requires access to all files. Unlike calendar permission, this access cannot be granted through a normal mobile permission prompt. PalmClaw opens the application settings page and tells the user to enable all files access manually.
5 Conclusion This paper examined how agent frameworks can be designed for the mobile environment beyond operating phone interfaces. We presented PalmClaw, an open-source on-device agent framework that runs directly on the phone and exposes device capabilities through device tools with explicit arguments, structured results, and tool-specific execution boundaries. On MobileTask, PalmClaw achieves an 11.5% relative improvement in task success and a 94.9% reduction in completion time, while lowering setup burden. Trace-based cases further illustrate how its execution boundaries are applied. Together, these results show that mobile phones can serve as environments for agent frameworks, extending mobile-agent research beyond screen operation toward direct and controlled use of device capabilities.
Ethics Statement PalmClaw is designed to keep mobile actions explicit and bounded: tools are registered, arguments are 7
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
aochuan Li, Siheng Zhao, Ruisheng Cao, Toh Jing Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese, Caiming Xiong, Victor Zhong, and Tao Yu. Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments, 2024. [8] Frank F. Xu, Yufan Song, Boxuan Li, et al. Theagentcompany: Benchmarking LLM agents on consequential real world tasks. In The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2025. URL https://openreview.net/forum?id=LZnKNApvhG. [9] Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W White, Doug Burger, and Chi Wang. Autogen: Enabling next-gen llm applications via multiagent conversation, 2023. URL https://arxiv.org/ abs/2308.08155. [10] International Telecommunication Union. Facts and figures 2024: Mobile phone ownership. https://www.itu.int/itu-d/reports/statistics/ 2024/11/10/ff24-mobile-phone-ownership/, 2024. Accessed: 2026-07-10. [11] Luyuan Wang, Yongyu Deng, Yiwei Zha, Guodong Mao, Qinmin Wang, Tianchen Min, Wei Chen, and Shoufa Chen. Mobileagentbench: An efficient and user-friendly benchmark for mobile llm agents, 2024. URL https://arxiv.org/abs/2406.08184. [12] Zhong Zhang, Yaxi Lu, Yikun Fu, et al. AgentCPMGUI: Building mobile-use agents with reinforcement fine-tuning. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, 2025. [13] Jiabo Ye, Xi Zhang, Haiyang Xu, Haowei Liu, Junyang Wang, Zhaoqing Zhu, Ziwei Zheng, Feiyu Gao, Junjie Cao, Zhengxi Lu, Jitong Liao, Qi Zheng, Fei Huang, Jingren Zhou, and Ming Yan. Mobile-agentv3: Fundamental agents for gui automation, 2025. URL https://arxiv.org/abs/2508.15144. [14] OpenAI. Codex CLI. https://developers.openai. com/codex/cli, 2025. Accessed: 2026-07-10. [15] Anthropic. Claude 3.7 Sonnet and Claude Code. https://www.anthropic.com/news/ claude-3-7-sonnet, 2025. Accessed: 2026-07-10. [16] Google. Gemini CLI: Your OpenSource AI Agent. https://blog.google/ innovation-and-ai/technology/developers-tools/ introducing-gemini-cli-open-source-ai-agent/, 2025. Accessed: 2026-07-10. [17] Christopher Rawles, Sarah Clinckemaillie, Yifan Chang, Jonathan Waltz, Gabrielle Lau, Marybeth Fair, Alice Li, William Bishop, Wei Li, Folawiyo
Campbell-Ajala, Daniel Toyama, Robert Berry, Divya Tyamagundlu, Timothy Lillicrap, and Oriana Riva. Androidworld: A dynamic benchmarking environment for autonomous agents, 2024. URL https://arxiv.org/abs/2405.14573. [18] Shihan Deng, Weikai Xu, Hongda Sun, Wei Liu, Tao Tan, Jianfeng Liu, Ang Li, Jian Luan, Bin Wang, Rui Yan, and Shuo Shang. Mobile-bench: An evaluation benchmark for LLM-based mobile agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2024. [19] Haiyang Xu, Xi Zhang, Haowei Liu, Junyang Wang, Zhaozai Zhu, Shengjie Zhou, Xuhao Hu, Feiyu Gao, Junjie Cao, Zihua Wang, Zhiyuan Chen, Jitong Liao, Qi Zheng, Jiahui Zeng, Ze Xu, Shuai Bai, Junyang Lin, Jingren Zhou, and Ming Yan. Mobile-agentv3.5: Multi-platform fundamental gui agents, 2026. URL https://arxiv.org/abs/2602.16855. [20] ApkClaw Team. ApkClaw. https://github.com/ apkclaw-team/ApkClaw, 2026. Software repository. Accessed: 2026-06-29. [21] MobileClaw. MobileClaw: Fully autonomous mobile agent. https://github.com/MobileClaw/MobileClaw, 2026. Software repository. Accessed: 2026-06-29. [22] Hongchao Du, Shangyu Wu, Qiao Li, Riwei Pan, Jinheng Li, Youcheng Sun, and Chun Jason Xue. ClawMobile: Rethinking smartphone-native agentic systems. In Proceedings of the Sixth European Workshop on Machine Learning and Systems, 2026. [23] Ori Yoran, Samuel Joseph Amouyal, Chaitanya Malaviya, Ben Bogin, Ofir Press, and Jonathan Berant. AssistantBench: Can web agents solve realistic and time-consuming tasks? In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2024. doi: 10.18653/v1/2024. emnlp-main.505. URL https://aclanthology.org/ 2024.emnlp-main.505/. [24] DeepSeek-AI et al. Deepseek-v4: Towards highly efficient million-token context intelligence, 2026. URL https://arxiv.org/abs/2606.19348. [25] Qwen Team. Qwen3.7-Plus: Multimodal Agent Intelligence, June 2026. URL https://qwen.ai/blog? id=qwen3.7-plus. Accessed: 2026-07-10.
8
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
A Additional Details A.1 Agent Context Composition
Figure 5 shows a shortened example of the context assembled for one PalmClaw agent turn. It includes system instructions, runtime context, shared long-term memory, active skill instructions, and an availableskill summary, recent conversation history, tool traces, and available tools.
Agent Context SYSTEM PROMPT ## AGENT.md You are PalmClaw, an assistant inside a mobile app… ## SOUL.md You should be helpful, concise, clear… ## USER.md The user’s name, timezone, language, work context… RUNTIME CONTEXT • Current_time: 2026-07-07 14:30:00 • Timezone: Asia/Hong Kong • Session_id: LOCAL • Workspace: /app/workspace1 MEMORY ## Long-term Memory User preferences… Personal facts… Writing Style… ## Session Memory Project notes… Currently focus on… SKILLS ## Active Skills Currently selected SKILL.md contents ## Skills <skill> name: workspace description: session file operations location: asset://skills/workspace/SKILL.md </skill>... CONVERSATION HISTORY USER: Add a meeting with Alex tomorrow at 10 a.m. ASSISTANT: [tool call] calendar_create_event(...) TOOL: permission missing... ASSISTANT: I need calendar permission to continue… TOOLS calendar_create_event: description: create calendar event schema: {title, start_time, end_time, timezone, ...} write: description: write file in session workspace schema: {path, content, overwrite} …
A.2 Datasets and Metrics
MobileTask. MobileTask adapts tasks from AndroidWorld [17], MobileAgentBench [11], and MobileBench [18]. Each candidate is rewritten as a usergoal instruction with a task identifier, source label, expected artifact, and evaluation note. We retain a task only if 1) it can be attempted without a fixed GUI path, 2) it does not depend on third-party app state, and 3) it does not favor GUI-only agents. We also remove unstable cases, including relative dates, live weather, and duplicated calendar variants. AssistantBench. AssistantBench [23] is used as a secondary information-seeking set. From the 33-task dev set, we keep 19 tasks whose answers remain checkable after manual review. We exclude tasks with 1) unstable live-state answers, or 2) reference answers that cannot be checked reliably. Table 4 summarizes statistics for the two datasets used in the evaluation. Metrics. MobileTask reports the mean success rate over 70 tasks. A task is successful when its final state or answer matches the predefined oracle, using deterministic checks for directly inspectable outcomes. For answer-based tasks, the same DeepSeek-V4-Flash model serves as the judge. It receives the task instruction, the agent’s final answer, and fixed reference evidence, and returns a binary success-or-failure decision. AssistantBench reports official accuracy averaged over the subset, using word-level F1 for string answers, log-distance scoring for numeric answers, and aligned mean F1 for list answers.
Figure 5: Agent context assembled for one PalmClaw turn.
9
PalmClaw: A Native On-Device Agent Framework for Mobile Phones
Table 3: Execution boundary cases. Each row shows the boundary event and the resulting agent outcome. Boundary
User request
Boundary event
Agent outcome
Missing permission
“Add a meeting with Alex tomorrow at 10 a.m.” “Take a photo of my desk to check the setup.” “Save my shopping list to SDCard/list.txt.” “Open Instagram to check updates from my friends.”
Calendar permission missing Manual confirmation needed File path outside workspace
Requests permission
No matching tool
Reports unsupported operation
User confirmation Workspace boundary Unsupported action
Sends confirmation request Tells user to enable access
Table 4: Dataset statistics. MobileTask lists task types and source benchmarks; AssistantBench lists difficulty levels from the dev set. Dataset
Category Source
#
Calendar
AndroidWorld MobileAgentBench
32 3
Weather
Mobile-Bench
10
Contacts
AndroidWorld MobileAgentBench
3 4
Audio
AndroidWorld MobileAgentBench
4 3
Notes
MobileAgentBench
4
Files
MobileAgentBench
3
MobileTask
Bluetooth AndroidWorld
2
Media
2
AndroidWorld
Total Medium AssistantBench Hard Total
(a) Provider setup
(b) Task completion
(c) Permission
(d) Settings
70 Dev set Dev set
10 9 19
Figure 6: PalmClaw application interface. The screenshots show (a) provider setup, (b) a calendar task completed through device tools, (c) a permission request before calendar access, and (d) settings.
10