Capabilities
Ask a target what works there before your agent relies on it. One command answers with a snapshot: each capability is available, degraded or unavailable, and anything short of available says why.
Try it autonom capabilities
Needs Autonom installed · a ready emulator, Android phone or Simulator
How it works
autonom capabilities describes a target, not a session. With a session it describes the session's target and fills in session_id. Without one it takes the target your flags name, or the only ready target, and session_id is null. That snapshot assumes nothing is attached yet, so network.capture is unavailable until a session attaches the capture proxy.
The answer is an autonom.provider/v1 snapshot inside the usual ok envelope. provider is local.android or local.ios. device_class is simulator for an Android emulator or an iOS Simulator, and physical for an Android phone. captured_at says when it was taken. capabilities lists every capability by name, in alphabetical order.
| State | What it means |
|---|---|
available | Works on this target now. |
degraded | Works in a weaker form. reason says how, for example a checkpoint that restores by replaying the flow from its start. |
unavailable | Does not work here. reason says why, for example a control that needs an emulator or Simulator. |
unknown | Allowed by the schema for a provider that cannot tell. The local Android and iOS providers in v0.36.1 always answer with one of the other three. |
A snapshot is a record, not a promise: it never changes after captured_at. A flow can name the capabilities it needs under requires, and flow run takes a fresh snapshot and checks them before the first step. A missing one stops the run with flow_requirements_unmet and nothing touches the device.
--probe adds a measurement. It reads the current screen once, so on iOS ui.accessibility and ui.input describe what was measured, not only which tools are installed. On Android the tree and input come from adb, so the answer is the same with or without it.
Examples
Every output here comes from Autonom's test emulator, a test Android phone and a test Simulator, so you can rerun it without a device. Reproduce these outputs, at the end of this section, has the exact commands.
See what an emulator can do
Goal: learn what your agent can rely on before it starts a long check.
- Ask the emulator.
No session is needed;
--serialnames the target.autonom capabilities --serial emulator-5554
You should see the snapshot, with each capability and its state.
What to look at. device_class is simulator, because an emulator can be reset and controlled from the host. checkpoint.create is degraded: a checkpoint restores by replaying the flow from its start. network.capture waits for a session to attach the capture proxy.
Show full output
Compare it with an Android phone
Goal: see what changes when the target is a phone instead of an emulator.
- Ask the phone.
The serial is the one
adb deviceslists for it.autonom capabilities --serial R5CT20ABCDE
You should see device_class change, and the emulator-only controls become unavailable.
What to look at. The screen, input, screenshots and logs work the same. Every simulator.* control, such as a simulated location, needs an emulator. A phone cannot be snapshotted, so a replay always starts from the beginning of the flow.
Measure the screen with --probe
Goal: tell an installed UI backend from one that can read this screen.
- Ask the Simulator without measuring.
The answer reflects the tools that are installed.
autonom capabilities --udid AAAAAAAA-1111-2222-3333-BBBBBBBBBBBB - Ask again with
--probe.Autonom reads the current screen once before it answers.
autonom capabilities --udid AAAAAAAA-1111-2222-3333-BBBBBBBBBBBB --probe
You should see ui.accessibility available first, then degraded once the screen was read.
What to look at. The idb backend is installed, so the first answer says available. The measured tree was empty, so --probe says degraded with the reason empty_accessibility_tree. On a real app that usually means its views carry no accessibility labels; Read and drive the screen explains what to do next.
Name the target when several are ready
Goal: see what your agent gets when it asks without naming a target.
- Ask with no target flags.
An emulator, a phone and a Simulator are ready, so Autonom will not pick one.
autonom capabilities
You should see one error object on stderr, with exit code 2.
What to look at. ambiguous_target lists the candidates. Pass one with --target, --serial or --udid, or narrow the list with --platform. Once a session owns a target, plain autonom capabilities describes that target.
Let a flow refuse a target that lacks a capability
Goal: stop a flow before its first step when the target cannot do what the flow needs.
- Name the capability in the flow.
This flow checks requests, so it needs the capture proxy.
schema: autonom.dev/flow/v1appId: com.example.appname: Checkout requestsrequires: capabilities: [network.capture]---- launchApp - Run it in a session without the proxy.
autonom flow run checkout.yaml
You should see the run refused with exit code 2, before the app launches.
What to look at. capability_details carries the snapshot entry for each missing capability, reason included. Attach the proxy with autonom network attach --i-understand-mitm, or run the flow on a target that has what it needs.
Reproduce these outputs
From the root of an Autonom checkout at tag v0.36.1 (commit ca2a280), in bash or zsh. The autonom function runs that checkout against its test doubles for adb, simctl and idb, so it needs no device, Xcode or idb. Session ids and times differ on every run.
Good to know
Ask before a long check, not after it fails. A snapshot costs one command. It tells your agent early that a phone has no simulated location, or that the proxy is not attached yet.
A snapshot never changes. Take a new one after you attach the proxy, start a session or switch targets;
captured_atsays which one you are reading.Use
--probeon iOS when the screen matters. Without it,ui.accessibilitysays whether idb is ready. With it, the answer is what Autonom measured on the current screen. While a session runs, a screen read from the last minute refines the plain snapshot too.An unknown capability name is refused early.
flow checkrejects a name underrequires.capabilitiesthat Autonom does not know, with the list of valid names, so a typo never reaches the device.Setup implies capabilities. A flow whose
setupsets a location, permissions, orientation, appearance or network also requires the matching capability, without listing it underrequires.Every run keeps its snapshot. A flow run records the snapshot it was checked against, and the agent report repeats it under
capabilities.
Reference
The command and the flags that pick its target.
| Command | What it does |
|---|---|
autonom capabilities | Prints the snapshot of the session's target, or of the only ready target when no session runs. |
autonom capabilities --probe | Reads the current screen once first, so the UI entries describe what was measured. |
--serial SERIAL | Picks an Android emulator or phone by its adb serial. |
--udid UDID | Picks an iOS Simulator by its UDID. |
--target TARGET | Picks a target by id, such as one of the candidates of ambiguous_target. |
--platform android|ios | Limits the choice to one platform. |
--session-id ID | Binds the command to one session when several run. |
The capabilities a snapshot lists.
| Capability | What it covers |
|---|---|
ui.accessibility | Reading the screen as a UI tree. |
ui.input | Taps, swipes, keys and typed text. |
screenshots, screen.stream | Screenshots, and the live view in the Mobile Canvas. |
logs | Device logs. |
network.capture | Requests through the capture proxy. Available once a session has attached it. |
checkpoint.create, checkpoint.restore | Saving and restoring a point in a flow. Degraded on an emulator or Simulator, where restoring replays the flow from its start; unavailable on a phone. |
simulator.location, simulator.permissions | Simulated location and permission changes. |
simulator.appearance, simulator.text_size, simulator.status_bar, simulator.battery, simulator.clipboard, simulator.biometric, simulator.keyboard | The simulator controls both platforms share, where the platform allows them. |
simulator.network, simulator.sms, simulator.call | Network shaping, text messages and calls: Android emulator only. |
simulator.push | Push notifications: iOS Simulator only. |
Android and iOS differences
Both providers answer with the same snapshot; the values differ with the platform and the kind of device.
| Capability | Android | iOS Simulator |
|---|---|---|
| Device class | simulator on an emulator, physical on a phone | simulator |
| UI tree and input | From adb; --probe changes nothing | From idb or XCUITest; --probe measures the screen |
| Checkpoints | Partly: degraded on an emulator, unavailable on a phone | Partly: degraded |
| Network, SMS and calls | Yes, on an emulator | No |
| Push | No | Yes |
| Keyboard preferences | No | Partly: applied at boot |
Next steps
You can see what a target supports before your agent relies on it.