ClawMobile: Rethinking Smartphone-Native Agentic Systems

Abstract: Smartphones represent a uniquely challenging environment for agentic systems. Unlike cloud or desktop settings, mobile devices combine constrained execution contexts, fragmented control interfaces, and rapidly changing application states. As LLMs evolve from conversational assistants to action-oriented agents, achieving reliable smartphone-native autonomy requires rethinking how reasoning and control are composed. We introduce ClawMobile as a concrete exploration of this design space. ClawMobile adopts a hierarchical architecture that separates high-level language reasoning from structured, deterministic control pathways, improving execution stability and reproducibility on real devices. Using ClawMobile as a case study, we distill the design principles for mobile LLM runtimes and identify key challenges in efficiency, adaptability, and stability. We argue that building robust smartphone-native agentic systems demands principled coordination between probabilistic planning and deterministic system interfaces. The implementation is open-sourced~\footnote{https://github.com/ClawMobile/ClawMobile} to facilitate future exploration.

• The paper presents a novel smartphone-native runtime prioritizing explicit reasoning-control separation and modular backend coordination.
• It leverages deterministic system APIs, semantic UI agents, and direct UI actions to ensure verifiable execution and improved task reliability.
• Empirical results demonstrate 100% task completion across real-world scenarios, highlighting robust performance despite latency trade-offs.

ClawMobile: Hierarchical Architectures for Robust Smartphone-Native Agentic Systems

Motivation and Problem Context

The proliferation of LLM-driven agents in desktop and cloud contexts has highlighted significant architectural and operational challenges when adapting agentic autonomy to smartphones. Mobile devices present non-trivial constraints: resource limitations, fragmented control surfaces, volatile application states, and unpredictable runtime interruptions. Traditional UI-centric agent architectures—primarily relying on probabilistic, LLM-powered GUI automation—are insufficient for robust, reproducible mobile autonomy, as evidenced by frequent execution failures in real-world deployments. ClawMobile rethinks agent runtime design for smartphones, prioritizing explicit reasoning-control separation, heterogeneous backend coordination, and iterative, verifiable execution loops (2602.22942).

System Architecture and Design Principles

ClawMobile introduces a smartphone-native runtime, structured around three modular components: Agent Orchestrator, Control Backends, and Memory. The orchestrator interprets user intent and constructs task-level execution plans, delegating actuation to backend controllers. Control Backends encapsulate device-specific action primitives—deterministic system APIs (ADB/Termux), semantic UI agents, and direct UI control actions—each with bounded, machine-readable outcomes. Memory biases backend selection, encodes operational preferences, and supports domain adaptation. Crucially, backend invocation is followed by explicit state verification, closing the intent-action-state loop and preventing silent reasoning errors by LLMs.

Figure 1: ClawMobile architecture with the Agent Orchestrator, Control Backends, and Memory as key components for robust and modular smartphone-native agentic execution.

This modular decomposition enables principled backend selection, runtime extensibility, and explicit execution boundaries, addressing volatility and heterogeneity inherent in mobile platforms.

Control Backends and Execution Modes

ClawMobile differentiates execution modalities to maximize reliability and coverage:

• Deterministic system backends: Leverage stable OS-level commands and hardware APIs for predictable state transitions. Preferred for reproducibility and minimized reasoning overhead.
• Semantic UI agents: Operate over visually-grounded screen representations, allowing flexible interaction across arbitrary apps but at increased uncertainty and token costs.
• Direct UI control actions: Used as fallback mechanisms for heterogeneous or unsupported interfaces, with weaker task-level guarantees.

Backend selection is governed by execution-aware scheduling policies, dynamically escalating from deterministic control to UI-centric reasoning as dictated by runtime constraints and device state. State verification and recovery are embedded in execution loops, mitigating common mobile agent failures (e.g., permission prompts, asynchronous app launches, ambiguous UI targets).

Implementation and Deployment

The ClawMobile prototype integrates OpenClaw as the orchestration substrate, running fully on commodity Android hardware. Control pathways are modular: ADB and Termux API interfaces for deterministic actions; DroidRun as the semantic UI backend for program-level action synthesis. Memory is managed through lightweight retrieval paths and model context embedding. User interaction occurs via Telegram chat channels, abstracting high-level instruction from device-specific execution mechanics.

Empirical Evaluation

ClawMobile’s efficacy was assessed across six representative real-world tasks spanning system configurations, single-app operations, and multi-app workflows. Completion ratio and end-to-end latency were compared against DroidRun and a naive ClawMobile variant (CM-w/o-DR).

• Completion Performance: ClawMobile achieved near-perfect completion ratios across all tasks (100%), significantly outperforming DroidRun in reliability, especially in cross-app scenarios.
• Efficiency Trade-offs: ClawMobile incurred a mean latency overhead (~57.5s slower than DroidRun), attributable to explicit verification steps and iterative recovery loops. However, naive UI-centric agents (CM-w/o-DR) exhibited higher latency and frequent timeouts, failing on complex tasks such as YouTube comment posting or multi-app data transfer.

These results underscore the necessity of hierarchical reasoning-control architectures and explicit execution verification for mobile autonomy.

Challenges and Open Research Directions

ClawMobile’s design and empirical findings surface key system-level questions:

Efficiency

Resource constraints—computation, bandwidth, and token budgets—mandate incremental context representation, delta-based state serialization, and hybrid deterministic-probabilistic scheduling strategies. Optimizing model placement (on-device vs. remote inference) [flexinfer] and reasoning depth under tight resource envelopes remains an active challenge.

Adaptability

Structuring agent behaviors via skill abstractions and hierarchical memory promotes reuse, domain specialization, and long-term coherence. Automated skill extraction and compositional workflows across heterogeneous app ecosystems are critical for generalizing agentic autonomy.

Stability

Reliability and fault tolerance require explicit progress verification, bounded execution scopes, and principled recovery mechanisms. Privacy and security considerations—especially in hybrid inference contexts and sensitive application domains—demand formal runtime policy design for state export, logging, and user control.

Implications and Future Directions

ClawMobile reframes the engineering of smartphone-native agents as a runtime systems problem, calling for holistic co-design of reasoning, control, memory, and reliability across modular pathways. The architecture demonstrates that robust mobile autonomy demands more than improved LLM reasoning or UI automation—principled coordination among multiple execution paradigms, explicit state verification, and modular extensibility are required.

Practically, this enables deployable autonomy for smartphones, advancing beyond brittle, UI-centric automation toward reliable, adaptable, and privacy-preserving mobile agentic systems. Theoretically, ClawMobile’s runtime approach suggests new lines of inquiry in agent scheduling, skill abstraction, context management, and verification, relevant across broader distributed agentic computing domains.

Conclusion

ClawMobile articulates a hierarchical runtime perspective for smartphone-native agentic systems, separating high-level language reasoning from structured device control and memory management. Empirical evidence demonstrates improved reliability and coverage vis-à-vis UI-centric baselines, motivating future research around modular backend scheduling, efficient state representation, and runtime stability. This architectural paradigm lays a foundation for principled, scalable, and robust mobile LLM autonomy, moving beyond UI-only frameworks to integrated systems-level agentic solutions.