2026-05-13 20:03 UTCIn-site rewrite6 min readUpdated: 2026-06-30 13:03 UTC

Local Android Emulation in an AI Agent

Devin now supports local Android emulation, enabling it to build, test, and debug Android apps directly. It integrates via declarative configuration, supports ADB and computer vision interactions, and offers end-to-end testing, UI verification, crash debugging, and multi-configuration testing.

SourceHacker News AIAuthor: Alextigtig

Android emulator support - Devin Docs

Devin Docs home page

Enterprise

Use Cases

API Reference

Release Notes

Introducing Devin

Your First Session

Tutorial Library

When to Use Devin

Instructing Devin Effectively

Good vs. Bad Instructions

Prompt Templates Cheat Sheet

How does Devin fit into my existing SDLC?

Declarative configuration

Android emulator support

Classic configuration

Index a Repository

VPN Configuration

Knowledge Onboarding

AGENTS.md

Devin Review

Devin Session Tools

Computer Use

Testing & Video Recordings

Slash Commands

Ask Devin

Data Analyst Agent

DeepWiki

MCP (Model Context Protocol) Marketplace

DeepWiki MCP

Devin MCP

Devin for Terminal (Devin CLI)

Advanced Capabilities

Knowledge

Skills

Session Insights

Secrets & Site Cookies

Creating Playbooks

Using Playbooks

Scheduled Sessions

Deployments

Autofix Settings - Bot Comments

Invite your Team

Importing Code Settings

Integrations Overview

Slack

Microsoft Teams

GitHub

GitLab

Bitbucket

Linear

Jira

GitHub Pull Request Templates

Self-Hosted SCM & Artifacts

Security at Cognition

Common Issues

Documentation Index

Fetch the complete documentation index at: https://docs.devin.ai/llms.txt

Use this file to discover all available pages before exploring further.

Devin can build and run Android applications directly on its own machine — giving it the Android equivalent of Computer Use and browser interaction. Devin can open the app, inspect behavior, reproduce issues, and verify changes in the environment where the application actually runs. Combined with video recordings, Devin can send you a recording as proof.

Android emulator support is currently available on a limited basis. If you’re interested in using it with Devin, please contact us to learn more and get access.

What You Can Do

With Android emulator support enabled, Devin can handle the full mobile development loop:

Build & smoke-test PRs

Devin builds and runs your app on the emulator, then clicks through critical flows after each PR. You get a video recording that proves the feature works — watch it and merge.

End-to-end mobile testing

Test complete user flows — login, navigation, form submission, checkout — on a real Android stack, not a mock. Devin follows the flow step-by-step and flags anything that breaks.

UI verification

Verify layouts, themes, and responsiveness across screen sizes and API levels. Devin takes screenshots at key points and flags visual issues like overlapping elements or clipped text.

Debug crashes & ANRs

Reproduce issues on the emulator, capture logcat output, inspect behavior, trace the root cause, and push a fix — all in one session.

Cross-platform validation

Building with React Native, Flutter, or Kotlin Multiplatform? Devin can test the Android side alongside your web or desktop builds in the same session.

Instrumented test execution

Run Espresso or UI Automator test suites on the emulator and get results reported back, without needing a separate CI device farm or physical devices.

Multi-config testing

Verify your app across different API levels or device profiles by configuring multiple AVDs. Useful for catching compatibility issues before they reach users.

How It Works

Android emulator support is built on the same declarative configuration system as the rest of Devin’s environment. You add the Android SDK and emulator to your blueprint, and Devin’s snapshot builds a VM with everything pre-installed. Every session boots from that snapshot with the emulator ready to go. During a session, Devin interacts with the emulator in two ways:

MethodWhat it doesWhen to use it

adb (command line)Install APKs, run tests, capture logs, take screenshotsAutomated builds, instrumented tests, logcat debugging

Computer Use (desktop)Tap, swipe, type, and navigate the emulator’s screen visuallyEnd-to-end UI testing, visual verification, video recordings

The emulator window runs on Devin’s desktop, so you can watch Devin interact with your app in real time via the Desktop tab in the webapp.

Setting Up the Emulator

Let Devin do it (recommended)

Manual blueprint setup

The easiest way to get started. Devin analyzes your Android project, installs the right SDK components, and configures the emulator for you.

Start a Devin session

Open a new session and ask Devin to set up Android emulation. For example: “Set up an Android emulator for this repo.”

Review and approve

Devin proposes a blueprint with the Android SDK, build tools, and emulator configuration. Review the suggestion cards in your timeline and click Approve.

Verify

Once the build completes, start a new session. Ask Devin to build and run your app on the emulator to confirm everything works.

If you know exactly what SDK components and emulator configuration you need, you can write the blueprint yourself.

Navigate to environment configuration

Go to Settings > Environment > Blueprints and select your Android repository.

Write your blueprint

Add the Android SDK, platform tools, emulator, and a system image to initialize. Add your dependency install to maintenance. See the blueprint examples below for copy-paste templates.

Save and build

Click Save. A build starts automatically (typically 5–15 minutes for Android due to SDK downloads). Monitor progress from Settings > Environment > Snapshots.

Verify

Once the build shows Success, start a new session. Ask Devin to launch the emulator and build your app to verify.

What gets installed

A typical Android emulator support blueprint installs:

ComponentPurpose

Android SDK command-line toolsCore SDK management (sdkmanager)

Platform toolsadb, fastboot for device communication

Build toolsaapt2, d8, zipalign for building APKs

Android platform (e.g., API 34)Target API level for your app

Emulator + system imageThe virtual device itself

Use an x86_64 system image for best performance inside Devin’s environment. ARM images work but are significantly slower under emulation.

Using the Emulator

On-demand testing

Ask Devin to build and run your app at any point during a session — no special syntax needed, just natural language:

“Build and run the app on the Android emulator”

“Test the login flow on the emulator and send me a recording”

“Open the settings screen on the emulator and verify the new toggle appears”

“Run the Espresso tests on the emulator and show me the results”

Devin will launch the emulator (if it isn’t already running), build and run your app, and interact with it — using adb for programmatic actions and Computer Use for visual interactions.

Integration with Testing & Recordings

Android emulator support plugs directly into Devin’s Testing & Recordings workflow. After creating a PR:

Devin offers to Test the app — click the button or ask directly

Devin builds and runs the app on the emulator and executes a focused test plan

The emulator screen is captured in a video recording with annotations

The recording is sent to you so you can watch the test and merge with confidence

This works the same way as web app testing — the only difference is that Devin interacts with the emulator window instead of Chrome.

Create a Skill that tells Devin exactly how to build, launch, and test your Android app. This saves setup time on repeat sessions and ensures consistent testing. For example, include the Gradle build command, which activity to launch, and which flows to verify.

Skill suggestions

After testing your Android app, Devin writes down what it learned — how to start the emulator, which Gradle tasks to run, how to navigate to the feature under test — and proposes creating or updating a Skill via PR. You can merge the PR as-is or tweak it to refine the instructions. Over time, this means Devin gets better at testing your Android project. Each session’s learnings build on the last — so the second time Devin tests your app, it already knows how to build it, which activity to launch, and which flows matter most. You can also prompt Devin to do this at any time (e.g., “create a skill for how to build and test this Android app”). See the Skills guide for full details.

Interacting via the desktop

The Android emulator runs as a window on Devin’s Linux desktop. This means:

Devin can interact with it via Computer Use — tapping buttons, swiping, typing text, navigating between screens

You can watch live via the Desktop tab in the Devin webapp

Recordings capture the emulator screen alongside anything else visible on Devin’s desktop

For details on how desktop interaction works, see Computer Use.

Using adb

Devin can also interact with the emulator programmatically via adb, which is useful for:

Installing APKs — adb install app-debug.apk

Running instrumented tests — adb shell am instrument -w com.example.test/androidx.test.runner.AndroidJUnitRunner

Capturing logs — adb logcat to debug crashes or unexpected behavior

Taking screenshots — adb exec-out screencap -p > screenshot.png

Simulating user input — adb shell input tap 500 800 for scripted interactions

Devin chooses between adb and Computer Use depending on the task — adb for speed and automation, Computer Use for visual verification and complex UI flows.

Blueprint Examples

Copy-paste blueprints for common Android setups. Each template is self-contained — paste it into your blueprint editor and save.

Native Android (Kotlin/Java + Gradle)

initialize:

name: "Install Android SDK"

run: | export ANDROID_HOME="$HOME/android-sdk" mkdir -p "$ANDROID_HOME/cmdline-tools" cd "$ANDROID_HOME/cmdline-tools" curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o tools.zip unzip -q tools.zip -d latest-tmp mv latest-tmp/cmdline-tools "$ANDROID_HOME/cmdline-tools/latest" rm -rf tools.zip latest-tmp echo "export ANDROID_HOME=$ANDROID_HOME" >> ~/.bashrc echo 'export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH' >> ~/.bashrc export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" yes | sdkmanager --licenses > /dev/null 2>&1 sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" "emulator" "system-images;android-34;google_apis;x86_64" echo "no" | avdmanager create avd -n devin -k "system-images;android-34;google_apis;x86_64" --device "pixel_6"

maintenance: | ./gradlew assembleDebug

knowledge:

name: build

contents: ./gradlew assembleDebug

name: test

contents: ./gradlew test

name: lint

contents: ./gradlew lint

name: emulator

contents: | Start the emulator: emulator -avd devin -no-window -no-audio -gpu swiftshader_indirect & Wait for boot: adb wait-for-device && adb shell getprop sys.boot_completed Install APK: adb install app/build/outputs/apk/debug/app-debug.apk

React Native

initialize:

name: "Install Node.js"

run: | nvm install 20 nvm use 20

name: "Install Android SDK"

maintenance: | npm install cd android &&

[truncated for AI cost control]