see-think-build
Provides runtime UI mapping and reverse-engineering for Android apps: traverses APKs on Android emulators or devices, captures screenshots and accessibility trees, bridges UI elements to decompiled code, and generates self-contained HTML reports.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
STB — See, Think, Build
Runtime UI maps for Android apps, bridged to static reverse engineering.
STB is a three-phase pipeline that gives coding agents what pure static analysis cannot see: what an app actually looks like when it runs — and which code is behind every button.
APK ──> [SEE] runtime traversal on a headless Android emulator
│ screenshots + accessibility dumps of every reachable screen
▼
[THINK] bridge UI elements to decompiled code (jadx)
│ resource-id / text / content-desc → file evidence
▼
[BUILD] self-contained HTML report: screenshot, element table,
code evidence per elementWhy
Static analyzers (REA, Ghidra, jadx) are blind to runtime UI: they see
MainActivity.java but not that the home screen has a drawer, a search bar, and
a bottom tab bar. GUI agents (AppAgent, ARTEMIS) see the UI but are task-driven —
they complete a mission, not map the app.
STB is the missing piece: exhaustive UI documentation as an artifact, with
every element bridged to the code that implements it. Ground-truth validated
against real app sources (see stb_validate.py).
Related MCP server: apk-preview-mcp
Files
File | Phase | What it does |
| See | Auto-explores an APK on a headless Android emulator (redroid): launches the app, dumps the accessibility tree, taps untried clickable elements, captures a screenshot per unique screen, emits a UI-map JSON. |
| Think | Reads the UI map, searches jadx-decompiled sources for each element (via |
| Build | Merges UI map + bridge into a single self-contained HTML report (screenshots base64-embedded, evidence tables). |
| eval | Ground-truth validation: compares STB findings against the app's real manifest & source. |
Setup (VM, no KVM needed)
# Android 11 in Docker via redroid (binder on host kernel)
sudo modprobe binder_linux
sudo mkdir -p /dev/binderfs && sudo mount -t binder binder /dev/binderfs
docker run -d --name stb-android --privileged -v /dev/binderfs:/dev/binderfs \
-p 5555:5555 redroid/redroid:11.0.0-latest \
androidboot.redroid_width=720 androidboot.redroid_height=1280 \
androidboot.redroid_dpi=320 androidboot.redroid_gpu_mode=guest
sleep 45 && adb connect localhost:5555
# tools
sudo apt-get install -y adb openjdk-17-jdk-headless
# jadx: https://github.com/skylot/jadx/releasesUsage
# 1. SEE — traverse the app (a few minutes, ~40 taps)
python3 stb_traverse.py org.schabi.newpipe --max-screens 20 --max-taps 40
# 2. THINK — decompile & bridge
jadx -d decompiled/newpipe --no-res -j 2 newpipe.apk
python3 stb_bridge.py <uimap>.json decompiled/newpipe
# 3. BUILD — report
python3 stb_report.py <uimap>.json <bridge>.json
# → opens as a single HTML file, works offlineValidated results (Nov 2026)
Test subjects: NewPipe 0.29.3, Aegis (open-source, F-Droid).
NewPipe: 17 screens mapped, 471 code references bridged
Aegis: 4 screens; every button resolved to its exact implementing class (
IMPORT VAULT→WelcomeSlide.javaL53, radios →SecurityPickerSlide.java)Ground truth vs real NewPipe source: all verified screens MANIFEST-OK, drawer coverage 7/10 items within a 40-tap budget (9/10 with targeted deep-dive)
FLAG_SECUREapps (Aegis) block screenshots but not accessibility dumps — STB detects and reports this as a security signal
Known limitations
Traversal is DFS with a tap budget — deep screens (Settings, About, Player) may need more budget or targeted navigation
Text-based code evidence can be noisy on large apps;
R.idevidence is preciseWizard screens requiring text input (e.g. password setup) are declared "dead" and backed out of
Roadmap
v0.1 MCP server (
see-think-build) so any coding agent can drive the pipelinev0.2 BFS-style traversal with scroll awareness (proactive swipes on long lists/drawers)
v0.2 Text-input actions during traversal (tap + typed sample)
v0.2 Layout-XML bridge: res-id → declaring layout/menu XML →
R.layout.*inflate sitev0.2 Labeled-row tapping (drawer items report
clickable=falsebut still navigate)Direct deep-link navigation between screens (skip back-walking)
Coverage regression tracking per APK version
Install
From PyPI (recommended):
pip install see-think-build
stb-server # run the MCP server (stdio)
stb-see org.schabi.newpipe --max-screens 15 # CLI also available:
stb-think uimap.json decompiled/ # stb-see, stb-think,
stb-build uimap.json uimap_bridge.json # stb-build, stb-validateFrom source:
git clone https://github.com/Kian1904/stb && cd stb
pip install .Python 3.10+; only hard dependency is the mcp package. adb and jadx
are external binaries you install separately (see below).
Cross-platform setup
STB runs on Linux, macOS, and Windows. It talks to anything adb can reach: an official Android Studio emulator (AVD), a physical phone over USB, or a redroid container (Linux/Docker only). Requirements:
Python 3.10+
adb (Android platform-tools) — on PATH or via
STB_ADBjadx — on PATH or via
STB_JADX(github.com/skylot/jadx; needs Java 17+)
Setup per OS:
Step | Linux | macOS | Windows |
adb |
|
| Download platform-tools zip, add to PATH |
jadx |
| same | same ( |
Emulator | Android Studio AVD, USB phone, or redroid (Docker) | AVD or USB phone | AVD or USB phone |
MCP config |
|
|
|
Device targeting — set STB_ADB_SERIAL if more than one device is connected
(find serials with adb devices -l):
export STB_ADB_SERIAL=emulator-5554 # or 127.0.0.1:5555, or a USB serial
export STB_JADX=/path/to/jadx/bin/jadx
export STB_DIR=~/stb # where maps/reports/decompiled goRun stb_status first — it reports exactly what is missing and how to fix it.
Using a physical phone (Termux-friendly)
Enable USB debugging (Developer options), connect, accept the fingerprint
From Termux:
pkg install python android-tools, clone this repopython stb_server.py— the phone you're debugging can be a second device; the controlling agent runs anywhere adb works
MCP server
STB also ships as an MCP server (stb_server.py) so any MCP-capable coding agent
(Claude Code, Codex, Hermes, …) can drive the whole pipeline:
Tool | What it does |
| Lab health: container, adb, boot state, packages, jadx |
| Traverse an app → UI-map JSON (screens + elements + screenshots) |
| Accessibility tree of the CURRENT screen (works on FLAG_SECURE apps) |
| Screenshot of the current screen |
| Decompile an APK (jadx) |
| Bridge UI-map elements to decompiled code |
| Generate the self-contained HTML report |
| Ground-truth check vs real app source |
Config (generic stdio):
{
"mcpServers": {
"stb": { "command": "python3", "args": ["/path/to/stb_server.py"] }
}
}Env overrides: STB_DIR, STB_ADB_SERIAL, STB_ADB, STB_JADX,
STB_RUN_DIR, STB_CONTAINER (see Cross-platform setup above).
License
MIT
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Remote MCP for Android CLI agent build gate, structured receipts, audit logs, and reviewer-ready evi
Give your AI agent a real cloud Android phone: push APKs, drive it, get screenshots and logs.
MCP server for static security analysis of Android source code
Disposable cloud Android emulators for coding agents: run an APK or PR build, tap, type, screenshot.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides AI agents with a unified MCP interface for Android APK reverse engineering, metadata analysis, Smali/resource editing, rebuilding, signing, verification, and ADB device testing.MIT
- FlicenseAqualityCmaintenanceEnables installing, launching, and inspecting Android APKs on a dedicated emulator, with screen capture, UI tree inspection, and touch/navigation control via MCP tools.10-
- AlicenseBqualityCmaintenanceEnables any MCP assistant to see and operate an Android phone or emulator over plain adb, reading the accessibility tree to tap elements by name and also supporting screenshots, typing, swiping, app launching and installation, and logcat — with nothing installed on the device and no root required.13MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to locally inspect Android APKs over MCP by decompiling Java, decoding resources, searching classes and methods, tracing references, and producing evidence reports with limitations.5MIT