Every molt leaves a mark. Trace. Verify. Trust.

Clawprint is a tamper-evident audit trail for OpenClaw agent runs. It silently taps the gateway wire, capturing every trace a molt leaves behind — tool calls, outputs, lifecycle events — and seals them in a SHA-256 hash chain ledger. Replay sessions offline, inspect the evidence through the web dashboard, or query activity from Claude Desktop via MCP.

Not a proxy or firewall — Clawprint is a passive observer. It watches the wire, never touches it.

• 24/7 daemon mode — Continuous recording to a single ledger, auto-reconnect on disconnect
• MCP server — Claude Desktop integration for querying agent activity via natural language
• Security scanner — Detect destructive operations, prompt injection, privilege escalation, and anomalies
• Tamper-evident ledger — SHA-256 hash chain for every trace with integrity verification
• Secret redaction — Automatic redaction of API keys, tokens, JWTs, AWS keys, GitHub PATs, and credentials
• Offline replay — Reconstruct agent runs with event breakdowns, agent run sections, and chat reconstruction
• Web dashboard — Clean minimal dashboard with filtered/paginated traces, search, and bar charts
• CLI analytics — Colored output, event histograms, per-minute timeline, live recording spinner
• Run diffing — Compare two runs side-by-side with event kind breakdown
• Cross-platform — Prebuilt binaries for Linux, macOS, and Windows
• CI/CD — GitHub Actions for testing, linting, and automated release builds

# Install
curl -fsSL https://raw.githubusercontent.com/cyntrisec/clawprint/master/install.sh | bash

# Or build from source
cargo install --path .

# Run everything in one process (daemon + viewer + MCP)
clawprint serve --daemon --viewer --mcp --out ./clawprints

# Or start individual services
clawprint daemon --gateway ws://127.0.0.1:18789 --out ./clawprints
clawprint record --gateway ws://127.0.0.1:18789 --out ./clawprints

# Open the latest recording in browser
clawprint open --out ./clawprints

# Start MCP server for Claude Desktop
clawprint mcp --out ./clawprints

The serve command runs any combination of daemon, viewer, and MCP server in a single process. No more juggling multiple terminals.

# Run everything
clawprint serve --daemon --viewer --mcp --out ./clawprints

# Daemon + viewer only
clawprint serve --daemon --viewer --out ./clawprints

# Daemon + MCP only
clawprint serve --daemon --mcp --out ./clawprints

# Viewer only (browse existing recordings)
clawprint serve --viewer --out ./clawprints

Per-service bind addresses can be configured independently:

clawprint serve --daemon --viewer --mcp \
  --out ./clawprints \
  --viewer-host 10.0.0.1 --viewer-port 8080 \
  --mcp-host 10.0.0.1 --mcp-port 3000 \
  --token mysecret

All services share a single Ctrl+C handler for coordinated graceful shutdown.

For always-on agents like OpenClaw, use daemon mode. It records to a single continuous ledger and auto-reconnects on disconnect:

clawprint daemon --gateway ws://127.0.0.1:18789 --out ./clawprints

The daemon:

• Writes to a single ledger.sqlite that grows forever
• Automatically groups traces into agent conversation runs
• Reconnects with exponential backoff (1s, 2s, 4s... up to 60s)
• Shuts down gracefully on Ctrl+C / SIGTERM

# /etc/systemd/system/clawprint.service
[Unit]
Description=Clawprint Flight Recorder
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/clawprint serve --daemon --viewer --mcp --out /var/lib/clawprints --token mysecret
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now clawprint

Clawprint includes an MCP (Model Context Protocol) server so you can query agent activity directly from Claude Desktop using natural language.

Add to your Claude Desktop config (~/.claude/claude_desktop_config.json):

{
  "mcpServers": {
    "clawprint": {
      "command": "clawprint",
      "args": ["mcp", "--out", "/path/to/clawprints"]
    }
  }
}

Run the MCP server in SSE mode on the machine with your recordings:

clawprint mcp --transport sse --host 0.0.0.0 --port 3000 --token mysecret

Then on your remote machine, configure Claude Desktop. Since mcp-remote enforces HTTPS for non-localhost addresses, use --allow-http when connecting over a private network (e.g. WireGuard):

{
  "mcpServers": {
    "clawprint": {
      "command": "npx",
      "args": ["mcp-remote", "http://<host-ip>:3000/mcp", "--allow-http"]
    }
  }
}

Requires Node.js >= 20.18.1 on the client machine.

Once connected, Claude can use these tools:

Ask Claude things like:

• "What did my agent do in the last hour?"
• "Show me all tool calls from today"
• "Run a security check on the latest agent run"
• "Search for any file deletions"
• "Is the recording ledger intact?"

The built-in security scanner detects suspicious patterns in recorded traces:

Use via MCP: ask Claude "run a security check on today's activity"

Or programmatically via the clawprint::security::scan_events() API.

The view command launches a minimal web dashboard at http://127.0.0.1:8080:

• Dashboard page — Summary stats (impressions, traces, evidence), clickable run list with status badges and integrity indicators
• Run detail page — Evidence breakdown bar chart, filter buttons per trace kind, text search with debounce, paginated trace log (50/page), collapsible JSON payloads, color-coded trace cards

Each run is a self-contained "case file":

clawprints/
  runs/
    <run_id>/
      ledger.sqlite      # Events with SHA-256 hash chain (WAL mode, synchronous=FULL)
      artifacts/          # Compressed blobs (zstd)
        <hash_prefix>/<hash>.zst
      meta.json           # Run metadata + root hash
  ledger.sqlite           # Continuous ledger (daemon mode)

Events are stored with sequential IDs, timestamps, event kind, JSON payload, span/parent IDs, and hash chain fields (hash_prev, hash_self). Artifacts are deduplicated by content hash and compressed with Zstandard.

                                                        Storage
 OpenClaw       WebSocket        Clawprint             (SQLite + zstd)
 Gateway  <------------------>  Daemon/Recorder  --->  ledger.sqlite
           (observer role)         |
                                   |--- MCP Server ---> Claude Desktop
                                   |
                                   v
                              Web Viewer  <---  Browser
                              (Axum HTTP)       (Dashboard UI)

Clawprint auto-discovers the gateway auth token from ~/.openclaw/openclaw.json:

{
  "gateway": {
    "auth": {
      "token": "your-token-here"
    }
  }
}

Or pass it directly: clawprint record --token <token>

If Clawprint runs on a remote machine (AWS, Mac Mini, etc.) and you want to access the dashboard or MCP server from other devices, use WireGuard to create an encrypted private network. No ports are exposed to the public internet — only the WireGuard UDP port.

# Ubuntu/Debian
sudo apt install wireguard

# macOS
brew install wireguard-tools

# Windows — download from https://www.wireguard.com/install/

wg genkey | tee privatekey | wg pubkey > publickey

On Windows, the WireGuard GUI generates keys automatically when you add a new tunnel.

# /etc/wireguard/wg0.conf
[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = <server-private-key>

# macOS client
[Peer]
PublicKey = <client1-public-key>
AllowedIPs = 10.0.0.2/32

# Linux client
[Peer]
PublicKey = <client2-public-key>
AllowedIPs = 10.0.0.3/32

# Windows client
[Peer]
PublicKey = <client3-public-key>
AllowedIPs = 10.0.0.4/32

# /etc/wireguard/wg0.conf
[Interface]
Address = 10.0.0.2/24
PrivateKey = <client-private-key>

[Peer]
PublicKey = <server-public-key>
Endpoint = <server-public-ip>:51820
AllowedIPs = 10.0.0.0/24
PersistentKeepalive = 25

Open the WireGuard app, click Add Tunnel > Add empty tunnel, and paste:

[Interface]
Address = 10.0.0.4/24
DNS = 1.1.1.1

[Peer]
PublicKey = <server-public-key>
Endpoint = <server-public-ip>:51820
AllowedIPs = 10.0.0.0/24
PersistentKeepalive = 25

# Linux / macOS
sudo wg-quick up wg0

# Enable on boot
sudo systemctl enable wg-quick@wg0   # Linux
sudo brew services start wireguard    # macOS

On Windows, click Activate in the WireGuard GUI.

Only UDP port 51820 needs to be open on the server:

• AWS: Add an inbound security group rule for UDP 51820
• Mac Mini behind a router: Forward UDP 51820 to the Mac Mini's local IP

Bind to the WireGuard IP so Clawprint is only reachable through the tunnel:

# All-in-one: daemon + viewer + MCP bound to WireGuard interface
clawprint serve --daemon --viewer --mcp \
  --out ./clawprints \
  --viewer-host 10.0.0.1 --mcp-host 10.0.0.1 \
  --token mysecret

# Or run services individually
clawprint open --out ./clawprints --host 10.0.0.1 --token mysecret
clawprint mcp --transport sse --host 10.0.0.1 --port 3000 --token mysecret --out ./clawprints

From any client on the WireGuard network, access http://10.0.0.1:8080 in a browser or configure Claude Desktop:

{
  "mcpServers": {
    "clawprint": {
      "command": "npx",
      "args": ["mcp-remote", "http://10.0.0.1:3000/mcp", "--allow-http"]
    }
  }
}

Requires Node.js >= 20.18.1 on the client machine. The --allow-http flag is safe here since 10.0.0.1 is the private WireGuard interface (encrypted at the tunnel level).

sudo wg show    # Check handshake and transfer stats
ping 10.0.0.1   # Test connectivity

Claude Desktop requires npx mcp-remote as a stdio-to-SSE bridge. Since mcp-remote enforces HTTPS for non-localhost addresses, use --allow-http for private WireGuard IPs:

{
  "mcpServers": {
    "clawprint": {
      "command": "npx",
      "args": ["mcp-remote", "http://10.0.0.1:3000/mcp", "--allow-http"]
    }
  }
}

Requires Node.js >= 20.18.1 on the client machine. The --allow-http flag is safe here since traffic is encrypted at the WireGuard tunnel level.

Every trace includes a SHA-256 hash computed from its canonical form. Each trace's hash_prev points to the previous trace's hash_self, forming a tamper-evident chain. The verify command inspects the entire chain of evidence and reports INTACT or COMPROMISED.

$ clawprint verify --run <run_id> --out ./clawprints
  Inspecting chain of evidence for a1b2c3d4... INTACT
  Traces:    1234
  Root hash: 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08

curl -fsSL https://raw.githubusercontent.com/cyntrisec/clawprint/master/install.sh | bash

Downloads the latest release binary for your platform (Linux x86_64/aarch64, macOS Intel/Apple Silicon). Falls back to building from source if no binary is available.

Download clawprint-windows-x86_64.exe from the latest release and add it to your PATH.

cargo install --path .

Or manually:

cargo build --release
cp target/release/clawprint ~/.local/bin/

# Development
cargo build

# Release (optimized, LTO, stripped)
cargo build --release

# Run tests
cargo test

# Without web viewer or MCP features
cargo build --no-default-features

Releases are automated via GitHub Actions. To publish a new version:

git tag v0.1.0
git push origin v0.1.0

This builds binaries for all 5 platforms (Linux x86_64/aarch64, macOS Intel/Apple Silicon, Windows x86_64) and creates a GitHub Release with the assets attached.

MIT