> ## Documentation Index
> Fetch the complete documentation index at: https://critiqor.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Started with Critiqor: Monitor OpenClaw in Four Steps

> Monitor your first OpenClaw session with Critiqor. Four commands: install, monitor, run, finalize — then your diagnosis dashboard opens automatically.

Critiqor wraps your OpenClaw session from start to finish: it creates a run, attaches its evidence plugin, launches OpenClaw, silently observes everything that happens, and — when you're done — generates a diagnosis and opens a local dashboard in your browser. The entire workflow runs through four commands and requires no manual configuration.

<Steps>
  <Step title="Install Critiqor">
    Install Critiqor from PyPI:

    ```bash theme={null}
    pip install critiqor
    ```

    This installs the `critiqor` CLI and the bundled OpenClaw plugin. No separate plugin setup is required.
  </Step>

  <Step title="Start monitoring">
    Start a monitored OpenClaw session:

    ```bash theme={null}
    critiqor monitor openclaw
    ```

    Critiqor runs through the following automatically before OpenClaw ever starts:

    * Generates a unique `run_id` (e.g. `run_001`) and creates a `runs/run_001/` directory
    * Writes an `active_session.json` file to track the in-progress session
    * Attaches the bundled OpenClaw evidence plugin
    * Initializes the runtime observer and begins capturing events
    * Launches `openclaw chat` in the same terminal as a supervised child process

    Because the observer starts before `openclaw chat` launches, every event from the very beginning of the session is captured.

    <Note>
      OpenClaw must be installed and available on your PATH for this command to work. Critiqor launches it via `openclaw chat` internally.
    </Note>
  </Step>

  <Step title="Use OpenClaw normally">
    The OpenClaw TUI opens in your terminal. Use it exactly as you normally would — send prompts, invoke tools, and interact with your agent. You do not need to change anything about how you work.

    While you interact with OpenClaw, Critiqor silently observes and captures:

    * Tool calls and tool outputs
    * Memory events
    * Retries and errors
    * Context and state transitions
    * Token usage
    * The full runtime event timeline

    When you're finished, exit the OpenClaw TUI as you normally would (e.g. `Ctrl+C` or the built-in exit command).
  </Step>

  <Step title="Finalize the session">
    After exiting OpenClaw, finalize the session to generate your diagnosis and open the dashboard:

    ```bash theme={null}
    critiqor finalize
    ```

    Critiqor will:

    1. Close the active session and stop the runtime observer
    2. Read the raw `session.json` evidence collected during the run
    3. Run the diagnosis engine — detecting failure modes, building the causal graph, calculating the trust score, and generating recommendations
    4. Write `diagnosis.json` alongside `session.json` in the run directory
    5. Start a local dashboard server on an available port
    6. Open the dashboard in your browser automatically at `http://127.0.0.1:<port>/?run_id=run_001`

    You'll see output similar to the following in your terminal:

    ```text theme={null}
    Stopping observer...
    Finalizing evidence...
    Generating diagnosis...
    Diagnosis saved: runs/run_001/diagnosis.json
    Starting local dashboard...
    Dashboard run: run_001
    Critiqor dashboard: http://127.0.0.1:<available-port>/?run_id=run_001
    ```

    <Note>
      Critiqor validates `diagnosis.json` before launching the dashboard. If the diagnosis is missing or invalid, dashboard launch is aborted and the CLI prints a clear recovery message instead of opening stale or default data.
    </Note>
  </Step>
</Steps>

## Files Created

After finalizing, your run artifacts are organized as follows:

```
runs/
  run_001/
    session.json    # raw runtime evidence (tool calls, events, timeline)
    diagnosis.json  # diagnosis, trust score, causal graph, recommendations
active_session.json # tracks the in-progress session (removed after finalize)
```

`session.json` is the complete structured runtime session — timeline events, tool activity, memory events, runtime metadata, and aggregate metrics. `diagnosis.json` is derived from that evidence and contains the trust score, primary failure mode, causal chain, severity, impact scores, and recommended fixes. The original evidence in `session.json` remains auditable and separate.

## What to Do Next

Once the dashboard opens, you'll see an **Overview** page with your trust score and a readiness verdict. From there you can:

* **Check the trust score** — a 0–100 reliability score weighted by the evidence Critiqor captured
* **Read the diagnosis** — the primary failure mode detected, its causal chain, and the recommended fix
* **Explore the Evidence view** — drill into the raw tool calls, outputs, memory events, retries, and the full execution trace
* **Review the causal graph** — a step-by-step explanation of why the session failed (if a failure was detected)

To revisit a past session or open a specific run's dashboard later, use:

```bash theme={null}
# List all completed runs with summaries
critiqor runs

# Reopen the dashboard for a specific run
critiqor dashboard run_001
```

For a full reference of all CLI commands and their options, see the [CLI Reference](/reference/cli/overview). To learn more about reading and navigating the dashboard, see the [Dashboard Guide](/guides/dashboard).