> ## Snouty CLI

> How to use the Snouty CLI to launch and debug tests

> Fetch the complete documentation index at: https://antithesis.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

---

The Snouty CLI lets you or your agents interact with Antithesis from your terminal. You can launch test runs, view the results, validate your system setup, read docs, and more. Agents should only use Snouty in tandem with the [Antithesis skills](https://antithesis.com/docs/ai/overview/#antithesis-skills-for-agents).

This page walks you through setting up Snouty and introduces some of the core features.

For the full docs, see [GitHub](https://github.com/antithesishq/snouty).

## Requirements

To use Snouty, you'll need:

- Docker or Podman.
- Docker Compose v2. Snouty drives either the standalone docker-compose binary or the Docker Compose CLI plugin bundled with Docker Desktop/Engine, whichever it finds on your PATH. Note that podman-compose is no longer supported.
  - Linux: Install Docker Compose or check your package manager.
  - macOS: Install Docker Desktop (includes Compose v2) or run `brew install docker-compose`.
- An Antithesis API key.

To launch tests, you’ll also need a system that's ready to run in Antithesis. See our [setup guide](/docs/getting_started/setup_guide/docker_compose/) for step-by-step instructions how to do this, or use our [`antithesis-setup`](/docs/ai/skills/#set-your-system-up-to-test-in-antithesis) skill.

## Install Snouty CLI

The recommended way to install Snouty CLI is to use our official installer:

```
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/antithesishq/snouty/releases/latest/download/snouty-installer.sh | sh
```

This allows you to update with `snouty update` later.

For full installation options, see [GitHub](https://github.com/antithesishq/snouty#install-snouty).

## Authenticate

To use Snouty CLI, you'll need to provide your Antithesis API key, tenant name and repository as environment variables:

```
export ANTITHESIS_API_KEY="<your-key>"
export ANTITHESIS_TENANT="<your-tenant>"
export ANTITHESIS_REPOSITORY="us-central1-docker.pkg.dev/<your-project>/<your-repo>"
```

Run `snouty doctor` to confirm you're set up correctly.

## Using Snouty CLI

You're now ready to try Snouty. Here are a few commands to get you started.

You can add `--help` to all Snouty commands to get help on command options and examples of how to use them.

### Read our docs

The `snouty docs` command lets you navigate through the Antithesis docs and view pages. As a first test of Snouty, try viewing a tree of contents for the docs:

```
snouty docs tree
```

For more options, run:

```
snouty docs --help
```

### Validate your system setup

Use `snouty validate` to check that your local setup is configured correctly to run in Antithesis. Give `snouty validate` the path to the config directory containing your `docker-compose.yaml` file (if you use Docker Compose) or your `manifests/` subdirectory (Kubernetes):

```
snouty validate <./path/to/config>
```

Snouty will then check your config:

- Docker Compose: runs `docker compose` locally (or `docker-compose` if you use Podman) and watches for the “set up complete” event. Then validates the structure of any [test commands](https://antithesis.com/docs/product/test_templates/test_composer_reference/). If you
- Kubernetes: performs static analysis of the manifests.

### Launch a test run

Once you’re happy with your config, you’re ready to launch an Antithesis test with `snouty launch`.

The simplest way is to use the `--config` flag to point Snouty at the local config directory that contains your `docker-compose.yaml` file:

```
 snouty launch --webhook basic_test --config <./path/to/config> \
   --test-name "<my-test>" \
   --description "example test" \
   --duration 30 \
   --recipients "team@example.com"
```

`snouty launch` pushes all images in your `docker-compose` file, so make sure you've built all required images before launching. If you define `build` alongside `image` in `docker-compose`, you can build and launch by running `docker compose build` followed by the `snouty launch` command.

If you’re using Docker Compose, Snouty also pins the current image tag, to ensure Antithesis runs exactly what you tested locally.

If you’d prefer to manage images yourself, you can use the `--config-image` flag instead and provide a pre-built image directly.

### Inspect your test runs

To see recent test runs, run:

```
snouty runs list
```

You should see your current run in the list.

To see details for a given run, use:

```
snouty runs show <run_id>
```

To see build logs for a given run, use:

```
snouty runs build-logs <run_id>
```

### Understand your test results

You can use Snouty to investigate your test results. For example, to get information on what properties passed and failed, use the `properties` subcommand:

```
snouty runs properties  <run-id>
```

Add the `--details` flag to see specific examples and counterexamples for each property. For a given example, you can then get the logs for the timeline leading up to the moment of that example:

```
snouty runs logs <run-id> <input-hash> <vtime>
```

To search events in a run, use:

```
snouty runs events <run_id> <query>
```

### Launch a debugging session

To start a [multiverse debugging](/docs/product/debugging/simple_mvd/) session, use:

```
snouty debug
```