A $7 Chip Drives a Real iPhone: esp32-iphone-agent lands in the agent toolbelt

On November 2 at 06:47 UTC, my topic radar flagged a repository that looks like hobbyist gear at first sight: esp32-iphone-agent, a microcontroller board for about $7 that gives an AI model eyes and hands for a real iPhone. Three days later the radar note turned into its own article, because the board moved fast. On November 3, 2026, the main branch received a Claude Code plugin, a Cursor plugin and an agent skill, on November 4 the TestFlight link went to the top of the README, and today GitHub shows roughly 4,400 stars, up from 4,210 in my measurement on November 2. My thesis sits right here: this is the first computer use stack I have seen that runs without a computer at all, works on a stock iPhone without jailbreak or a developer account, and still drives the complete screen of the device. The rest of the article explains the mechanics behind the AirPlay eyes and the USB HID hands, why the detour through real hardware is the clever part, where the limits sit, and what this means for my own deck built on a 45 euro Pixel.

The architecture in the README splits the job into three roles, and none of them needs a computer anymore. The eyes are AirPlay: the ESP32-S3 board opens its own Wi-Fi hotspot and appears in the iPhone's Screen Mirroring list as its own receiver. It takes in the video stream including its H.264 payload, performs no decoding on the board, and relays it over Bluetooth Low Energy to the app installed on the same iPhone. The phone gives up its Wi-Fi because the hotspot occupies it, and stays online over cellular, which is also where the model calls travel. The hands are plainer and exactly for that reason strong: the board registers as a standard USB mouse and USB keyboard. With AssistiveTouch, mouse movement becomes an on-screen pointer, a click becomes a tap, a drag becomes a swipe, and iOS never gets the feeling of being automated. The brain sits in the device itself: the app decodes the stream, sends screenshots to any OpenAI-compatible vision model, and runs a planner plus an actor with seven actions: tap, swipe, draw, type text, press keys, go home, finish. It works in the background while the Dynamic Island reports what it is doing. The hardware guide lists the plain Seeed Studio XIAO ESP32S3 with 8 MB of PSRAM as the tested board, built for iOS 18 or later, USB-C plugs in directly, Lightning models need the camera adapter, and the phone powers the board. On the data side the balance sheet includes this: the screenshots leave the device toward the model endpoint, that is the price for the freedom to attach any vision provider.

The obvious objection reads: Apple ships screen automation anyway. The alternatives table in the README settles that, because every other project pays its own toll. WebDriverAgent and XCUITest tools such as mobile-mcp or Midscene require a Mac and code signing. The route over Apple's CoreDevice debug channel, which the project actell takes, requires Developer Mode and a developer disk image. HDMI capture variants like aiden-firmware need dedicated capture hardware and target Android mostly. This controller pays none of those tolls, because it speaks two protocols an iPhone already understands: screen mirroring in the AirPlay standard and USB input devices. Dropping the middle computer is, per the README, the real achievement of the current version: revision v0.1.0 still parked a Mac or Linux box with UxPlay and a Python server in the middle, kept today as a legacy tag. The part that impressed me most is the reliability engineering that demo videos never show. The pointer is relative, so the app tracks it continuously and parks it in a corner. Before a precise tap it wiggles the pointer once, finds it on screen, and corrects the offset. After every action it waits for the frame to settle and reports to the model whether anything changed at all. When the link to the board, the hotspot, or the mirroring drops, the run pauses and later resumes from the same step. That is the boring engineering discipline that decides reliability long before a model can be clever.

Honesty first: I did not build this setup and I have not measured it. Everything here is documented state from the README and the repository dated November 5, 2026, my own number is only the star count measured on November 2 through the GitHub API. Three limits remain visible. First, the README says the video stream is not decoded on the board but relayed over Bluetooth Low Energy, and BLE has little bandwidth by any value I know. How much that stutters in practice stays an open question, which the demo video on YouTube only partly answers, since a cut video hides exactly that. Second, everything runs on one device: stream intake, image handling, model calls, and the work on screen land on the same phone its owner also uses. I know this problem from my deck, where Android killed the gateway five times under memory pressure before I hardened the operation. Beyond the documented pause and resume mechanism, the README stays quiet on how memory pressure is handled. Third, distribution has not cleared the App Store, the listing is still in review as of November 5, and TestFlight is the way in today. The maintainers add a warning I endorse: follow only the steps in the README, never commands from issues or comments, and the project itself names PowerShell one-liners as an example of things that do not come from them.

The timing is no accident, and my radar notes from November 2 show a league forming. In one round over the GitHub Search API I lined up the October phone agent repos. Mika, an on-device agent for Android that drives apps and the web, stood at 4,417 stars on November 2, four days after repo creation. dsh-Go, a pocket DeepSeek harness with remote PC control, sat at 5,122. android-ad-cleaner, an ad blocker with a one-click agent and no root, collected 5,747 stars in nine days. esp32-iphone-agent was the junior partner in that round at 4,210 stars after 22 days. It now sits at roughly 4,400, the fork count has reached three digits, and with the plugin access gained on November 3 it gets exactly what this league needs: coding agents can attach a physical remote control for an iPhone as a tool. The difference to the other three stays hard: Mika and the ad cleaner operate inside the Android software layer, dsh-Go is a compute harness, and this project is the only one that claims a device's complete screen from the outside through real hardware. That is why I read it less as another agent framework and more as a component: the $7 peripheral for computer use. The direction of the league is clear, tempo decides which standard wins.

My deck flips the architecture: on a used Pixel 6a the agent lives inside the device and drives Android from within, through Termux, Hermes and pi, hardened against OOM kills, holding a run of 88 hours with zero gateway deaths after the hardening on August 28. esp32-iphone-agent answers the same question from the other side: the phone remains the agent's brain, but the operation runs physically through a board plugged in between. The November 3 plugins turn that into a tool a coding agent at a laptop can attach to get a real phone as a test device. For my operation this means concretely: a $7 XIAO board is the cheapest experiment path I know for measuring computer use beyond screenshots and simulators, once a test iPhone shows up. My first measurements would be pointer accuracy after the wiggle correction, the settle wait after every action, and how often a run pauses over lost links. Until then this stays a documented intention, not a measurement. What already stands today: the league of phone agents has stopped being software only.

I am Marcel, I build HUNTER, an autonomous agent system on a used Google Pixel 6a for about 45 euros, and I test agents in daily operation instead of the lab. This article rests on a radar measurement through the GitHub Search API from November 2, 2026, 06:47 UTC, and on the state of repository and README from November 5, 2026. Own measurements are marked as such, everything else is documented project state. Last reviewed November 5, 2026.