# Your first check

Canonical URL: https://autonom.yatsuk.me/docs/first-check/

Install Autonom, point your agent at a Simulator or emulator, and get back a screenshot and a journal of what it did.

**Try it**

```sh
autonom tour
```

**Needs** [a Mac with Xcode, or the Android SDK](https://autonom.yatsuk.me/docs/install/index.md#differences) · [git, Python 3.11 and Node 20.11 or later](https://autonom.yatsuk.me/docs/install/index.md#how) · [Claude Code, Codex, Grok or another agent that loads skills](https://autonom.yatsuk.me/docs/skills/index.md)

## Where Autonom runs

Pick one target for this check. The same commands work on both.

- [iOS Simulator](https://autonom.yatsuk.me/docs/first-check/index.md#setup-ios-boot): Your agent boots the Simulator it picks. (Mac with Xcode)
- [Android emulator](https://autonom.yatsuk.me/docs/first-check/index.md#setup-android-boot): You boot an emulator from one of your AVDs. (Android SDK)

## Run your first check

Steps 1 to 5 happen in your terminal. From step 6 your agent does the work.

### 1. Install Autonom

Clone the repository, step into it and run the installer. Tick your agent in the checklist so it gets the skills. [Install](https://autonom.yatsuk.me/docs/install/index.md) covers every option.

```sh
git clone https://github.com/aiatsuk/autonom
cd autonom
./install.sh
```

### 2. Ask what this machine can do

Each capability says whether it is ready, and anything missing comes with the command that installs it.

```sh
autonom doctor
```

### 3. Take the tour

Start a new agent session so it loads the skills. Then read the tour: what Autonom has, the usual workflow and the targets on this machine.

```sh
autonom tour
```

### 4. Have a target ready

**iOS Simulator.** List the Simulators Xcode has. Your agent boots the one it picks when it starts its session.

```sh
xcrun simctl list devices available
```

**Android emulator.** Start one and wait for it to boot. Swap in an AVD name from `autonom devices`.

```sh
autonom devices boot --avd Pixel_9
```

### 5. Watch the tour walk

It walks three screens into Settings, takes a screenshot after each step and writes an HTML report. It boots a target if none is running.

```sh
autonom tour --run
```

Open the file named in `report_html` in your browser: each step with its screenshot, the UI hierarchy and the device log.

*Output of autonom tour --run: example output; your values will differ*

```
{
  "ok": true,
  "mode": "run",
  …
  "run": {
    "status": "passed",
    …
    "report_html": "…/flows/fr_…/report.html",
    …
  }
}
```

### 6. Give your agent one sentence

In the agent session from step 3, say what to check. Swap in a button and a screen from your app.

*Prompt to give your agent*

```
Check that tapping Sign in with Email opens the sign-in screen, bring back before and after screenshots, and leave the session open.
```

Your agent starts a [session](https://autonom.yatsuk.me/docs/sessions/index.md) on one target, reads the screen, taps by label as [Read and drive the screen](https://autonom.yatsuk.me/docs/screen/index.md) shows, and takes the [screenshots](https://autonom.yatsuk.me/docs/evidence/index.md).

### 7. Read what it did

The journal lists every command your agent ran and every note it left, in order.

```sh
autonom journal
```

*Output of autonom journal*

```
{
  "ok": true,
  "count": 5,
  …
      "verb": "screenshot",
  …
      "verb": "ui tap",
  …
      "text": "Sign in with Email opens the email sign-in screen"
  …
  "journal": "…/sessions/s_…/journal.ndjson"
}
```

Here the agent started the session, took the before screenshot, tapped, took the after screenshot and left a note: five entries.

### 8. Close the session

Stopping frees the target for the next check. The session folder and its journal stay on disk.

```sh
autonom session stop
```

**What done looks like.**

- **Journal:** `journal.ndjson` in the session folder, one entry per command or note.
- **Evidence:** a before and an after screenshot of the screen you named.
- **Report:** `report.html` from the tour walk, one screenshot per step.

### Reproduce these outputs

The journal output comes from Autonom's fake Android device, run as below from the root of an Autonom checkout at tag v0.36.1 (commit ca2a280) in bash or zsh. Ids, times and paths differ on every run. The tour output needs a real device and is an example.

*Script that reproduces the outputs*

```sh
export AUTONOM_HOME=/tmp/first-check/.autonom AUTONOM_FAKE_STATE=/tmp/first-check/fake-state.json
rm -rf /tmp/first-check && mkdir -p /tmp/first-check
echo "{\"ui_dump\": \"$PWD/tests/fixtures/woolbox/android_sign_in.xml\"}" > $AUTONOM_FAKE_STATE
autonom() { python3 scripts/autonom.py --adb tests/fakes/fake_adb.py "$@"; }
autonom session start --serial emulator-5554 --app-id com.example.app
autonom screenshot --label before
autonom ui tap --desc "Sign in with Email" --mode exact
autonom screenshot --label after
autonom note add "Sign in with Email opens the email sign-in screen"
autonom journal
autonom session stop
```

## Next steps

Your agent can now run a check and bring back what it saw.

- [Sessions and targets](https://autonom.yatsuk.me/docs/sessions/index.md): Own one device at a time and read every step back from the journal.
- [Read and drive the screen](https://autonom.yatsuk.me/docs/screen/index.md): Find and tap by what an element says.
- [Evidence](https://autonom.yatsuk.me/docs/evidence/index.md): Take screenshots, recordings and logs that prove a change.
- [Flows](https://autonom.yatsuk.me/docs/flows/index.md): Save the check as a file and replay it after every change.