Your iPhone in Parallax, and agent taps 6 to 20 times faster The Parallax project released beta.7 of its desktop app and MCP server for React Native, which now builds the element list for agent taps from the app's React tree via Metro instead of slow platform accessibility dumps, cutting tap latency to roughly 0.5–0.84 seconds from as much as 14 seconds. The team measured 33 of 34 frames matching the dump within a point, and the tool falls back to AXe or uiautomator when the app isn't connected or in front. The release also adds read-only iPhone mirroring over macOS capture, while sending taps to a physical iPhone still requires a signed test runner and is not yet supported. A Galaxy S24 and an iPhone 13 in one Parallax window, running the same test app on one Metro. The agent taps on the S24; the iPhone is watch only, and a pick on its picture opens src/CompatScreen.tsx:16 . Parallax is a desktop app and an MCP server that give you and your coding agent the same live view of a running React Native app: the screen, the component tree, logs, network and state. Three releases went out this week. Here is what changed, how one of the changes works, and what is still missing. Every agent tap reads the screen twice. Before the tap, the tool needs to find the element and check that the app is in front. After the tap, it tells the agent what changed. Until beta.7 both reads were the platform's accessibility dump: AXe on iOS, uiautomator on Android. Those dumps are slow. On a still screen they took 0.6 to 3 s. On an Android screen with an animation, uiautomator waits for the screen to go idle, and on our busy test screen it gave up after 11 s. One tap took 14 s. A React Native app already knows what is on its screen. Parallax reads the app's React tree through Metro, and from it builds the same list the dump gives: each view with a testID, a label, text, or a text input, with its frame measured by the app itself. That takes 5 to 100 ms. The testIDs are the same, and 33 of 34 frames we compared matched the dump's to within a point. So when the app is connected and in front, both reads now come from React. A tap is 0.50 to 0.53 s on the iOS simulator and 0.60 to 0.84 s on the S24, measured over 5 taps by id and 5 by point on each. The first tap of a session still takes about 4.9 s, because it opens the input session and reads the dump once. The agent's taps on the iOS simulator: count+ three times, then the perf lab opened and closed. The "Last action" line under the picture updates after each tap. The dump stays for what React can't see: system alerts and permission prompts, the keyboard, another app in front, an app that isn't connected. If the app loses its connection to Metro, every read falls back to the dump, and taps are as slow as before. Showing an iPhone and controlling one are different problems. Showing it is the cheap half. macOS can treat a plugged-in iPhone as a video source. Our capture helper, a small piece of native code of our own, streams that picture to the window. The app's data comes through Metro as on a simulator, so the Inspector, logs, network and state work unchanged. Nothing is installed on the phone, and you need no Apple account. macOS asks once for camera access, because that is how it classes the iPhone's picture. Pointing works on the iPhone's picture as on a simulator's, because a pick reads React, not input: On the simulator: Select element, a click on "fetch", and the Inspector opens src/CompatScreen.tsx:16 . The pick on the iPhone in the first clip works the same way. Controlling it is the expensive half. Sending a tap to a real iPhone needs a signed test runner on the phone. That is the next plan, and until it lands, the agent's tap, swipe and type tools on an iPhone answer that this needs a later version. You tap on the phone itself. One setup note. With React Native 0.86 and the prebuilt React Core, an app on a device ignores RCT METRO PORT and connects to port 8081. If your Metro runs on another port, start the app from Xcode with this launch argument: -RCT jsLocation