Browser agents are a solved-enough problem in 2026: give Claude Code a Chrome and it can click through your checkout flow. Phones are a different story — USB debugging, accessibility services, Compose canvases with no DOM, and a device that sleeps halfway through your test. That is the gap ARTEMIS is aimed at: an open-source agent from Google’s Pixel Test Engineering team that turns “open Settings, find Battery and tell me the level” into taps on a real device, and exposes it to Claude Code, Codex, Antigravity, Cursor and Windsurf over MCP.

The repo went public on August 13, 2026, sits at 6,100+ GitHub stars as of September 16, 2026, is Apache-2.0, and claims 99.1% task completion on Google Research’s AndroidWorld benchmark. It has also spent the last week in an attribution dispute with the French startup Minitap, whose open-source mobile-use project ARTEMIS was built on — a dispute that hit 166 points on Hacker News and forced Google to amend the README.

Here’s what ARTEMIS does, how it’s built, what it installs on your phone, and how to weigh the benchmark once you know where the code came from.

TL;DR for AI agents

Repogithub.com/google/artemis — 6,167 stars, 548 forks, 75 open issues (Sept 16, 2026)
WhatNatural-language → Android device automation; MCP server for coding agents; Python SDK for CI
License / languageApache-2.0 / Python 3.12+ (LangGraph, LangChain, uiautomator2, adbutils, FastAPI)
ModelsGemini 3.8 Flash default (config), presets for Gemini 2.5, GPT-4o, Gemini Flash-Lite, local Ollama vision models; also Anthropic, OpenRouter, xAI keys
InterfacesWeb console (localhost:8000), CLI (artemis run), MCP server (5 tools), Python SDK (artemis-client)
ProfilesFlash — single-model reactive loop, ~3–5 s/step. Pro — Planner/Operator/Checker graph, ~15–40 s/step
Benchmark99.1% on AndroidWorld (self-reported; leaderboard does not verify)
LineageIncorporates code from Minitap’s mobile-use (Apache-2.0, 3k stars); attribution added Sept 12, 2026 after complaint
RoadmapAndroid Studio plugin, iOS, on-device VLMs, duplex voice control

What ARTEMIS actually is

ARTEMIS observes an Android screen (screenshot + accessibility hierarchy + OCR), picks an action with an LLM, executes it through ADB/UIAutomator2, and loops. That fits a dozen “mobile-use” projects from 2025. What makes ARTEMIS worth a look is the packaging around the loop:

  • A native MCP server with five tools — mobile_run_task, mobile_manage_task, mobile_get_device_state, mobile_inspect_trace, mobile_diagnose — so a coding agent can drive a test device without you writing glue.
  • Two execution profiles (Flash and Pro) with very different cost/latency envelopes, selectable per task.
  • A rules file (mcp_server/rules.md) that teaches the host agent to explore the app with ARTEMIS first, then write deterministic test code — a genuinely useful discipline for anyone using Claude Code to write Espresso or Maestro tests.
  • A web console with live scrcpy mirroring, a prompt dock, task queue and replays.
  • A zero-dependency Python client for calling a remote ARTEMIS host from pytest or CI.

The README pitch is testing (“Let AI assistants and test suites use real phones like a human”); the demo GIF is consumer automation — plan routes in Google Maps, sum the durations, open YouTube and play a Coldplay song. Both work; the design leans QA.

Installation: one script, plus an APK on your phone

Requirements are Python 3.12+, uv, and an Android device with USB debugging enabled (or an emulator). The start script installs ADB, scrcpy and FFmpeg if missing:

git clone https://github.com/google/artemis.git && cd artemis
cp .env.example .env      # add GEMINI_API_KEY (or OPENAI/ANTHROPIC/OPEN_ROUTER/XAI)
./start.sh                # Windows: .\start.bat

That opens http://localhost:8000 with a device wizard. The CLI equivalent:

uv run artemis run "Open Settings, find Battery and tell me current level" --profile flash
uv run artemis doctor      # environment check
uv run artemis helper install   # pre-install the on-device helper

The part worth reading twice: the first task installs an APK on your phone. The Artemis Accessibility Helper is a small accessibility service that reads the screen layout without taking the UiAutomation connection, so ARTEMIS can coexist with other UiAutomation tools. You’ll see a persistent “Artemis test helper is running” notification and an entry under Settings → Accessibility. Google says it listens only on the phone and sends nothing elsewhere. To opt out, set ARTEMIS_HELPER_AUTO_INSTALL=false and ARTEMIS_HIERARCHY_BACKEND=uiautomator in .env. Also note ARTEMIS_KEEP_DEVICE_AWAKE=true holds a wake lock by default — turn it off on a personal phone.

Wiring it into Claude Code, Codex or Antigravity

The one-liner installs both the MCP server config and the rules file for every detected IDE:

uv run artemis mcp --install all      # or: claude | codex | antigravity | cursor | windsurf | openclaw
uv run artemis mcp --generate-config codex   # print the snippet instead

The manual Codex entry (~/.codex/config.toml) shows what it’s doing — no npx, it points at the repo’s own venv:

[mcp_servers.artemis]
command = "/path/to/artemis/.venv/bin/python"
args = ["-m", "mcp_server"]
cwd = "/path/to/artemis"

[mcp_servers.artemis.env]
PYTHONUNBUFFERED = "1"
PYTHONPATH = "/path/to/artemis"

For Claude Code the installer drops the rules into ~/.claude/rules/artemis.md; for Cursor ~/.cursor/rules/artemis.mdc; for Antigravity ~/.gemini/rules/artemis.md. Then you prompt in the IDE:

“Build the latest changes into an APK, install it on the connected device, open the login screen with a test account, verify there are no unexpected popups after login, and return screenshots of the final page.”

mobile_run_task is asynchronous — it spawns a detached process and returns a trace ID, so the coding agent isn’t blocked for a 10-minute run. Completion fans out through notifiers: Antigravity gets a reactive wake-up via agentapi, Claude Code and Cursor get a desktop toast plus a notifications.jsonl audit log, and CI/Discord/Slack/OpenClaw get a JSON webhook (ARTEMIS_WEBHOOK_URL). The agent then polls mobile_manage_task(action="status").

Flash vs Pro: the architecture that matters

This is the most interesting engineering decision in the project, and the README is candid about the trade-offs.

Flash is a single-LLM observe-think-act loop with no orchestration graph: goal + current UI element list + screenshot in, action tools out, around 3–5 seconds per step. It chains taps into a click_sequence to catch auto-fading control bars and toasts. There is no step cap by default because history is compressed rather than truncated — older screenshots collapse into visual summaries, completed steps get chunked into “eras”, and the model can call search_history / replay_steps / video_analyzer to look back. Limitations, per Google: no plan, no pre-execution safety net, no checkpoint verification, no final report, no ADB shell.

Pro is a LangGraph multi-agent workflow at 15–40 seconds per step:

  • A Planner writes a living Markdown plan with milestones and verify / assert items.
  • An Operator executes it with the full toolset — an Explorer for visual grounding (three depth tiers: flash one-shot, pro three-turn, ultra deep zoom), notes, history recall, video analysis, and ADB commands.
  • Every single action passes a Safety Net that checks the target against the live XML tree first, pixels second. Multi-action “fast-action bursts” skip the net to beat transient UI.
  • A blocked action opens an execution incident that stays in the Operator’s context until a later action succeeds — recovery is the Operator’s own job; there’s no separate repair agent.
  • A read-only Checker verifies checkpoints and runs an exit review against the original goal. --verification-level goes off / final (default) / checkpoints / strict, where a failed assert halts the run.
  • An optional Outputter writes a human-readable report.

artemis/agents/ holds seventeen agent modules — planner, operator, checker, explorer, hopper, object_detector, video_analyzer, log_analyzer, diagnoser and more. config/artemis.jsonc routes them to different models: gemini-3.8-flash by default, gemini-3.5-flash-lite for the cheap Hopper node, gemini-robotics-er-2-preview for object detection. A local-ollama preset points at llama3.2-vision, though nobody should expect 99% from it.

The rules file’s heuristic: Flash for straightforward UI actions regardless of length; Pro when you need a persistent plan, verified checkpoints, [Loop:continuous] polling, ADB/log/video diagnostics, or a written report.

The Python SDK for CI

The artemis-client package has zero runtime dependencies and talks HTTP to an ARTEMIS host that owns the ADB connection, models and image processing:

uv add "artemis-client @ git+https://github.com/google/artemis.git#subdirectory=packages/artemis-client"
import asyncio
from artemis_client import ArtemisClient

async def main():
    client = ArtemisClient(
        "http://artemis-host:8000",
        device_serial="emulator-5554",
        default_profile="flash",
    )
    result = await client.run(
        "Open System Settings, go to 'Battery', verify battery percentage "
        "is displayed, and check for any crash dialogs."
    )
    assert result.succeeded, f"Test failed: {result.error or result.status}"
    print(f"Passed on {result.device_serial} | trace {result.trace_id}")

asyncio.run(main())

Results are typed Pydantic objects, so assert result.succeeded slots into pytest. Per-device locks let different devices run in parallel; the same device queues FIFO.

The Minitap dispute — read this before you cite the benchmark

On September 11, 2026 Minitap co-founder Pierre-Louis Favreau published “I expected better from Google”. The team opened ARTEMIS, recognised their own code, and — in Favreau’s words — reacted with “What the fuck? We wrote this.” The specifics are checkable:

  • ARTEMIS’s adb_tunnel.py device-connection code matched mobile-use’s implementation line for line at the time of the check.
  • The Hopper agent’s prompt (hopper.md) was identical, word for word — down to a name a Minitap engineer picked because he liked Minecraft.
  • An SDK example (app_lock_messaging.py) sent the same Happy New Year messages to Alice, Bob and Charlie with the same comments.
  • Older versions shared the same bug in media.py — a helper wrote a results file, then failed reading its own output.
  • ARTEMIS’s initial pyproject.toml carried mobile-use’s version number, 3.6.3, and listed Minitap’s three authors under a Google copyright header. A force push in August replaced them with a single Google author. The only change in that commit was the author list.

Minitap filed issue #40. The HN thread reached 166 points and 31 comments on September 12. Reactions ranged from “this looks pretty damning… is an innocent explanation possible here?” to one commenter’s pushback that swapping pyproject.toml authors is normal (“the equivalent of telling you who the maintainers are”) — while noting the proper convention is keeping copyright headers in source files and a NOTICE, which ARTEMIS hadn’t done.

Google’s response: commit 371aa6d on September 12 added a one-line README credit (“This project includes source code developed by Minitap, Inc.”) and restored upstream copyright headers. On September 15 the maintainer closed and locked issue #40 without further comment. A community PR (#76) listing a dozen more overlapping files — ui_hierarchy.py, recorder.py, shell_utils.py, the unit tests — is still open. No apology has been posted.

Why this matters beyond ethics: the 99.1% AndroidWorld number is self-reported, and the leaderboard says explicitly it does not verify submissions. Minitap says mobile-use scored 94.8% and then 100% in its own January evaluations, emailed the leaderboard maintainer four times, and got no reply — the sheet still shows 91.4%. So the README’s “99%+ SOTA” compares Google’s fresh self-report to a competitor’s stale entry, for a codebase that descends from that competitor. Treat the benchmark as “very good on the tasks Google evaluated”, not proof of superiority.

To Google’s partial credit: Apache-2.0 permits the reuse, ARTEMIS adds real engineering (the Flash/Pro split, the Accessibility Helper, the MCP server, diagnostics, history compression), and attribution now exists. But an official Google repo shipping a force-pushed author swap is the kind of thing that makes small teams stop publishing.

Community reaction to the tool itself

Outside the attribution row, feedback is thin because the repo is five weeks old. AlphaSignal framed it as “99% on Android tasks where most agents fail” and identified the Pixel Test Engineering team as the origin. The issue tracker has the useful signal: a fix closed an ADB shell injection (#55), helper status misreports the service as disabled on some devices (#109), and feature request #114 asks for mobile_observe / mobile_act primitives so the host agent can drive the phone step by step instead of delegating a whole task. That one is telling — some users want ARTEMIS to be a device driver, not a second autonomous agent.

Honest limitations

  • Android only. iOS is a roadmap checkbox; Minitap’s mobile-use and Maestro cover iOS today.
  • It installs software on the device and holds a wake lock. Fine for a test rack; think twice on your daily phone.
  • Pro is slow and expensive. 15–40 s per step with several Gemini calls per turn; a 100-step run is real money.
  • Model latency ≠ test timing. Google’s own rules file admits the agent can’t do precise waits — use ARTEMIS to discover the path, then write deterministic tests with explicit waits.
  • Google-tuned. Defaults, presets and the object detector are Gemini; the OpenAI and Ollama paths exist but the 99% claim doesn’t travel with them.
  • Heavy install. LangGraph, LangChain, OpenCV, scipy, matplotlib, FastAPI — not a pip install and go.
  • Governance risk. Five weeks old, one listed author, a locked attribution issue. Fork it before betting a QA pipeline on it.

ARTEMIS vs the alternatives

ARTEMISMinitap mobile-usePhone HarnessMaestro
PlatformsAndroidAndroid + iOSAndroid + iOSAndroid + iOS
ApproachAutonomous agent, Flash/ProAutonomous agentHost agent drives phone step by stepDeclarative YAML flows
MCP serverYes (5 tools)—YesVia community
Coding-agent rules fileYes———
AndroidWorld99.1% (self-reported)91.4% on sheet; 100% self-reported—n/a
LicenseApache-2.0Apache-2.0Open sourceApache-2.0
MaintainerGoogle Pixel Test EngMinitap (now closed-source successor)IndividualMobile.dev

If you want an agent-driven Android test harness with Google’s engineering budget and don’t mind Gemini, ARTEMIS is the most complete option right now. If you want your coding agent to hold the controls itself, Phone Harness is closer to that model (and issue #114 suggests ARTEMIS may follow). For deterministic regression suites, Maestro is still the boring right answer — ARTEMIS’s own rules file effectively tells Claude Code to write Maestro/Espresso tests after exploring.

Verdict

ARTEMIS is serious mobile-agent infrastructure with an unusually good MCP story: async tasks, notifier fan-out, a diagnostic tool the host agent can act on, and a rules file that encodes real QA discipline. The Flash/Pro split is the right abstraction and history compression for unbounded loops is smart.

It is also a Google repo that shipped another team’s code under a swapped author line and fixed it only after public shaming. Use the software — the licence allows it and it works — but cite the benchmark with the asterisk it deserves, and if attribution matters to you, star mobile-use too.

FAQ

Does Google ARTEMIS work with Claude Code? Yes. uv run artemis mcp --install claude writes the MCP server entry and installs the testing-rules file to ~/.claude/rules/artemis.md. Claude Code then gets five mobile_* tools and can launch async device tasks, poll status and inspect traces.

What’s the difference between ARTEMIS Flash and Pro? Flash is a single-model reactive loop (~3–5 s/step) with no planner, safety net or verifier — fast and cheap for deterministic UI tasks. Pro is a LangGraph Planner → Operator → Checker workflow (~15–40 s/step) with pre-action checks, incident tracking, checkpoint verification and optional reports, meant for long, branching or diagnostic tasks.

Is the 99% AndroidWorld score verified? No. AndroidWorld’s leaderboard states it does not independently verify submissions. ARTEMIS reports 99.1%; Minitap reports 100% for mobile-use in its own January 2026 evaluation but appears on the sheet at an older 91.4%.

What does ARTEMIS install on my phone? An accessibility service APK called Artemis Accessibility Helper, used to read the UI hierarchy. It shows a persistent notification and appears under Settings → Accessibility. Disable auto-install with ARTEMIS_HELPER_AUTO_INSTALL=false; remove it with uv run artemis helper uninstall.

Can ARTEMIS run with local models instead of Gemini? There’s a local-ollama preset using an OpenAI-compatible endpoint and llama3.2-vision, plus OpenAI, Anthropic, OpenRouter and xAI key slots. The defaults, object detector and benchmark results all assume Gemini. iOS support is not available yet; it’s on the roadmap with an Android Studio plugin and on-device VLMs.

Sources