---
title: "Runs & Outputs"
canonical: https://trickest.com/docs/developer-tools/cli/runs
description: "Execute workflows, watch progress, manage run records, and read node outputs (stdout/stderr, files) from the CLI."
---

# Runs & Outputs

The `run` family executes workflows and manages run records; the `output` family
reads results back out. Both operate on your **active workflow context** and default
to the **latest run** unless you specify one.

<Note>
Need a workflow active first: `trickest workflow use <name-or-id>`. Run-scoped
output commands default to the most recent run; pass `--run <id>` to target another.
</Note>

## `trickest run`

| Subcommand | Description |
|---|---|
| `run execute [target]` | Execute the workflow (or a single node) |
| `run ls` | List runs for the current workflow |
| `run get <run-id>` | Run details + per-node statuses |
| `run watch\|status <run-id>` | Watch a run live until completion |
| `run stop <run-id>` | Stop a running execution |
| `run retry <run-id>` | Retry a failed run |
| `run rm <run-id>` | Remove a run record |
| `run output\|outputs <run-id> <node>` | Output files for a node in a run |
| `run output-content\|cat <output-id>` | Print an output file's content |

### `run execute`

```bash
trickest run execute                       # run the whole active workflow
trickest run execute --watch               # run and stream progress
trickest run execute --async               # start and return immediately
trickest run execute httpx --downstream    # run one node and everything after it
trickest run execute --set domain=example.com --set threads=50
```

| Flag | Description |
|---|---|
| `--fleet <name>` | Fleet to execute on |
| `--watch` | Stream execution progress live |
| `--no-wait` / `--async` | Start the run and return immediately |
| `--dry` | Preview the execution plan without running |
| `--timeout <duration>` | Auto-stop after e.g. `30m`, `1h` — **client-side**, so it requires `--watch` (the CLI stays attached and stops the run; the backend does not enforce a run timeout) |
| `--downstream` | When running a single target, also run nodes downstream of it |
| `--set <key=value>` | Override an input value (repeatable) |
| `--node <name>` | Execute a single node (alias for the positional target) |

### `run ls`

```bash
trickest run ls
```
```json
[{"id":"72e345d6-…","status":"COMPLETED","created":"2026-05-26T16:16:21Z","finished":"","fleet":""}]
```

| Flag | Description |
|---|---|
| `--limit <n>` | Max runs to show (default 20) |
| `--status <status>` | Filter: `PENDING`, `RUNNING`, `COMPLETED`, `FAILED`, `CANCELLED`, `STOPPED`, `ERROR`, `PARTIAL_SUCCESS`, `SCHEDULED`, `STOPPING` |

```bash
trickest run ls --status FAILED --limit 5
```

### `run get` & `run watch`

```bash
trickest run get 72e345d6-…
```
```json
{
  "id": "72e345d6-…",
  "status": "COMPLETED",
  "fleet": "0ca38cb7-…",
  "created": "2026-05-26T16:16:21Z",
  "nodes": [{"name":"airixss","status":"SUCCEEDED"}]
}
```

```bash
trickest run watch 72e345d6-…    # block and stream until the run finishes
```

### Manage runs

```bash
trickest run stop 72e345d6-…
trickest run retry 72e345d6-… --watch
trickest run rm 72e345d6-… --force
```

## `trickest output`

Read node results from a run. `--run` defaults to the latest run.

| Subcommand | Description |
|---|---|
| `output ls [node]` | List output files per node |
| `output get <node>` | Summary: status, stdout preview, stderr |
| `output stdout <node>` | Raw stdout (pipe-friendly) |
| `output stderr <node>` | Raw stderr (pipe-friendly) |
| `output tail <node>` | Live-tail stdout |
| `output pull <node> [file]` | Download output files |
| `output mount` | Materialize run outputs as real files |

### `output ls`

```bash
trickest output ls --run 72e345d6-…
```
```json
[{"node":"airixss","status":"SUCCEEDED","files":1}]
```

### Reading logs

```bash
trickest output get httpx                  # status + stdout preview + stderr
trickest output stdout httpx --all         # entire stdout
trickest output stdout httpx --tail 50     # last 50 lines
trickest output stderr httpx
trickest output tail httpx --follow        # stream while the run is RUNNING
```

`stdout`/`stderr` print raw text so you can pipe them:

```bash
trickest output stdout subfinder --all | sort -u | wc -l
```

| Command | Notable flags |
|---|---|
| `output stdout` / `stderr` | `--run <id>`, `--tail <n>`, `--all` |
| `output tail` | `--run <id>`, `--follow`, `-n, --lines <n>` |

### Downloading files

```bash
trickest output pull httpx                       # download this node's output
trickest output pull httpx results.txt           # a specific file
trickest output pull httpx --all -o ./out/       # everything into a directory
```

| Flag | Description |
|---|---|
| `--run <run-id>` | Target run (default latest) |
| `-o, --output <path>` | Destination file or directory |
| `--all` | Download all output files |

### `output mount`

Materialize a run's outputs as real files in the sandbox filesystem — handy when an
agent wants to process results with normal shell tools:

```bash
trickest output mount                       # current effective outputs → /trickest/sandbox/outputs/
trickest output mount --run 72e345d6-…      # a specific run → /trickest/sandbox/runs/<id>/
trickest output mount -o /tmp/results       # custom destination
```

## Recipe: run and collect

```bash
trickest workflow use "Discovery"
RUN=$(trickest run execute --async | jq -r '.id')
trickest run watch "$RUN"
trickest output ls --run "$RUN"
trickest output pull httpx --all -o ./discovery-results/
```

## Related

<CardGroup cols={2}>
  <Card title="Schedules" icon="clock" href="/docs/developer-tools/cli/schedules">
    Run workflows automatically on a recurring schedule.
  </Card>
  <Card title="Graph Analysis" icon="sitemap" href="/docs/developer-tools/cli/graph">
    Validate the DAG before you execute.
  </Card>
</CardGroup>

---
_Markdown source of https://trickest.com/docs/developer-tools/cli/runs._