PowerLens: Taming LLM Agents for Safe and Personalized Mobile Power Management

PowerLens is a safe, personalized mobile power management system for Android that leverages a multi-agent LLM architecture with constraint-based verification and implicit feedback learning to generate context-aware policies, achieving significant energy savings and high accuracy without requiring explicit user configuration.

The Gist

Imagine your smartphone battery is like a wallet full of cash. Every time you use an app, you're spending money.

For years, phone manufacturers have tried to help you save money by acting like a strict, one-size-fits-it-all accountant. They say, "Okay, you're low on cash? Let's just cut everyone's spending by 50%." So, they dim your screen, slow down your processor, and turn off your GPS.

The problem? This accountant doesn't know what you are doing.

• If you are reading a book, dimming the screen is fine.
• But if you are navigating a new city, dimming the screen and turning off GPS is a disaster. You might get lost!
• Also, this accountant doesn't know your personal habits. Maybe you hate reading in the dark, but the phone thinks you do.

Enter PowerLens. Think of PowerLens not as a strict accountant, but as a smart, personal butler who has a PhD in psychology and engineering.

How PowerLens Works (The Butler Analogy)

PowerLens uses a team of AI butlers (called LLM Agents) to manage your phone's energy, but they are "tamed" to be safe and smart. Here is how they operate:

1. The Detective (Activity Agent)

Instead of just looking at the clock, this butler looks at what you are actually doing.

• Old way: "It's 2 PM, let's save power."
• PowerLens way: "Ah, I see you are on Google Maps looking for a coffee shop. You need bright lights and precise GPS. But you don't need Bluetooth right now. Let's keep the lights on but turn off Bluetooth."
• The Magic: It understands the context. It knows that "watching a video" needs a fast screen, but "listening to music in the background" does not.

2. The Learner (Memory System)

This is the butler's notebook.

• The Problem: You never tell your phone, "I prefer 60% brightness when I'm reading." You just manually turn it up when the phone dims it.
• The Solution: PowerLens watches you. If you turn the brightness up after the phone tries to dim it, the butler writes in his notebook: "Ah! User hates dim screens while reading."
• The Result: After a few days (3–5 days), the butler learns your habits perfectly. He stops asking and starts doing exactly what you like, without you ever having to go into settings.

3. The Safety Inspector (PDL Verification)

AI can sometimes be a bit "hallucinatory" (making things up). A smart butler might think, "I'll save battery by turning off the GPS!" while you are driving. That's dangerous.

• The Fix: Before the butler changes anything, a Safety Inspector checks a rulebook. The rulebook says: "If the user is navigating, GPS MUST stay on."
• If the butler suggests a dangerous move, the Inspector says, "Nope, that breaks the rules," and stops it. This ensures the phone never breaks your apps or makes you get lost.

Why is this a big deal?

The researchers tested this on real phones and found:

• It saves a ton of battery: About 39% more battery life than your phone's current "Battery Saver" mode.
• It doesn't annoy you: Unlike the old "Battery Saver" which makes your phone feel slow and dark, PowerLens keeps your experience smooth. You barely notice it working.
• It learns fast: It figures out your personal style in less than a week.
• It's safe: It almost never makes a mistake that would break an app (96.5% fewer safety errors than a raw AI).

The Bottom Line

Think of PowerLens as upgrading your phone's battery management from a blindfolded robot (which just turns everything down randomly) to a mindful, personalized assistant.

It knows when to be frugal (turning off unused radios) and when to be generous (keeping the screen bright for navigation). It learns your secrets (preferences) just by watching you, and it has a safety guard to make sure it never does anything stupid.

In short: More battery, less hassle, and a phone that actually knows you.

Technical Summary

1. Problem Statement

Mobile battery life remains a critical bottleneck for smartphone users. Existing power management solutions suffer from three primary limitations:

• Lack of Semantic Understanding: Traditional OS-level mechanisms (e.g., Android's Adaptive Battery) and hardware governors (DVFS) rely on coarse-grained heuristics or instantaneous load metrics. They fail to understand the context of user activities (e.g., distinguishing between a video call requiring high GPU/CPU and a background sync that can be throttled).
• One-Size-Fits-All Approach: Current systems apply global rules that ignore individual user preferences. For instance, a user who prefers high brightness while reading outdoors is treated the same as a user who prefers dark mode in a dim room.
• Safety Risks in Automation: While Large Language Models (LLMs) offer powerful reasoning capabilities, raw LLM outputs often hallucinate invalid parameter values or propose actions that break critical app functionality (e.g., disabling GPS during navigation).

2. Methodology: The PowerLens System

PowerLens is a system-level power management framework for Android that leverages LLM agents to generate zero-shot, context-aware, and personalized policies. It operates on a rooted Android device and consists of a Multi-Agent Architecture and a Two-Tier Memory System.

A. Multi-Agent Architecture

The system decomposes the power management problem into four specialized agents forming a closed-loop pipeline:

1. Activity Agent ($M_a$):
   • Input: UI tree (via Accessibility API), device state (battery, sensors), and app history.
   • Function: Uses an LLM to infer the user's high-level activity (e.g., "Navigation," "Video Watching") and fine-grained sub-activity (e.g., "Turn-by-turn guidance"). It outputs a compact "context signature."
2. Policy Agent ($M_p$):
   • Input: Context signature, device capabilities, PDL safety constraints, and user preferences from memory.
   • Function: Generates a holistic power policy (a set of actions across 18 device parameters like brightness, refresh rate, CPU governor, GPS mode, etc.). It arbitrates between three memory sources: Session constraints (STM), Context-specific rules (LPM), and General profiles.
3. Execution Agent ($M_e$):
   • Function: Acts as a safety gatekeeper. It performs two LLM calls:
     • Verification: Checks proposed actions against device capability profiles and Propositional Dynamic Logic (PDL) safety constraints to prevent hallucinations or critical failures.
     • Command Generation: Translates approved actions into executable root shell commands (e.g., settings put system screen_brightness).
4. Feedback Agent ($M_f$):
   • Function: A deterministic agent that performs state differencing. It compares the system state before and after a decision cycle. If a parameter changes due to user intervention (manual override), it flags this as a "Strong" feedback signal, locking the setting for the current session and logging it for learning.

B. Two-Tier Memory System

To enable personalization without explicit user configuration, PowerLens employs:

• Short-Term Memory (STM): Volatile, session-scoped storage that holds active constraints (user locks) and raw event logs.
• Long-Term Personal Memory (LPM): Persistent storage containing distilled preference rules.
• The Extractor: An asynchronous process (running during idle/charging) that analyzes STM logs. It uses an LLM to infer user intent from overrides, scores candidates using a decay-reward mechanism (to filter noise and handle preference shifts), and promotes high-confidence rules to the LPM. This allows the system to converge on user preferences within 3–5 days.

C. Safety Verification (PDL)

To ensure safety, PowerLens defines constraints in Propositional Dynamic Logic (PDL). These are hard invariants (e.g., "If App is Navigation, then GPS must be High Accuracy") and contextual constraints. The Execution Agent validates every LLM-generated action against these rules before execution, ensuring that optimization strategies never violate critical functionality.

3. Key Contributions

1. First LLM-Based System-Level Manager: PowerLens is the first system to utilize LLM agents for mobile power management, moving beyond UI automation to direct hardware parameter control.
2. Implicit Preference Learning: Introduces a novel two-tier memory system that learns individualized preferences solely from implicit user overrides (state differencing), achieving convergence in 3–5 days without explicit setup.
3. Safe Execution Framework: Implements a PDL-based constraint verification framework that reduces LLM safety violations by 96.5%, bridging the gap between flexible LLM reasoning and strict system safety.
4. Comprehensive Benchmark: Created PowerLensBench, a benchmark covering 7 app categories, 48 tasks, and diverse user profiles to evaluate energy saving, safety, and personalization.

4. Experimental Results

Evaluated on a rooted OnePlus ACE 5 (Snapdragon 8 Gen 3) with Gemini-2.5-Flash as the backbone:

• Energy Efficiency: PowerLens achieved an average 38.8% energy saving compared to stock Android.
  • Comparison: Outperformed Rule-Based (19.9%) and Android Battery Saver (4.6%).
  • Note: A "Single-Agent LLM" baseline achieved higher raw savings (48.4%) but at the cost of safety and user experience.
• Accuracy & User Experience:
  • Action Accuracy: 81.7% (weighted match against ground truth).
  • User Experience Score (UES): 4.3/5.0.
  • Safety Violation Rate: 0.6% (vs. 12.5% for Single-Agent LLM and 17.0% for raw LLM outputs).
• Personalization: The memory system improved action accuracy by 10.3% and UES by 23% compared to a system without memory.
• Overhead: The system itself consumes only 0.5% of daily battery capacity. The decision pipeline latency is ~12.2 seconds per cycle.
• User Study: In a 14-day study with 10 participants, 90% expressed willingness to continue using the system, with an average satisfaction score of 4.2/5.0. Revert rates dropped from 25.7% to 4.9% as the system learned preferences.

5. Significance

PowerLens demonstrates that LLMs can effectively serve as system-level resource managers when augmented with domain-specific constraints and personalized memory. It solves the "semantic gap" between user intent and low-level hardware parameters, offering a path toward autonomous, context-aware, and safe mobile optimization. The framework's multi-agent decomposition and implicit feedback learning mechanisms provide a generalizable paradigm for other complex system optimization tasks (e.g., thermal management, network scheduling) where safety and personalization are paramount.