PokeClaw vs FoneClaw: Local AI Phone Agent Comparison

Choose by Fit, Not by a Single Winner

The useful PokeClaw vs FoneClaw verdict is fit-based. Choose PokeClaw when you want an open-source, local-first Android prototype that lets you study how an on-device model can read phone state and choose actions. Choose FoneClaw when you want an independent Android phone-agent runtime focused on governed execution: floating access, deliberate current-screen context, approvals, stopping, recovery, and routed supported actions.

The fresh comparison angle is local model inference versus governed Android execution. Those sound similar, but they are different. Local model inference means the model runs on the phone. Phone-resident execution means the action loop operates on Android surfaces, permissions, tools, app state, and user approvals. A product can be strong in one dimension while still depending on choices or limits in the other.

PokeClaw’s official materials present it as a local-first prototype. That makes it interesting for developers, researchers, and privacy-minded users who want to see a model-driven Android loop in the open. FoneClaw’s role is different. At FoneClaw, we build around the parts of phone work that break in daily use: permission gaps, stale screens, missing confirmations, interrupted tasks, and unclear recovery. We do not reduce the comparison to a feature count because the real question is which product matches the job you need to test.

Compare Model and Data Paths

The clearest PokeClaw advantage is the local model path. The PokeClaw official GitHub repository describes PokeClaw as an open-source local-first Android prototype. In Local mode, it runs Gemma 4 through LiteRT-LM on the phone, and after setup the local path does not require an account or API key. For readers comparing a local AI phone agent, that is the headline: the reasoning loop can stay on the device in that configuration.

The word “local” still needs careful reading. PokeClaw also supports optional cloud providers. Once a user enables a cloud model, the model path changes. That does not make the project less interesting; it simply changes the data-flow question. A fair test records which model route is active, whether prompts leave the device, what account or key is used, and whether the task still works when the cloud route is disabled.

FoneClaw should be evaluated on a different boundary. We describe FoneClaw as an independent Android phone-agent runtime, not as a product where every inference path is guaranteed to stay on-device. According to the latest FoneClaw product information available as of this article update, FoneClaw Download is the current availability path, while FoneClaw Features summarizes current supported capabilities for Android execution. The key product promise is governed action flow on supported Android tasks, not a universal local-inference claim.

For broader trust tradeoffs, AI Agent Trust: Local Android Phone Control vs Cloud Security explains why local and cloud designs need different evidence. This page keeps the comparison practical: name the active model path, then test the action path on the phone.

Compare How Each Agent Observes and Acts

PokeClaw’s official repository describes a phone-resident loop that reads a text representation of the current UI and chooses tools. That architecture is valuable because it makes the agent behavior visible to builders. Instead of treating the phone as a black box, the prototype turns screen state into a format the model can reason over, then uses available tools to act.

The documented PokeClaw tool set includes touch, text, app opening, screen reading, screenshots, messaging, auto-reply, and finish. It also documents skills, guards, QA priorities, limitations, and Apache 2.0 licensing. This is a good shape for experimentation: a developer can inspect the loop, understand where actions are defined, and test whether a specific app workflow survives real Android screens.

FoneClaw’s action loop starts from the user’s phone workflow. The floating assistant gives the user an entry point over other apps. Current-screen attachment is user-triggered, so the user decides when the visible screen becomes part of the task context. From there, FoneClaw routes supported requests to the capability that owns the job, including screen and app context, device state, system controls, navigation, communication, calendar, memo, workflows, skills, plugins, and other supported paths where available.

The reliability implication is straightforward. A generic UI loop can be flexible, but it has to survive ambiguous screens, app updates, unavailable nodes, and consequential-action boundaries. A governed capability route can be more explicit, but it still needs good context entry and clear recovery when Android behavior differs across devices. For FoneClaw’s screen-context workflow, Android Floating AI Assistant: Use Current-Screen Context Safely explains why deliberate screen attachment is part of the control model.

Compare Permissions, Approvals, Stopping, and Recovery

A phone agent comparison becomes serious when actions touch real data. PokeClaw requires Accessibility for screen reading and gestures. Its official materials also discuss rules, guards, stuck detection, clean failures, QA priorities, and limitations. Those are important signals because a local AI phone agent still needs operating-system authority before it can observe and act on Android screens.

Open source helps with inspection, but it does not automatically make a workflow safe. Permissions help an agent act, but they do not automatically mean the user understood the next effect. The critical tests are concrete: does the agent show the target, stop before sending or auto-replying when needed, recover from a wrong screen, and fail cleanly when a tool cannot complete?

At FoneClaw, we build the control boundary into the user flow. Current cumulative product capabilities include approvals, stopping, state checks, permission recovery, and capability routing. For supported Android actions, FoneClaw is designed to keep consequential steps reviewable. If a workflow needs a permission, the assistant can help the user reach the relevant permission path and then continue the task after state changes are checked. If the user stops, the task should stop in a way the user can understand.

Plugin and skill routes need the same discipline. Capability routing helps match a request to an available tool, plugin, skill, or workflow, but routing is not a shortcut around approval. A good PocketClaw alternative is not the product that clicks fastest; it is the one that makes the next phone effect inspectable before it matters. For deeper FoneClaw architecture, FoneClaw Tools, Plugins, Skills, Workflows, and Shortcuts Explained covers how tools, plugins, skills, workflows, and shortcuts fit together.

Compare Installation and Device Cost

PokeClaw’s local-first path has a real hardware cost. The PokeClaw official landing page lists direct APK access and Android 9+ arm64 support. It also says Local mode downloads about 2.6 GB on first launch and needs about 4 GB free RAM. That is a concrete tradeoff: local inference reduces dependence on a cloud model, but the phone has to carry the model and runtime.

The same official site notes that CPU warmup may take about 45 seconds, while supported accelerated hardware can be faster. Treat those numbers as setup expectations, not promises for every handset. Thermal limits, storage speed, available RAM, Android vendor behavior, background apps, and runtime acceleration can all change the experience. A listed chipset or Android version is a starting point, not a performance guarantee.

FoneClaw’s setup question is different. The first question is not whether the phone can run a large local model; it is whether the Android execution path has the permissions and supported capabilities needed for the task. The user should check current availability from FoneClaw’s Download page, inspect current capabilities on the Features page, and start with a reversible workflow before granting broader access.

For readers focused on on-device speed and memory tradeoffs, On-Device LLM Optimization for Phone Agents: Android Speed, Privacy, and Actions goes deeper into why phone agents need more than raw tokens. The short version is that model latency, UI observation, action selection, permission flow, and result verification all affect perceived speed.

Map Each Product to Realistic Workflows

Use task fit before product preference. PokeClaw is a better first test when the workflow is local-model experimentation, open-source inspection, or studying how an Android agent navigates app screens. Its documentation includes WhatsApp auto-reply and generic app navigation examples, which makes it especially relevant for builders who want to inspect messaging automation boundaries.

FoneClaw is a better first test when the workflow is governed utility execution on Android. We see the highest value when the user wants to start from the current screen, ask the assistant to understand the visible context, route the request to a supported capability, review the proposed effect, stop if needed, and recover if permission state blocks the path. This includes device checks, setting-oriented tasks, draft preparation, navigation handoffs, calendar and memo workflows, and other supported actions where the product has a defined route.

The right answer changes by device, account, app version, permission state, and task risk. Avoid judging either product from a single demo. Run the exact workflow you care about, record failures as carefully as successes, and keep first tests reversible.

Choose and Run a Reversible First Test

Choose PokeClaw first if your core question is local inference: can a phone run the model loop locally, observe a visible UI representation, and choose documented tools with acceptable latency on your hardware? Choose FoneClaw first if your core question is governed Android execution: can the assistant begin where you are, attach current-screen context when you choose, route the request to a supported capability, ask for approval, stop cleanly, recover from permissions, and verify the result?

Use one reversible test for both products. Start with a low-risk task such as opening an app, reading visible state, explaining a current screen, checking a supported device setting, or preparing an unsent draft. Avoid sending, purchasing, deleting, booking, account changes, or broad auto-reply workflows as the first comparison.

1. Set the same device condition: battery, network, language, account state, app version, and starting screen.
2. Run the task once without granting unnecessary permissions, and record what the product asks for.
3. Grant only the permission needed for the test, then repeat the same prompt.
4. Use stop or cancel during the task, then check whether the product recovers clearly.
5. Record latency, action visibility, approval wording, final-state verification, recovery path, and repeatability.

A single success proves only that the task worked once. A useful phone agent earns trust by repeating the result, showing the action boundary, and failing cleanly when conditions change. That is the comparison we recommend before choosing a local AI phone agent, an on-device phone agent, or a broader governed Android runtime.