Skip to content

Releases

v0.3.1

Choose a tag to compare

@github-actions github-actions released this 24 Oct 13:18

Droid 0.3.1

Your phone. Any agent.

Experimental. arm64-v8a only. Fixes to talking to Droid over WhatsApp, iMessage and Telegram through Photon.


Update

Download asterdroid-0.3.1.apk from the assets below and open it on the phone, or:

adb install -r asterdroid-0.3.1.apk

It installs over 0.3.0 and keeps your settings, keys, sessions and memory.

Fixes

  • Approvals show the whole request. Asking for a go-ahead over Photon no longer cuts the preview at 1,500 characters. A long one arrives over several messages with its indentation intact, and "Reply yes, always, or no." comes last, on its own. Droid only takes your answer once every part has arrived, so you never approve something you have not seen.
  • One turn per chat. Two messages, or a message and a reminder, arriving together could start two turns in the same chat, each with its own agent. A chat now runs one turn at a time, and later messages join it or wait their turn.

v0.3.0

Choose a tag to compare

@Zfinix Zfinix released this 24 Oct 09:41

Droid 0.3.0

Your phone. Any agent.

Experimental. arm64-v8a only. Aster Droid is now Droid. It no longer needs a Telegram bot or a paid key to start: a new phone is walked through a model and a place to talk, and the chat lives in the app. Any agent on your computer can drive the phone over MCP, and editors can talk to the agent on it over ACP.


Update

Download asterdroid-0.3.0.apk from the assets below and open it on the phone, or:

adb install -r asterdroid-0.3.0.apk

It installs over 0.2.0 and keeps your settings, keys, sessions and memory. A phone that already has a key or a bot token skips onboarding and keeps talking where it did. The app is now called Droid on the home screen; the package is still dev.aster.probe.

Start with no key

  • Onboarding. A new phone goes through four steps, one at a time: a model, where to talk to it, the permissions, done. It comes back to the same step if Android restarts the app halfway, and Settings can run it again.
  • Try it free. Free models through Kilo Gateway, with no account and no key. Droid picks the best free model that can see images and use tools. The free tier allows about 200 requests an hour, around 10 tasks. Those requests run on a trial service that keeps logs, so the app says to keep them away from banking, health and other private screens.
  • Your computer's model. Droid looks for Ollama and LM Studio on the same Wi-Fi, lists their models, and uses the one you tap. If it finds none, it shows the command that makes each listen on the network.
  • Sign in or use a key. OpenRouter signs in and hands back a key with nothing to copy. Any other provider, or any OpenAI-compatible address, takes a pasted key, which is tried before it is saved.

Talk to it anywhere

  • Chat in the app. The default once no bot token is set. Tool calls, plans and questions show as cards, and the agent can ask you to pick an answer. Replies arrive as notifications when the app is closed.
  • Telegram, as before, now optional.
  • WhatsApp and iMessage through Photon. One Photon project bridges both. Set Allowed people to the numbers that may ask.

Setup links

A setup link or QR code from droid.withaster.dev carries a whole setup: the model, its key and the chat app. The settings ride in the part of the link a browser never sends to a server. Droid opens it straight from the camera, shows every change it would make, with keys cut to their last four characters, and writes nothing until you say yes. A link expires after 15 minutes and works once. A link that names a model address Droid does not know, or a relay of its own, says so in red or amber before you apply it.

Connect a computer

Connect a computer in Settings turns each way in on and off:

  • Agents (MCP). Claude Code, Codex, Cursor and other agents use the phone's screen, with the same receipts the built-in agent gets.
  • Editors (ACP). Zed and JetBrains chat with the agent on the phone.
  • Over Wi-Fi. Off by default, so both listen only on the phone and a USB cable reaches them through adb. On, they listen on the Wi-Fi address only, not on mobile data.

Each has its own 64-character key, made when you turn it on. The screen writes out the snippet for Claude Code, Codex, Cursor and Zed, with Copy carrying the whole key.

The @withaster/droid CLI

npx @withaster/droid pair --adb               # phone on a USB cable
npx @withaster/droid pair --lan 192.168.1.20  # phone on this Wi-Fi or Tailscale
npx @withaster/droid setup all                # claude, codex, cursor, zed, jetbrains, vscode

pair checks each key against the phone before it saves it, in ~/.config/aster-droid/credentials.json (0600). A bare pair uses adb when it sees exactly one phone, and otherwise says how to pair over Wi-Fi or USB. setup adds Droid to each client's config and never rewrites a file with comments in it. aster-droid mcp and aster-droid acp are the stdio bridges the clients launch, so the key stays out of their config files.

Aster Relay is coming soon

Aster Relay will reach the phone from anywhere with one code, with no open port, adb or Tailscale. It is not open yet, so Reach from anywhere shows as coming soon and cannot be turned on, and a setup link cannot turn it on either. A relay you host yourself works now: set ASTER_RELAY_URL to its address and the switch comes back. docs/RELAY.md has the steps.

Privacy

  • Droid opts out of Android backup and device transfer, so .env with its keys never lands in a cloud backup or on another phone.
  • Plain http is allowed only to addresses on your own network. A key is never sent to the internet without TLS.
  • MCP and ACP keys are marked sensitive when copied, so Android 13 and later hide them in the clipboard preview.

Known limits

  • The in-app chat, Photon bridge and setup links are new in this release. Report a setup link that is refused when it should not be, or a chat reply that never arrives.
  • Free models are rate-limited by the gateway, and a long task can run out of requests partway. Pick your computer's model or a key for heavy use.
  • Over Tailscale, set Other agents' and Editors' address in settings to the phone's Tailscale address; Over Wi-Fi binds the Wi-Fi address only.
  • Everything listed under 0.1.0 still applies: text input into views without an input connection, PIN and pattern locks, no start after reboot, arm64-v8a only.

v0.2.0

Choose a tag to compare

@github-actions github-actions released this 17 Sep 00:58

Aster Droid 0.2.0

Fewer round trips, shorter waits, and a phone that speaks up on its own.

Experimental. arm64-v8a only. Most of the time a phone task takes is the model thinking between steps, not the phone. This release cuts the number of steps and the time spent waiting between them.


Update

Download asterdroid-0.2.0.apk from the assets below and open it on the phone, or:

adb install -r asterdroid-0.2.0.apk

It installs over 0.1.0 and keeps your settings, keys, sessions and memory. Open the app afterwards and press start if the agent is not running, so it picks up the new instructions.

Fewer model round trips

  • Tap by text. tap Wi-Fi reads the screen as the tap runs and taps the element that says it. An exact match wins over a partial one. If the text is on several elements, the reply lists them and asks for an index instead of guessing.
  • Several steps in one call. do tap Network & internet; tap Internet; tap Wi-Fi runs the steps on the phone, prints one line per step and ends with the final screen. It stops at the first step that errors or changes nothing, and says which steps it did not run. The agent is told to send a known route this way.
  • Shorter receipts. When a screen changes in place, a receipt lists only the rows that changed, and says the rest keep their numbers. A new screen still comes back as the whole map. A tap that changes nothing no longer resends the map.

Waits that fit the phone

  • Learned per app. The service times how long each app takes to react to a touch and to go still, and sizes both waits from that. Apps with little history use the phone's figures. The first few actions after an update use the old fixed waits, so nothing starts out faster than it can back up.
  • A late answer is never lost. A shorter wait can call a slow app's reaction "no change". If the app then changes the screen, the next command is held instead of run, and the reply shows the real screen with held:. This stops a message or a payment from going through twice. The late timing also lengthens that app's wait.
  • pace prints the current waits for the app in front. pace reset forgets them.
  • wait <text> checks again as soon as the screen moves, instead of every half second.

Faster reads on canvas screens

  • capture on starts the screen capture the mirror uses, with nobody watching. ocr, locate, aim and blind taps then take frames from it instead of rate-limited screenshots. It shows the recording indicator, and stops after 30 idle minutes or with capture off.
  • Without a capture, the service learns how far apart the system allows screenshots and waits that long, instead of being refused and retrying.
  • Actions on blind screens wait until the pixels stop changing, instead of a fixed second and a half.

Alerts in the chat

  • Battery. The phone posts to the chat when it runs low, at 20% and 10% by default, once per level per discharge. Ask the agent to change the levels or turn it off (alerts battery 30,15, alerts battery off).
  • Notifications. Ask the agent to forward an app's notifications (alerts add whatsapp) and they arrive in the chat as they come in. Repeated updates of the same notification are sent once. alerts lists what is on.

Alerts are posted as notices, so they do not start an agent turn.

Settings

  • Settings is a full page instead of a sheet.
  • Every key in the agent's .env is shown, including keys for providers other than the current one, which used to look lost.
  • The whole .env can be edited as text, for names no row covers. Saving restarts the agent.

Consent

The agent's instructions are stricter about two kinds of action. Spending money and reaching another person as you (a message, a call, a post) always stop for a yes, with what it is, what it costs and who it reaches. A yes covers the step it was asked about, not the next one. Everything that stays on the phone still just happens.

Known limits

  • The wait timings, text taps and capture frames are new in this release. Report a held: that should not have happened, or a canvas read that got slower after capture on.
  • A screen with a ticking clock or counter can occasionally hold a command after a tap that really did nothing. It costs one extra step.
  • Everything listed under 0.1.0 still applies: text input into views without an input connection, PIN and pattern locks, no start after reboot, arm64-v8a only.

Aster Droid 0.1.0

Choose a tag to compare

@github-actions github-actions released this 15 Sep 08:55

Aster Droid 0.1.0

Aster runs on an Android phone. The full agent, on the device, driven from Telegram.

Experimental. arm64-v8a only. The fast path is four steps and no compiler: install the APK, create a bot, paste two values, send a message. Everything else here is detail.


1. Install the APK

Download asterdroid-0.1.0.apk from the assets below (or the Releases page) and open it on an Android 8+ phone. Android asks once to allow installs from your browser; allow it.

Open asterdroid and grant what it asks for: accessibility, notification access, Do Not Disturb. The agent needs the accessibility service to read and control the screen, so confirm it is on.

Prefer adb? Connect the phone and run:

adb install -r asterdroid-0.1.0.apk

Building from source instead is covered in the appendix.

2. Connect your bot

The phone runs aster remote telegram as a child of the foreground service. That bridge is the whole interface: you never touch the phone, you message it.

  1. Create a bot with @BotFather: send /newbot, follow the prompts, copy the token.
  2. Get an API key from any provider. Groq has a free tier; a local server needs no key at all.
  3. In asterdroid, tap the settings icon in the top right. Paste the token into Telegram token, pick the provider, paste its key. Save. Saving writes the agent's .env and restarts the agent.
  4. Press start and wait for the notification to say Connected to Telegram.
  5. Send hello to your own bot in Telegram, not to BotFather. With no allowed users configured it replies with your numeric user id.
  6. Paste that id into Allowed ids and save. The bot now ignores every account outside the list.

Then send a real instruction:

Open settings and turn on Do Not Disturb.

The agent reads the screen, performs the action and replies with the result.

From your computer instead. Push a .env rather than typing in the settings sheet:

cat > .env <<'EOF'
ASTER_TELEGRAM_TOKEN=YOUR_BOT_TOKEN
<PROVIDER>_API_KEY=YOUR_PROVIDER_KEY
ASTER_REMOTE_USERS=YOUR_TELEGRAM_USER_ID
EOF
adb push .env /sdcard/Android/data/dev.aster.probe/files/.env

The external files dir is the one place adb can write without run-as. Install.env moves the file inside and deletes the outside copy. Pushed values merge with what the phone already has; keys absent from the pushed file survive. If you do not know your user id yet, steps 4 and 5 above get it.

3. Providers, models, keys

The provider catalog is the same providers.json the CLI and desktop read, synced from the Aster repo at build time. The settings sheet lists it, and model lists come from the selected provider's /models endpoint, so the phone offers what the terminal offers.

Pick provider, model and effort in the app's pickers, or in chat with /model and /effort. Either way the agent restarts to apply it.

Keys are plain environment variables named in the catalog's key_env field for whichever provider you selected. The README's Providers table links every provider's key page. Fast picks:

A local OpenAI-compatible endpoint also works, with no key: point ASTER_BASE_URL at Ollama, LM Studio, vLLM or a llama.cpp server.

4. Modes and commands

The agent starts in yolo mode because a phone has no terminal for approval prompts. It announces outbound actions rather than gating them. Change it per chat with /mode.

/help lists the chat commands: /new, /stop, /retry, /queue, /mirror, /mode, /model, /effort, /status, /sessions, /resume, /memory, /remember, /skills, /learn, /checkins, /cron. /mirror returns a browser URL that shows the phone and accepts input.

5. Push to production

release.sh builds a signed release into dist/. It rebuilds both native binaries, runs the Gradle release task, verifies the signature with apksigner and prints a sha256.

./release.sh apk                  # signed release APK
./release.sh aab                  # signed release App Bundle
./release.sh apk -v 0.2.0 -c 2    # set the version, then build
./release.sh apk -s -i            # reuse jniLibs, install over adb

Signing reads keystore.properties and the key it names, both outside git. ./release.sh check reports the SDK, NDK, build-tools, Aster checkout and signing setup without building anything. Install the artifact the same way as the debug build:

adb install -r dist/asterdroid-<version>.apk

From CI

.github/workflows/release.yml runs the same release.sh on GitHub's runners. It checks out Aster beside this repository, installs the NDK, platform 35 and build-tools, cross-compiles both native binaries, then builds and uploads the signed artifacts. A tag push publishes a GitHub Release, using docs/release-notes/vX.Y.Z.md as the body when that file exists.

git tag v0.1.0
git push origin v0.1.0

Set these repository secrets first:

secret what it is
ANDROID_KEYSTORE_BASE64 base64 -i aster-release.jks
ANDROID_KEYSTORE_PASSWORD storePassword
ANDROID_KEY_ALIAS keyAlias
ANDROID_KEY_PASSWORD keyPassword

The keystore is written on the runner and removed with it, so the key never leaves the secrets store. The native build is cached on target/android-tls and target/android-client, which is what keeps a run under the timeout after the first one.

What shipped

  • The agent, not a client. build-agent.sh cross-compiles aster-cli for aarch64-linux-android and packages it as libaster.so. The process on the phone has the same tools, skills, prompts and review path as the terminal version. Sessions, memory and skills live on the device.
  • Hands and eyes. An accessibility service reads and drives the screen: numbered element maps, swipes, drags, pinches, held touches, typing through ACTION_SET_TEXT or a windowless IME, with OCR, screenshot grids and colour-region targeting where the tree is blind.
  • Receipts. Every action returns a dispatch receipt and the observed screen change. An empty diff returns warning: nothing on screen changed; treat as not done.
  • Screen mirror. /mirror returns a browser URL that shows the phone and accepts input. MediaProjection feeds a hardware encoder directly; the wire format follows scrcpy and the Rust server converts to AVCC for WebCodecs.

Known limits

  • arm64-v8a only.
  • Broad permissions: accessibility, notification access, Do Not Disturb, battery exemption.
  • Starts in yolo mode, since a phone has no terminal for approval prompts. Change it per chat with /mode.
  • type cannot reach a view that handles input without opening an input connection, such as some terminals. Read the field back to verify.
  • A reboot means opening the app once before the agent is reachable again; boot start is declared but not wired yet.

Appendix: build from source

What you need

  • An Android 8+ phone or emulator (minSdk 26) connected through adb.
  • An Aster checkout beside this repository, or ASTER_REPO pointing to one.
  • ANDROID_HOME with build-tools and platform 35, an NDK, and kotlinc.
  • A Rust toolchain that can build std for a custom target, with rust-src installed (rustup component add rust-src).

Build and install

./build-agent.sh     # the agent, into app/src/main/jniLibs/arm64-v8a/libaster.so
./build-client.sh    # asterctl and the mirror, as libclient.so
./gradlew assembleDebug
adb install -r app/build/outputs/apk/debug/app-debug.apk
./grant.sh

The first build is the slow one: it builds std from source and a static libffi for the embedded Python. Both land in jniLibs because nativeLibraryDir is the one place Android executes from.

grant.sh grants runtime permissions, app-op access, notification access, Do Not Disturb access and battery exemptions, enables the accessibility service and selects the keyboard, then reports any denied grants. Check that the accessibility service is on. The agent needs it to read and control the screen.