CLOUD ANDROID EMULATOR

A real Android emulator in the cloud.

Boot a genuine Android 14 device — adb, Appium, and 223 packages preloaded — inside an isolated sandbox. One command runs your mobile E2E script, records the screen, and hands back a GREEN or RED verdict with an evidence bundle.

Start free — $5 credits See the verdict flow

$5 free credits · no card · android / mobile-test template

one command — mobile E2E to a verdict

$ pilldrops test ./mobile.sh
→ creating sandbox from template android
→ emulator booting … Galaxy S10 · Android 14 (SDK 34)
✓ adb connected · appium :4723 up
→ recording screen · running ./mobile.sh
  PASS  launch app & sign in
  PASS  add item to cart
  PASS  checkout completes
→ evidence: recording.mp4 · 3 screenshots · logcat.txt
✓ VERDICT: GREEN

Android 14

SDK 34

adb + appium

preinstalled

screen recording

automatic

GREEN/RED

verdict + evidence

free credits

[01] — The device / a real Android 14 AVD, not a stub

A real Android 14 device.

The android template boots a Galaxy S10 AVD on Android 14 (SDK 34) with the full test toolchain already installed. You get shell-level adb, an Appium server, and native-resolution capture — no local Android SDK, no emulator on your laptop.

▤

Galaxy S10 · Android 14

A real AVD targeting Android 14 (SDK 34) at native device resolution — the same surface your users touch, running headless in the cloud.

⬢

adb + Appium + 223 packages

Shell-level adb, an Appium server on :4723, and 223 packages ready on boot. Drive it from your existing Appium or espresso scripts.

◉

Automatic screen recording

Every run is recorded to recording.mp4 without a flag — so a failed step comes with the video that shows exactly what the agent saw.

◧

Native-resolution screenshots

Pixel-accurate screenshots at the device's real resolution, captured on each assertion and bundled with the verdict as evidence.

[02] — The verdict / one command, GREEN or RED

One command, a GREEN/RED verdict.

pilldrops test ./mobile.sh creates the emulator, waits for adb and Appium, records the screen, runs your script, and returns a single verdict plus an evidence bundle — recording, screenshots, and logcat. Perfect for an agent that needs a machine-readable pass/fail, or for CI.

from the SDK — spin the android emulator directly

from pilldrops import Sandbox

with Sandbox.create(template="android") as sb:   # or "mobile-test"
    sb.run("adb wait-for-device").check()
    sb.upload("./app-release.apk", "/app.apk")
    sb.run("adb install /app.apk").check()
    r = sb.run("python /tests/checkout_flow.py")  # your appium script
    print(r.stdout)                                # PASS checkout completes

import { Sandbox } from '@pilldrops/sdk'

const sb = await Sandbox.create({ template: 'android' })  // or 'mobile-test'
await sb.run("adb wait-for-device")
await sb.upload('./app-release.apk', '/app.apk')
await sb.run("adb install /app.apk")
const r = await sb.run("python /tests/checkout_flow.py")
console.log(r.stdout)                                // PASS checkout completes
await sb.kill()

The test command is the shortcut: it wraps all of that and returns the verdict for you. See how the evidence bundle and GREEN/RED contract work end to end on the testing page →

[03] — Unique to PillDrops / most agent sandboxes stop at Linux

Mobile that most sandboxes just don't have.

Nearly every code-execution sandbox for AI agents ships a Linux box and stops there. PillDrops ships a real Android emulator as a first-class template — so an agent can install an APK, drive the UI, and prove a mobile flow works, all through the same API it already uses for code and browsers.

STEP 01

Create the emulator

Ask for the android template and a genuine Android 14 device boots in a microVM — adb and Appium come up automatically.

$ pilldrops sandbox create --template android

android 14cloud adb

STEP 02

Drive & assert

Install your APK over adb, run your Appium script, and let PillDrops record the screen and capture screenshots on every assertion.

$ pilldrops exec sb_id -- adb install /app.apk

appiumrecording

STEP 03

Get a verdict

Collapse it all into one call: pilldrops test ./mobile.sh returns GREEN or RED with the evidence bundle attached — ideal for agents and CI.

$ pilldrops test ./mobile.sh   # → ✓ VERDICT: GREEN

GREEN/REDevidence

STEP 04

Wire it into an agent

The same flow runs from the SDK, the REST API, or the hosted MCP — so a coding agent can ship and verify a mobile feature on its own.

$ pilldrops logs sb_id -f

SDKMCP

Read the mobile-testing guide →

TEST ON A REAL DEVICE

Ship mobile with a GREEN verdict.

Boot a real Android 14 emulator, drive it with adb and Appium, and get a machine-readable GREEN/RED verdict plus a recording, screenshots, and logs. Try it on $5 of free credits — no card.

Start free See the testing flow