Argent review: an agentic CLI that lets an AI assistant drive iOS, Android and TV apps

What Argent actually solves for mobile teams

Mobile debugging is a loop of manual steps: build, launch, tap through to the screen that misbehaves, attach a profiler, read logs, repeat. Argent's premise is that an AI assistant can drive those steps itself if it is given a stable command surface. The README describes the toolkit as giving "your AI assistant direct control of iOS simulators, Android emulators and devices, TVs (Apple TV, Android TV, Fire TV) and Electron/Chromium apps", with the stated goal of tapping a button, profiling a screen or reproducing a bug "without leaving the CLI".

The audience is narrow but real. Teams already working in React Native get the most from it, because the README claims build, launch and iteration for React Native with "no extra setup". The TV and Electron targets widen that a little: a Fire TV app and a Chromium desktop build are driven through the same command surface, which matters if you ship the same product across those form factors. If your workflow is Xcode-only and you never script anything, the value proposition is weaker, because the whole point is handing control to an assistant that reads and writes commands.

The tool surface: interact, flows, visual regression, profiling

Argent is not one command but a set of capabilities the README groups into six areas. Interaction covers tap, swipe, gesture, typing and hardware buttons, plus D-pad on TV and mouse and keyboard on desktop. Flows let you "record a path once, replay it deterministically as a repro or smoke test", which is the part with the clearest engineering payoff: a recorded path is a reproducible artifact rather than a description of a bug.

Visual regression diffs a baseline against a live capture and the README says the diff is OCR- and font-aware, a detail that matters because naive pixel diffing flags text rendering changes as failures. Profiling is the broadest area: Hermes, React DevTools, Xcode Instruments and Perfetto, covering renders, CPU hotspots and hangs. Debugging exposes logs, network traffic from both fetch and native layers, JS evaluation, and the native and React trees.

The README suggests asking your assistant "What can Argent do?" to list every tool, which implies the tool list is discoverable at runtime rather than only in docs. That is a sensible design for an agent-facing product, since the assistant's context is the real interface.

Installing Argent and driving a first session

The README gives a single bootstrap command. It runs the latest published package and starts the initialisation flow; the comment notes the pnpm equivalent.

npx @swmansion/argent@latest init  # pnpm: pnpm dlx @swmansion/argent@latest init

After init, the CLI is the interface. Telemetry is on by default and the README documents the opt-out as a subcommand, so a privacy-conscious setup should run this before anything else:

argent telemetry disable

The README points to a separate installation page for the full procedure, so treat the init command as the entry point rather than the whole story. The repository layout also shows that the workspace pulls platform binaries at build time: package.json defines download:simulator-server, download:native-binaries and download:trace-processor scripts, and a pack:mcp:local script that chains those downloads with the iOS and Android binary builds. That tells you the distributed CLI depends on prebuilt per-platform executables, not on pure TypeScript. If you are building from source rather than installing the package, expect to run those download steps yourself.

Mixed licensing is the constraint that decides adoption

The Apache-2.0 label on the repository is only half the picture. The README states plainly that Argent uses a mixed licensing model: source code is Apache-2.0, while the per-platform simulator-server under bin/<platform>/simulator-server, the bin/darwin/ax-service executable and the .dylib files in native-devtools-ios are the intellectual property of Software Mansion S.A. and are "licensed solely for use within this project". Decompiling, reverse-engineering or redistributing them without written permission is prohibited.

For most application teams this changes nothing: you install the CLI and use it. For anyone who wants to vendor the tooling, ship it inside an internal platform, or audit the binary that touches their simulator, it changes a lot. You cannot treat Argent as an Apache-2.0 dependency in the ordinary sense, because part of what you run is not under that licence. The README does not document a source-only build path that avoids the proprietary binaries; the pack:mcp:local script in package.json downloads them. That is the sharpest limitation in the project, and it is a licensing one rather than a technical one.

Where Argent is the wrong tool

Argent assumes a running target. It controls simulators, emulators, physical devices, TVs and Electron apps, so it is not a substitute for tests that run without a device, and it is not a CI replacement for a headless unit suite. The README's flows feature is described as producing a repro or smoke test, which is a narrower claim than a full test framework: nothing in the README describes assertions, parallel execution or reporting.

There is also a platform assumption baked into the repository layout. The binary paths reference darwin and per-platform simulator-server builds, and the iOS tooling (Xcode Instruments, native-devtools-ios) is Apple-specific. The README lists Android emulators and devices as supported, so Android is not excluded, but the profiler integrations named are Hermes, React DevTools, Xcode Instruments and Perfetto, which means the depth of profiling differs by platform. If your product is a Flutter or native Android app with no React layer, several of the debugging surfaces (React trees, React DevTools) do not apply to you.

Finally, the README does not document rollback or version pinning behaviour for the init command, and it does not describe what happens when a device disconnects mid-flow. Those are the operational gaps a team should probe before making Argent part of a release process.

How it compares to Maestro and Appium

The closest comparison is Maestro, which also drives mobile apps through declarative flows and is aimed at reproducible UI automation. The difference in approach is who consumes the flow. Maestro flows are written by a human and run by a test runner; Argent's flows are recorded from an interaction and replayed, and the primary consumer is an AI assistant issuing commands. Argent also goes further into profiling and debugging than a UI automation tool normally does, exposing Hermes, Perfetto and Xcode Instruments alongside taps and swipes.

Appium sits at the other end: a long-established WebDriver-based automation protocol with a large ecosystem of language clients. Appium's model is a stable protocol with many drivers; Argent's model is a CLI surface designed for an agent to discover and call. If you need a protocol other teams already integrate against, Appium is the safer choice. If you want an assistant to open a simulator, tap through a screen, capture a baseline and pull a CPU profile in one session, Argent is built for exactly that and Appium is not.

Maintenance, releases and what to verify

The repository is not archived, and the last push was on 2026-09-24. Recent releases are frequent: v0.25.0 on 2026-09-09, v0.25.1 on 2026-09-15 and v0.25.2 on 2026-09-18. The version numbering is pre-1.0, so minor releases can carry breaking changes, and the release notes are the place to check before upgrading a pinned version.

Upgrade cost is mostly the binary download step. Because the CLI depends on per-platform simulator-server and native-devtools-ios artifacts, an upgrade is not purely a package version bump: the download scripts in package.json fetch matching binaries. Teams that vendor Argent into an internal image should pin the version and re-run the download steps deliberately rather than tracking latest.

On licensing, the practical point is that Apache-2.0 covers the TypeScript source in packages/, not the executables. If your legal review treats all dependencies as uniform, this repository will not fit that model. Read LICENSE.txt and the Privacy Notice linked from the README before distributing anything built on Argent. This is a description of what the README states, not legal advice.

Editorial conclusion

Adopt Argent if your team already runs React Native or native mobile builds in a CLI-driven workflow and wants an assistant to tap, profile and reproduce bugs without hand-driving a simulator. Do not adopt it if you need a fully open toolchain: the simulator-server and ax-service binaries are proprietary and licensed only for use inside this project, and decompiling or redistributing them is prohibited. Before committing, verify the Node version the CLI expects, run argent telemetry disable if your organisation requires it, and read LICENSE.txt to confirm the mixed licensing fits your distribution model.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. software-mansion/argent on GitHub