Your OpenClaw agent can read your email, search the web, manage your calendar, and run cron jobs at 3 AM. All of that lives on the VPS.

But the VPS is blind. It has no idea where you are, what's happening in the physical world, or what the thing in your pocket is observing right now.

That changes when you pair your phone.

What node mode actually is

When you install the OpenClaw app on an Android phone or iPhone and pair it with your gateway, that device becomes a node — a peripheral with its own command surface that your agent can invoke remotely.

The architecture is simple: your gateway (VPS) stays the brain. The phone is the hands and eyes. The agent running on your server can send commands to any paired node, get results back, and act on them — all without you touching the device.

Pair once. From that point, any workflow can reach the phone.

What's available on a paired device

Here's the full module breakdown for v2026.3.1:

Camera

camera.list — enumerate cameras on device
camera.snap — capture from front, back, or both
camera.clip — record a video clip (with or without audio)

Location

location.get — GPS coordinates, altitude, speed, heading, source (gps | wifi | cell), accuracy in meters
Three accuracy modes: coarse (WiFi/cell), balanced (mixed), precise (full GPS)

Motion sensors

motion.activity — detects activity type: walking, running, stationary, in-vehicle, tilting
motion.pedometer — step count and movement data

Photos

photos.latest — pull recent photos from the device gallery

Contacts

contacts.search — query device contacts by name, phone, email
contacts.add — add a new contact

Calendar

calendar.events — read upcoming events (uses device's default calendar)
calendar.add — create a new event

Notifications

notifications.actions — open, dismiss, or reply to system notifications
system.notify — send a notification to the device

Device health

device.health — battery level, storage, network status

System

system.run — execute commands on the node (with approval allowlist)
device.permissions — check and manage app permissions

Three use cases worth building

1. Field verification — proof of presence, timestamped

The pattern: your agent needs to confirm someone was somewhere and did something.

The phone delivers: GPS coordinates, timestamped photo from device camera, calendar entry created automatically. Chain these together and you get a complete audit trail — timestamped coordinates, photo proof, calendar record — without any manual entry.

Relevant modules: location.get, camera.snap, calendar.add

A concrete version of this: a field tech arrives at a job site, the agent captures location and photo, logs the visit to calendar, sends the client a confirmation. The tech doesn't type anything. The agent assembles the record from hardware signals.

2. Motion-triggered automation

motion.activity returns one of six states: walking, running, stationary, in-vehicle, tilting, unknown.

That state is queryable from any workflow. The interesting part is what you can gate on it.

Example: you have a cron job that checks email and sends summaries. You might want it to skip that when you're driving. A quick check against motion.activity returns in-vehicle — job pauses, no distraction. When it returns stationary, the summary comes through.

Less dramatic version: trigger briefings when you start walking (commute mode), stop them when you reach the office. Use step count as a rough proxy for whether someone is on-site or not.

This is the kind of context that makes an agent feel aware instead of mechanical.

3. Photo capture to pipeline

camera.snap fires the camera. photos.latest pulls recent images. Both return media attachments the agent can immediately analyze, label, store, or forward.

A working version: an agent polls a tablet mounted in a warehouse every 30 minutes. It snaps a photo, compares it against an expected shelf layout via a vision model, and alerts on anomalies — without anyone actively monitoring.

The agent runs on the VPS. The camera hardware is on the tablet. The node is the bridge.

iOS vs Android

Both platforms are supported. The difference is how background behavior works.

Android nodes generally stay connected while the app is in the background. iOS has stricter backgrounding rules — to handle this, OpenClaw uses APNs (Apple Push Notification service) to wake a backgrounded iOS node before invoking commands. If the app is backgrounded when your agent fires a camera.snap, the gateway sends a wake signal first, waits for reconnect, then sends the command.

In practice: iOS nodes work fine, but they need APNs configured and the app needs push notification permission. If nodes.invoke is timing out on an iPhone, that's usually the first thing to check.

How to set it up

No server access needed. The whole pairing flow happens from Telegram:

Install the OpenClaw app on your device (Android: Play Store; iOS: App Store)
In Telegram, message your bot: /pair
The bot replies with a setup code — a single string to copy
In the OpenClaw app, go to Settings → Gateway, paste the setup code, and connect
Back in Telegram: /pair approve

That's it. Your device is now a paired node. Any agent or cron job in your workspace can invoke commands on it from that point on.

The setup code is short-lived (treat it like a one-time password). If it expires before you use it, just run /pair again to generate a fresh one.

The gap between "cloud agent" and "physical world" is smaller than it looks. A paired phone is GPS, camera, motion sensor, notification hub, and calendar in one — all accessible from the same agent that reads your email and manages your schedule.

That's the part that changes what's possible.

Try MoltBot Ninja