MATE: Mobile Agent Trustworthy Execution for Safe and Efficient Mobile Control

Minsuk Jang, Hee-Seon Kim, Hui-Cheol Yu, Changick KimarXiv 2026 · arXiv

This paper introduces MATE (Mobile Agent Trustworthy Execution), a system designed to make LLM-powered mobile agents safer, faster, and less intrusive. Rather than trying to "fix" the underlying language model, MATE acts as an intelligent execution layer that intercepts agent proposals before they hit the operating system, ensuring that high-risk actions are vetted and routine tasks are optimized.

TL;DR

MATE is a "runtime firewall" and optimizer for mobile agents that blocks 97% of high-risk actions and reduces LLM costs by up to 6x. It achieves this through a combination of semantic guardrails, deterministic task routing for recurring routines, and a non-disruptive floating UI.

What Problem Does This Paper Address?

Large Language Model (LLM) agents can now navigate mobile apps by "seeing" the screen and "clicking" buttons. However, deploying them on personal devices presents three major hurdles:

  1. Safety Risks: A single hallucination or "jailbreak" could lead to an agent sending $10,000 to a stranger or deleting a database.
  2. Resource Costs: Calling a frontier LLM (like GPT-4o) for every single tap and swipe is slow and expensive.
  3. UX Disruption: Most agents hijack the foreground, making the phone unusable while the agent "works."

Existing safety frameworks often focus on text-based outputs, but on a phone, the same "tap" can be benign in a calculator and catastrophic in a banking app. MATE addresses this by focusing on the action-execution boundary.

Figure 1: MATE makes mobile agent execution safe without replacing the underlying model. Sensitive actions are sent for user approval, harmful actions are blocked, and safe actions proceed across apps and task types.

Methods

MATE introduces three core components that sit between the agent's brain (the LLM) and the phone's OS:

  • Runtime Guardrail (RG): This is the safety engine. It converts every proposed UI action into a structured record (instruction, app, screen context, etc.) and runs it through six "rails." These rails check for things like prohibited topics, restricted apps, or financial intent. RG can Allow the action, Deny it (block), or route it for User Approval (e.g., "I've filled the cart; please tap 'Buy' to confirm").
  • Predefined Task Routing (PTR): For recurring tasks (like "search for coffee on Amazon"), MATE skips the expensive LLM reasoning. It uses a library of verified, deterministic routes discovered during a one-time "setup" exploration of the app. If a user's request matches a known route, MATE executes it instantly without per-step LLM calls.
  • Floating Execution Interface: Instead of taking over the whole screen, MATE runs the agent in a compact, transparent overlay. This allows the user to continue watching a video or browsing the web while the agent performs a background task.
Figure 3: Mobile deployment demands cost efficiency, safety, and screen-surface control simultaneously, addressed by MATE through route reuse, pre-execution checks, and bounded surfaces.

Datasets

The authors evaluated MATE using:

  • MobileSafetyBench: A benchmark of 156 high-risk mobile tasks covering ethical compliance, offensiveness, private information, bias, and robustness to prompt injection.
  • AndroidWorld: A standard benchmark for general mobile task completion and efficiency.
  • MobileRisk: Used for head-to-head comparison with other safety frameworks like OS-Sentinel.

Key Insights and Ideas

  • The Action is the Unit of Control: Text-stage guardrails are insufficient for mobile. Safety must be enforced at the UI primitive level (tap, type, swipe) where the actual device effects are realized.
  • Mobile UIs are "Low-Entropy": Unlike the open web, mobile apps have very stable, repeatable navigation paths. This makes simple (app, instruction) keys surprisingly effective for caching and replaying routes (PTR), drastically reducing the need for "reasoning" during routine use.
  • The "Safety Gap" is Real: The authors found that standard mobile agents (like AppAgent or AutoDroid) leave the vast majority of high-risk tasks unblocked. MATE specifically targets this gap.
Figure 2: MATE closes the safety gap that existing mobile agents leave open. MATE achieves substantial blocking across all five safety categories while published baselines leave most high-risk tasks unblocked.

Key Results

  • Safety: On MobileSafetyBench, MATE increased the blocking of high-risk actions from 29.7% to 97.0% when using GPT-4o.
  • Efficiency: For recurring tasks, PTR reduced the number of LLM calls by 6x and cut end-to-end latency by over 3x.
  • Success Rate: By using verified routes, MATE raised the success rate for recurring tasks to 95.7% on AndroidWorld, as it avoids the "drift" and errors common in step-by-step LLM reasoning.
  • UX: Qualitative analysis showed that the floating interface successfully allows multitasking, such as shopping in the overlay while watching a video in the background.
Figure 4: A routine shopping task shows MATE’s execution layer. PTR skips repeated navigation steps, the floating interface contains execution to an overlay, and RG routes the purchase confirmation to user approval.

Limitations and Future Work

  • UI Drift: PTR relies on stored routes. If an app undergoes a major redesign, those routes may break, requiring the system to fall back to the slower LLM-based reasoning or re-explore the app.
  • Cross-App Complexity: The current implementation of PTR focuses on single-app routines. Extending this to complex, multi-app workflows is a noted area for future research.
  • Approval Fatigue: While routing sensitive actions to the user is safe, frequent approval requests could lead to user fatigue. Tuning the "semantic thresholds" for what requires approval vs. what is blocked is an ongoing challenge.

Summary updated

Abstract

Mobile agents on personal smartphones can affect private data, payments, settings, and the foreground screen. We present MATE (Mobile Agent Trustworthy Execution), an execution-layer system that controls the boundary between agent action proposals and device effects without modifying the underlying model. MATE represents each UI primitive as a structured action record that combines the instruction, target app, screen context, primitive, and action fields. Runtime Guardrail (RG) maps this record to an allow, block, or user-approval decision; Predefined Task Routing (PTR) serves recurring requests through verified routes with post-execution screen checks; and a floating interface keeps execution in a compact overlay. On MobileSafetyBench, MATE raises high-risk blocking from 29.7% to 97.0% under GPT-4o. On AndroidWorld, it reduces LLM calls by up to 6x and raises recurring-use task success to 95.7%.
BibTeX
@misc{jang2026mate,
  author = {Minsuk Jang and Hee-Seon Kim and Hui-Cheol Yu and Changick Kim},
  title = {{MATE: Mobile Agent Trustworthy Execution for Safe and Efficient Mobile Control}},
  year = {2026},
  eprint = {2611.25526},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.25526},
}
Figure