A complete device API
for AI agents.

Test every edge case your QA team never gets to — no test code, no device farm, no instrumentation. The emulator is just the runtime.

Hero: Terminal on the left showing MCP tool calls (send_phone_call, set_network_speed, get_network_logs) with an Android emulator on the right showing the app under test responding to each command in real-time.

One tool call. Full device control.

Your agent calls MCP tools. Doksi manipulates the device. No scripts, no selectors, no SDK.

install_appInstall APK and launch
send_phone_callInject call mid-flow
set_network_speedDegrade to 2G / 3G
set_gps_locationSpoof coordinates
grant_permissionGrant or revoke at any point
trigger_fingerprintBiometric auth
get_network_logsFull HTTP traffic with payloads
get_performance_metricsFrames, jank, render times
pull_app_dataSQLite, shared prefs, files
start_tunnelConnect to your local dev server
One session. Full coverage.

What an agent does in a single session

No test scripts. No device farm setup. No instrumentation framework. Just an AI agent with full device control.

Install a fresh build and test the happy path UI flow
Test biometric auth without physical hardware
Inject a phone call mid-flow and verify graceful handling
Drop to 2G and verify loading states appear
Revoke location permission mid-session and verify fallback UI
Assert every API call fired with correct payloads and status codes
Pull performance metrics and flag janky frames

All without a single line of test code.

Vertical sequence of 7 steps, each as a small card: (1) APK install with green check (2) Fingerprint icon with auth success (3) Phone ringing icon mid-checkout (4) Signal bars dropping to 2G (5) Shield icon with permission denied (6) Network log table with 200/500 statuses (7) Performance graph with jank highlighted. Connected by a dotted vertical line.

Capabilities

Everything your agent needs to test the untestable

A complete device state manipulation API. The emulator is just the runtime.

Telephony simulation

  • •Simulate incoming calls at any point — init, accept, reject, busy, hold
  • •Send SMS messages mid-session
  • •Does your checkout survive a phone call? Does onboarding handle an interruption?

Biometric auth

  • •Trigger fingerprint authentication programmatically
  • •Test biometric login flows without physical hardware or manual interaction

Environment simulation

  • •GPS — set exact coordinates for location-aware features
  • •Network speed — degrade to 2G/3G, verify loading states and timeouts
  • •Battery — set level and charging state for battery-aware UI
  • •Font scale — test accessibility at 150% or 200% font size
  • •Dark mode — verify at system level, not just in-app toggle
  • •Orientation — portrait and landscape switching mid-flow
  • •Silent mode / volume — test audio-aware UI states
  • •Wifi / Bluetooth / Location / Airplane mode toggles
  • •Phone vs tablet — switch display profile for responsive layouts

Permission testing

  • •Grant and revoke permissions programmatically at any point in a session
  • •Test mid-session permission denial — the flows that always break in production

Network assertion layer

  • •get_network_logs — full HTTP traffic: URL, method, status, request body, response body
  • •Assert the right endpoint was called with the right payload after every interaction
  • •Functional test coverage without Espresso, without mocking, without instrumentation
  • •The agent is the test runner. The network log is the ground truth.

Performance monitoring

  • •Frame count, janky frame percentage, render time percentiles
  • •Automated perf regression — did this build get slower?
  • •Memory profiling: native heap, Dalvik heap, and total PSS per app

Deep device access

  • •Push test fixture files onto the device
  • •Pull SQLite databases and app data for state inspection
  • •Clear app data between test runs for clean state
  • •Inspect installed packages, clipboard content, and set clipboard for paste flows
  • •Read application logs (logcat) to catch crashes and errors
  • •Read shared preferences, databases, and app files directly
  • •Disable animations for reliable, flake-free automated testing

Local dev tunneling

  • •Built-in Tailscale tunnel connects the cloud device directly to your local machine
  • •Test against your local dev server — no staging environment, no deploy pipeline
  • •Ship nothing, test everything: run node server.js, install your dev build, the agent tests the full stack in real time
  • •Network logs capture all traffic to your local server with full request/response visibility
App lifecycle

Every entry point. Every exit.

Full lifecycle control in a single session. Install, launch, deep link, navigate away, come back, uninstall.

Open deep links — test every entry point into your app
Open Chrome, open system settings — test flows that leave and return
Expand notification shade — test notification tap handling
Install, launch, terminate, uninstall — full cycle per session

Flow diagram: circular layout showing Install -> Launch -> Deep Link -> Chrome -> Return to App -> Notification Tap -> Terminate -> Uninstall. Each node is a small rounded card with an icon. Arrows connecting them. Center shows the Android robot icon.

What this replaces

Stop duct-taping tools together. One API replaces your entire device testing stack.

What you needed beforeDoksi replaces it with
QA engineer manually testing edge casesAI agent running systematic edge case coverage
Device farm subscription (BrowserStack, LambdaTest)Cloud emulator on demand
Espresso / XCUITest instrumentationNetwork logs + visual state as assertion layer
Custom ADB scripts for device stateSingle MCP tool call
"We don't test that"send_phone_call + get_textual_state

Simple pricing

Pay for what you use. A full edge case test suite — happy path, biometric, interrupted flow, degraded network, permission denial, performance check — runs comfortably in one session.

$10

200 minutes, 1 device

Full device state API
Network assertion layer
Performance monitoring
Local dev tunneling
RECOMMENDED
$20

500 minutes, 2 devices

Everything in $10 plan
Parallel test execution
2 concurrent devices
Faster feedback loops

Billing starts when the session is ready, not when you call session start.

Test every edge case.
Ship with confidence.

No test code. No device farm. No maintenance.