The AI’s own phone

Give your AI its own phone

An AI’s own phone is a spare Android that belongs to your assistant rather than to you: it runs the Aster companion app, keeps its own SIM and number, and sits on a charger so the agent can see what arrives on it and act without being asked first.

It is the same Aster, pointed the other way round. In copilot mode you drive and the AI works your phone for you. Here the phone is the AI’s, the events come to it, and the thing you notice is your own phone ringing — because your assistant decided the gate change was worth a call.

What it takes

Four things, none of them bought for the purpose. The drawer phone most people already own is the whole hardware budget.

  • A spare Android

    Anything running Android 8.0+ (API 26). No root, no custom ROM, no unlocked bootloader — the companion app is sideloaded and asks only for the permissions the tools it exposes actually use.

  • A charger it never leaves

    A phone the AI owns is a phone that is always awake. Leave it plugged in on Wi-Fi, screen off, and let Android keep the companion running in the foreground service it already uses.

  • The Aster server, somewhere always on

    The npm package aster-mcp on Node >= 20 — a laptop that stays open, a mini PC, a home server. The phone holds a WebSocket to it on port 5987; your AI client speaks MCP to the same machine at http://localhost:5988/mcp.

  • A SIM, if you want it to call and text

    Photos, notifications and screen work need no SIM at all. Giving the phone its own number is what lets your assistant call you, text you, and answer for you from an identity that is not yours.

What changes

A phone the AI holds stops being a thing it operates on request and becomes a thing it watches.

  • It sees what arrives

    Texts, app notifications, a ringing call, the phone dropping offline. With event forwarding on, those reach your agent as they happen instead of waiting for you to ask what is new.

  • It can act first

    An event that matters becomes a photo taken, a clip recorded, a reply sent, a call placed to you. Which events matter is your agent’s rule, not a setting buried in Aster.

  • It uses a number that is not yours

    Deliveries, verification codes and the noise you would rather not receive can live on the assistant’s line. Your own phone hears from it only when the assistant decides you should.

One honest limit. When the AI phones you, it speaks through the device loudspeaker and the call microphone picks that up — acoustic coupling, not audio routed into the call stream. It works, and it works best with the phone in a quiet room; quality depends on the handset. Plan for a call that reliably gets your attention, not a hands-free conversation.

What it looks like from your side: a call from the phone your assistant holds, reading out the one thing you needed to know.

Proactive event forwarding

Your phone tells your AI what just happened

A copilot waits to be asked. A phone that belongs to your AI does not have to. Aster can push the things that arrive on the device — a text, a notification, a ringing call, the phone itself going offline — straight to your agent as they happen, so the agent reacts instead of polling.

Forwarding is off until you turn it on. Nothing leaves the phone until you run aster set-event-forwarding and name a destination you control.

  1. Step 1

    The phone

    A text lands, an app posts a notification, or the phone starts ringing. The companion app sees it and sends it up its existing WebSocket.

  2. Step 2

    The Aster server

    Your own machine, not ours. It filters the event against the kinds you enabled, formats it as tagged text, and forwards it.

  3. Step 3

    Your AI

    The agent wakes on the webhook, reads the tags, and decides whether to act, to tell you, or to do nothing at all.

What gets forwarded

Five event kinds, each switchable on its own. Every one arrives as tagged plain text an agent can read without a parser.

Incoming SMS
Tagged [event] sms, carrying the sender and the full message body, the moment the phone receives it. The agent answers from the push instead of polling an inbox.
App notifications
Tagged [event] notification, carrying the app name, its package id, and the notification title and text. This is the one that catches flight delays, delivery updates and the ride that just pulled up — anything an app already tells you about.
Incoming call
Tagged [event] incoming_call, carrying the number and the contact name when the phone can resolve one, while it is still ringing. This is the one event that is on unless you explicitly switch it off: a missing events.incomingCalls key does not drop RINGING events, only an explicit off does.
Device online and offline
Tagged [event] device_online or [event] device_offline when the companion's WebSocket connects or drops. An agent that has to know whether the phone is reachable before it queues work reads these.
New pairing request
Tagged [event] pairing with the status pending_approval when an unknown device asks to join. The payload names the next step — approve it from the dashboard, or with aster devices approve — so nobody quietly joins your server.

Where the events go

Aster POSTs to one destination of your choosing. There is no Aster relay in the middle and no account to create — the server on your machine talks directly to the endpoint you named.

  • An agent webhook

    The OpenClaw-style hook shape, which ClawdBot and MoltBot also speak. Aster POSTs to {endpoint}{webhookPath} — by default http://localhost:18789/hooks/agent — with an Authorization: Bearer token that has to match the token configured on the gateway.

  • A Mattermost incoming webhook

    The same tagged text posted as { "text": "..." }, with no Bearer token. Create the webhook in Mattermost under Integrations, paste the URL into the dashboard, and optionally override the channel it lands in.

Turn it on
$ aster set-event-forwarding

  Channel type      agent webhook
  Endpoint          http://localhost:18789
  Webhook path      /hooks/agent
  Bearer token      ****  (must match the gateway)
  Events            sms, notifications, incoming calls,
                    device online/offline, pairing requests

  Saved to ~/.aster/event-forwarding.json

Or configure it in the dashboard at http://localhost:5989/settings/event-forwarding. The alias aster set-openclaw-callbacks still works.

What your agent receives
{
  "message": "[skill] aster\n[event] incoming_call\n[device_id] …\n[model] …\n[data-number] +15551212\n[data-contact] Jane",
  "wakeMode": "now",
  "deliver": true,
  "channel": "whatsapp",
  "to": "+15550001111"
}

Every event is one tagged text block. An agent that can read a line can route it — no schema, no SDK.

What people build with it

Each of these is a forwarded event plus one or two tool calls. The tool names are the callable ones, exactly as an MCP client lists them.

  • Record a clip when someone is at the door

    Leave the phone facing the entrance. When your doorbell or intercom app posts a notification, that event reaches the agent, which records a few seconds of video and texts it to you. The trigger is the notification the other app already posts, not motion detection — if that app stays silent, so does this.

    Tools used

    • aster_record_video
    • aster_send_sms
  • Be called when your flight changes

    The airline app posts a gate change or a delay, the agent reads the forwarded notification and phones you to say it out loud — useful precisely when you are not looking at a screen. Understand how that audio works: Aster speaks through the loudspeaker and the call microphone picks it up, so it is acoustic coupling, not audio routed into the call stream. Keep the phone in a quiet room, expect quality to vary by device, and treat it as a nudge that gets through rather than a hands-free conversation.

    Tools used

    • aster_read_notifications
    • aster_make_call_with_voice
  • Hear your ride arrive from the next room

    The ride-hailing app says the driver is two minutes out. The agent gets the notification, speaks the line aloud on the spare phone and texts you the driver and plate so you are not reading a map on the pavement.

    Tools used

    • aster_read_notifications
    • aster_speak_tts
    • aster_send_sms
  • Look in on a pet while you are out

    Prop the phone where the dog usually sleeps and have the agent take a photo and send it to you. Aster runs no scheduler, so the cadence is your AI client's: a cron job, a scheduled agent run, or a standing instruction in the assistant itself. Aster's side of it is one camera call and one message per run.

    Tools used

    • aster_take_photo
    • aster_send_sms
  • Check the nursery without opening the door

    The same shape as the pet check, and quieter than walking in. A photo goes out on whatever rhythm your agent keeps — again, that clock belongs to the AI client, not to Aster. Point the phone at the cot, not at the room, and remember the photo travels wherever you told the agent to send it.

    Tools used

    • aster_take_photo
    • aster_send_sms
  • Answer for you while you are driving or in a meeting

    An SMS lands, the agent reads it, decides whether it can be answered without you, and replies with something true — that you are driving and will call back — rather than a canned auto-reply. You set the rules for what it may answer and what it must hold for you.

    Tools used

    • aster_read_sms
    • aster_send_sms

Aster ships no scheduler and no rules engine. It exposes 49 tools and pushes these events; deciding when to act, and what counts as worth waking you for, stays with your AI client. See every tool Aster exposes .

Setting one up

How to give your AI its own phone

Five steps, start to finish. The first four are the ordinary Aster install — the fifth is the one that turns a phone your AI can use into a phone your AI watches.

  1. Install the server on a machine that stays on

    Aster's server is an npm package. Put it on whatever is already awake at 3am — a laptop that stays open, a mini PC, a home server — not on the phone. It needs Node >= 20.

    On the always-on machine
    npm install -g aster-mcp
    aster start
  2. Sideload the companion app on the spare phone

    Grab the APK from the releases page and install it on the phone you are dedicating. Anything on Android 8.0+ (API 26) works; no root, no custom ROM. Grant the permissions for the things you actually want it to do — camera, SMS and notification access are each optional.

    Download the companion APK
  3. Point the phone at the server and approve it

    Open the app and enter the server address the terminal printed — the device WebSocket listens on port 5987. The device arrives as pending and stays inert until you approve it, from the dashboard at http://localhost:5989 or with the CLI.

    Approve the device
    aster devices list
    aster devices approve <deviceId>
  4. Leave it on the charger and connect your AI client

    Plug the phone in, screen off, and leave it. Then point Claude Code, Claude Desktop, OpenClaw, MoltBot, ClawdBot or any MCP client at the server's Streamable-HTTP endpoint. That is the copilot half working — your AI can now use the phone.

    MCP client config
    {
      "mcpServers": {
        "aster": {
          "type": "http",
          "url": "http://localhost:5988/mcp"
        }
      }
    }
  5. Turn on event forwarding

    This is the step that makes it the AI's phone rather than a phone it borrows. Choose an agent webhook with a Bearer token, or a Mattermost incoming webhook, pick which events to forward, and the phone starts pushing them the moment they happen.

    Enable proactive events
    aster set-event-forwarding

The full walkthrough — permissions, the device approval gate, pointing an MCP client at the server, and what to do when the device sits on pending — lives on the setup page.