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

# Quickstart

> Get Quint running in under 5 minutes

## Data Flow

```mermaid theme={null}
flowchart LR
    Agent["AI Agent"] -->|"actions"| Daemon["quint daemon"]
    Daemon -->|"events + sessions"| Cloud["api.quintai.dev"]
    Cloud -->|"query API"| Dashboard["cloud.quintai.dev"]
```

## Install the Endpoint Agent

<Steps>
  <Step title="Install the daemon">
    <CodeGroup>
      ```bash macOS (.pkg installer) theme={null}
      # Download and run the signed .pkg installer from your dashboard
      # Or use the install script:
      Install the signed `.pkg`. See [Installation](/operations/installation) for
      Gatekeeper approval and first-run verification. The installer is distributed
      to design partners and customers directly: hello@quintai.dev.
      ```
    </CodeGroup>

    Verify the install:

    ```bash theme={null}
    quint --version
    ```
  </Step>

  <Step title="Configure and enroll">
    Run setup with your deploy token (created in the dashboard or via API):

    ```bash theme={null}
    sudo quint setup --token qt_deploy_YOUR_TOKEN
    ```

    This writes the config to `/etc/quint/config.yaml`:

    ```yaml theme={null}
    api_url: https://api.quintai.dev
    token: qt_deploy_YOUR_TOKEN
    log_level: info
    ```
  </Step>

  <Step title="Start the daemon">
    The daemon runs as a `LaunchDaemon` managed by `launchd` — it starts automatically after setup and survives reboots. To manage it manually:

    ```bash theme={null}
    # Check status + daemon health
    quint status

    # Full diagnostic snapshot (JSON)
    quint diag

    # Panic button: temporarily disable the NE proxy
    sudo quint off
    sudo quint on

    # Follow the daemon log
    sudo tail -f /var/log/quint-proxy.log
    ```

    The daemon begins detecting AI agents on your machine and streaming events to the cloud API.
  </Step>

  <Step title="Use your AI agents normally">
    Start any AI agent as you normally would. Quint detects them automatically via code signing:

    ```bash theme={null}
    # Claude Code
    claude

    # Cursor, Windsurf, Cline -- just open the IDE
    # Quint detects agent processes at the OS level
    ```

    Open the dashboard at [cloud.quintai.dev](https://cloud.quintai.dev) to see sessions, events, and detected agents across your fleet.
  </Step>
</Steps>

***

## API Quick Test

Verify your deployment is working by hitting the API directly.

<Steps>
  <Step title="Health check (no auth required)">
    ```bash theme={null}
    curl https://api.quintai.dev/health
    ```

    ```json theme={null}
    {"status": "ok"}
    ```
  </Step>

  <Step title="Readiness check">
    ```bash theme={null}
    curl https://api.quintai.dev/ready
    ```

    ```json theme={null}
    {"status": "ready"}
    ```
  </Step>

  <Step title="List events (authenticated)">
    Use your deploy token or Supabase JWT:

    ```bash theme={null}
    curl https://api.quintai.dev/v1/events \
      -H "Authorization: Bearer qt_deploy_YOUR_TOKEN"
    ```

    Filter by agent, session, action type, or time range:

    ```bash theme={null}
    curl "https://api.quintai.dev/v1/events?action_type=PROCESS_EXEC&agent_id=claude-code" \
      -H "Authorization: Bearer qt_deploy_YOUR_TOKEN"
    ```
  </Step>

  <Step title="View sessions">
    ```bash theme={null}
    curl https://api.quintai.dev/v1/sessions \
      -H "Authorization: Bearer qt_deploy_YOUR_TOKEN"
    ```

    Get a specific session with its children and risk summary:

    ```bash theme={null}
    curl https://api.quintai.dev/v1/sessions/{session_id} \
      -H "Authorization: Bearer qt_deploy_YOUR_TOKEN"
    ```
  </Step>

  <Step title="Check 24h stats">
    ```bash theme={null}
    curl https://api.quintai.dev/v1/events/stats \
      -H "Authorization: Bearer qt_deploy_YOUR_TOKEN"
    ```
  </Step>
</Steps>

## Deploy Token Management

Deploy tokens are how machines authenticate with the cloud API. Create them from the dashboard or via the API:

```bash theme={null}
# Create a new deploy token
curl -X POST https://api.quintai.dev/v1/deploy-tokens \
  -H "Authorization: Bearer YOUR_SUPABASE_JWT" \
  -H "Content-Type: application/json" \
  -d '{"name": "dev-machine-01"}'

# List existing tokens
curl https://api.quintai.dev/v1/deploy-tokens \
  -H "Authorization: Bearer YOUR_SUPABASE_JWT"
```

Deploy tokens use the `qt_deploy_` prefix and are SHA-256 hashed before storage. The raw token is shown only once at creation time.

## What Gets Captured

When an AI agent runs on a machine with Quint installed, the daemon captures:

| Action Type       | Example                                          |
| ----------------- | ------------------------------------------------ |
| `PROCESS_EXEC`    | Agent spawns `git commit`, `npm install`, `curl` |
| `FILE_READ`       | Agent reads source code, config files, `.env`    |
| `FILE_WRITE`      | Agent modifies code, creates files               |
| `FILE_DELETE`     | Agent removes files                              |
| `NETWORK_CONNECT` | Agent makes outbound network connections         |

Each event includes the `tool_name` (binary basename), `arguments` (process args), `session_id` (UUID v5), and the detected `agent_id`.

## Configuration

The daemon config lives at `/etc/quint/config.yaml`:

```yaml theme={null}
api_url: https://api.quintai.dev
token: qt_deploy_YOUR_TOKEN
log_level: info    # debug, info, warn, error
```