Agent Device
Open-source CLI from Callstack that gives AI agents token-efficient, LLM-readable snapshots and control of real iOS, Android, TV, and desktop apps.
Agent Device addresses the part of agentic mobile work teams underestimate: giving the model a small structured view of a native screen instead of a screenshot. The record-then-replay loop is the real payoff — exploration becomes a replayable .ad script rather than throwaway session work, and the typed TypeScript client lets you fold that into a CI job or cloud agent. Go in knowing `replay -u` selector healing is explicitly labeled Experimental, so budget a human check on replayed scripts. If your automation is browser-shaped, stick with Playwright or Puppeteer; this covers the native app ground they don't.
Verified 2d ago · liveness 61/100 · cite: rightaichoice.com/tools/agent-device
- Developers building AI agents that must operate real native iOS, Android, TV, or desktop apps
- QA engineers turning exploratory mobile sessions into replayable .ad regression scripts
- Teams running cloud agents that still need verification on simulators or real devices
- TypeScript teams embedding device automation directly in their codebase
- Non-technical users who want a GUI-driven mobile automation tool
- Teams that require formal test-reporting dashboards for release sign-off
- Anyone expecting a hosted device farm bundled out of the box
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Agent Device if you need a GUI test recorder or a hosted device farm, or if your automation target is a web app that Playwright already drives.
Agent Device is published as open source and installs free via `npm install -g agent-device`, so the real cost is the simulators and physical devices you supply plus engineering time to write and maintain .ad scripts. That puts it at the low end versus hosted device farms and commercial mobile test platforms, which bill per device-minute or per seat.
In short
Agent Device — Open-source CLI from Callstack that gives AI agents token-efficient, LLM-readable snapshots and control of real iOS, Android, TV, and desktop apps. Best for Developers building AI agents that must operate real native iOS, Android, TV, or desktop apps, QA engineers turning exploratory mobile sessions into replayable .ad regression scripts, Teams running cloud agents that still need verification on simulators or real devices. Free to use.
What people actually say about Agent Device — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
63 mentions across 5 sources (Hacker News, YouTube, Bluesky, GitHub, Lemmy) · researched Jul 15, 2026.
Average across the 5 sources that answered — each source counts once, not each post.
- +Free and open-source with no pricing tiers.
- +Token-efficient accessibility-tree snapshots reduce LLM costs.
- +Stable element references (@e1, @e2) for reliable agent interaction.
- +Cross-platform support for iOS, Android, TV, and desktop.
- +Session recording and deterministic replay for reproducible testing.
- −Very early stage with 37 open GitHub issues.
- −Thin community feedback makes reliability hard to judge.
- −No official integrations or plugin ecosystem yet.
- −Limited documentation beyond basic CLI usage.
- −Lack of published performance benchmarks or comparisons.
Viability Score
How well maintained and how widely used is Agent Device? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Accessibility-tree snapshots rendered as token-efficient, LLM-readable UI views
- Stable element refs (@e1, @e2) for repeatable targeting across runs
- `snapshot -i` returns only interactive elements to shrink context
- Snapshot refinement flags, e.g. `snapshot -i -c -d 4`
- Semantic selectors: `find "Sign In" click` and `find role button click`
- Drives real apps on iOS, Android, TV, and desktop targets
- Cross-platform runs via --platform ios, --platform android, or --target tv
- Switch between simulators, physical QA devices, and TV-class targets
- Pin a specific device with --serial, e.g. --serial emulator-5554
- Record exploratory sessions to a replayable .ad script with --save-script
- Deterministic replay via `agent-device replay`, plus experimental -u selector healing
- Typed TypeScript client (createAgentDeviceClient) with simulators.ensure and capture.snapshot
- Session lock policy such as 'reject' for concurrent-session safety
- Parsed log capture with `agent-device logs mark` and network dumps via `network dump`
- Screenshots, screen recordings, airplane-mode toggling, and push notification triggers
About Agent Device
Agent Device is an open-source command-line tool from Callstack, the React and React Native consultancy, that gives AI agents structured control over real native apps on iOS, Android, TV, and desktop. It borrows the pattern that made browser agents practical: snapshot the screen, hand the model a small readable view of it, then act. You install it globally with `npm install -g agent-device` and point it at an app identifier and platform, e.g. `agent-device open com.myapp --platform ios`. The core command is `snapshot`, which exposes the target app's accessibility tree and tags each element with a stable ref like @e2, formatted for LLMs. `snapshot -i` returns only interactive elements to keep context small, and the docs show `snapshot -i -c -d 4` trimming it further. Acting is either ref-based (`agent-device fill @e3 "agent@example.com"`) or semantic (`agent-device find "Sign In" click`, `agent-device find role button click`), which keeps agent flows readable instead of coordinate-fragile. One mental model covers every target: `--platform ios`, `--platform android`, or a TV target via `--platform android --target tv`, and `--serial` pins a specific device such as emulator-5554. You record an exploratory session with `--save-script`, replay it deterministically with `agent-device replay`, and can try experimental selector healing with `-u`. Debugging stays in the terminal: `logs mark`, `network dump 25`, `screenshot error.png`, `record start fail-state.mp4`, `settings airplane on`, and push notification triggers for edge states. Callstack also ships a typed TypeScript client (`createAgentDeviceClient`) for embedding sessions, simulator provisioning, and snapshot capture in your own codebase or cloud agent, plus official agent skills via `npx skills add callstack/agent-device`, including a structured `dogfood` exploratory QA skill. It is aimed at developers and QA engineers building agents that must touch native apps; Playwright and Puppeteer still cover the web side.
Behind the Verdict
Agent Device is best understood as Playwright's methodology transplanted onto native mobile and TV, and that framing is accurate to how Callstack has built it. The snapshot command reads the accessibility tree and assigns stable refs (@e1, @e2, @e3) formatted for LLM consumption. That matters more than it sounds: raw screenshots burn context and force coordinate guessing, while a tagged tree gives an agent a short list of named, addressable elements. `snapshot -i` narrowing to interactive elements, and `snapshot -i -c -d 4` narrowing further, are the practical knobs you'll reach for first when a long flow starts blowing context. The acting layer is where it separates from older mobile automation. You can hit a ref directly (`agent-device fill @e3 "agent@example.com"`) or use semantic selectors (`agent-device find "Sign In" click`, `agent-device find role button click`). Semantic targeting is what makes a recorded flow survive a redesign; ref-based targeting is faster but more brittle across builds. The record/replay loop is the strongest idea in the product. An agent explores with `--save-script`, the session lands as a .ad script under ~/.agent-device/sessions/, and `agent-device replay` reruns it deterministically. That converts one-off exploration into something CI can consume. Weigh the caveat: auto-healing via `replay -u` is labeled Experimental on the vendor's own homepage, so treat healed selectors as a suggestion, not a guarantee, and review replayed scripts before they gate a release. Cross-platform reach is genuinely single-model: `--platform ios`, `--platform android`, `--platform android --target tv`, with `--serial emulator-5554` to pin a device. Moving the same flow from a simulator to a physical QA device to TV-class hardware doesn't require rewriting it. The TypeScript client (`createAgentDeviceClient`, with `simulators.ensure`, `apps.open`, `capture.snapshot`, `sessions.close`, and a `lockPolicy: 'reject'` option for concurrent-session safety) is what makes it usable inside a cloud agent rather than only at a laptop terminal. Debugging support is unusually complete for a v1-pattern tool: `logs mark` writes a labelled marker into parsed logs, `network dump 25` captures the last 25 network events, `screenshot` and `record start` produce visual evidence, and `settings airplane on` plus push payloads let you force edge states like offline or notification-entry flows. That is the difference between an agent that reports "failed" and one that hands you a recording and a network trace. Where it doesn't fit: the whole documented surface is terminal commands, so a team without command-line comfort will struggle. It is not a hosted device farm — the examples run against targets you supply: `emulator-5554`, a physical QA device, or TV hardware. Snapshot quality is bounded by how good the target app's accessibility tree is; a poorly labelled native app yields a poor snapshot. And there is no test-report dashboard, so if release
Researching Agent Device? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Agent Device actually fits — and what changes day-one when you adopt it.
You open a build on an iOS simulator with `agent-device open com.myapp --platform ios --session e2e --save-script`, let an agent walk the signup flow, then replay the saved .ad script in CI with `agent-device replay`.
Outcome: Exploratory session work becomes a deterministic regression run instead of a one-off manual pass.
You call createAgentDeviceClient({ session: 'qa-ios', lockPolicy: 'reject' }), run `simulators.ensure({ device: 'iPhone 17 Pro', boot: true })`, open an app, and pull `capture.snapshot({ interactiveOnly: true })` inside your own orchestration loop.
Outcome: Device provisioning and LLM-readable screen context live in your codebase rather than a shell script.
You deep-link to the failing state, run `agent-device network dump 25` and `agent-device logs mark "before submit"`, then `record start fail-state.mp4` and `screenshot error.png` before toggling `settings airplane on` to reproduce the offline case.
Outcome: You hand over a network trace, labelled logs, and a video instead of a vague description.
Use Cases
- Give an AI agent a token-efficient, structured view of a native iOS screen so it can navigate real flows
- Record an exploratory Android session with --save-script and replay it later as a regression run
- Run one agent workflow against an iOS simulator, a physical QA device, and an Android TV target
- Provision simulators and capture snapshots programmatically from TypeScript with createAgentDeviceClient
- Reproduce a bug by deep-linking to a state, running `network dump 25`, and saving an mp4 recording
- Exercise onboarding and permissions by reinstalling builds and testing clean-state flows
- Install the official agent-device skills so an agent automates mobile apps from the first prompt
Limitations
- Agent Device is a CLI-first developer tool: setup and the documented workflow run through terminal commands (`npm install -g agent-device`, then `open`, `snapshot`, `press`, `replay`), so comfort with a command line and with mobile device automation is expected.
- It drives targets you supply, such as development simulators (`--serial emulator-5554`), physical QA devices, or TV-class targets, rather than hosting devices itself.
- Selector auto-healing via `replay -u` is explicitly labeled Experimental on the vendor homepage, so replayed scripts should be human-checked before gating a release.
- Snapshot output derives from the accessibility tree plus assigned refs, so quality depends on the target app exposing a usable tree.
as of 2026-10-17
Verification history
We have re-verified Agent Device 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Agent Device tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Developers, QA engineers, and agent builders who already have simulators or physical devices and want native app control without a per-seat licence
What this tier adds
Starting (and only published) tier: free install via `npm install -g agent-device`, with accessibility-tree snapshots, semantic selectors, record/replay, the typed TypeScript client, and official agent skills
Where the pricing makes sense
The company stage and team size where Agent Device's pricing actually pencils out — and where peers do it cheaper.
Agent Device is published as open source and installs free via `npm install -g agent-device`, so the real cost is the simulators and physical devices you supply plus engineering time to write and maintain .ad scripts. That puts it at the low end versus hosted device farms and commercial mobile test platforms, which bill per device-minute or per seat.
Setup time & first value
How long it actually takes to get something useful out of Agent Device — broken out by persona, not the marketing-page minute.
Developers with Node installed: minutes to `npm install -g agent-device`, then a first `open` plus `snapshot -i` against a running simulator. QA engineers and agent builders embedding the TypeScript client should budget an afternoon for the client wiring, lock policy, and a first replay in CI.
Switching to or from Agent Device
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From manual mobile QA passes: record the flow once with --save-script, then replay it with `agent-device replay` instead of repeating taps by hand
- →From coordinate-based mobile automation: replace x/y taps with stable refs (@e2) or semantic selectors like `find role button click`
- →From browser-only agent stacks: keep Playwright or Puppeteer on the web side and add agent-device for the native app surface
- ↗To a hosted device farm: keep your .ad scripts as the flow definition and point execution at the farm's device inventory
- ↗To a GUI test recorder: export the recorded steps from your .ad script as the starting structure for the recorder
- ↗To a reporting-first test platform: feed replayed script results and captured screenshots into that platform's dashboard
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Agent Device”, and we withheld 5: 5 did not mention Agent Device. Showing the 1 we can prove is about Agent Device.
Official links
Featured Head-to-Head Comparisons
Agent Device vs Presto Voice
Choose Presto Voice if you run a QSR chain and want a turnkey voice AI to boost drive-thru revenue—its upselling engine and 95% autonomy rate are tailored for that. Pick Agent Device if you're a developer building AI agents that need to manipulate real iOS/Android apps via a lightweight, open-source CLI—it's free and excels at token-efficient UI snapshots.
Agent Device vs Spider Cloud
Spider Cloud and Agent Device serve fundamentally different domains: Spider Cloud extracts web data for AI agents, while Agent Device lets AI agents control mobile devices. If your need is web scraping for RAG or LLM context, choose Spider Cloud for its low-cost, high-volume API. If you need an AI agent to interact with native mobile apps, Agent Device's free, open-source CLI is the clear choice. They are complementary rather than competitors.
Agent Device vs Temporal Ai
If you need to build reliable, fault-tolerant AI agents that handle long-running processes and recover from failures, Temporal is your pick. If you want a free CLI to let AI agents natively control mobile devices, Agent Device is the go-to. They solve completely different problems; choose based on whether your bottleneck is execution durability or mobile device interaction.
Popular in Browser & Computer-Use Agents
Spider Cloud
Spider Cloud is a web scraping, crawling, and search API that streams live pages as markdown or JSON for AI agents and RAG pipelines.
OpenAgents
OpenAgents is an open-source language agent platform for data analysis, 200+ plugins and autonomous web browsing.
Frequently Asked Questions
Used Agent Device? Help shape our editorial sentiment research.