<!-- https://zunder-design-preview.pages.dev/connect · Markdown version of the page -->

# Backtest it. Watch it. Then guard it.

Available now: replay and Watch, directly in your browser. Guard 1.0 will add order protection when it is released.

1. **Backtest** (in your browser · now): Replay your bot’s past under your rules.
2. **Watch** (in your browser · now): Judge every new trade live. Get warned.
3. **Guard** (with Guard 1.0 · waitlist): Run Guard in front of your bot. Block, not just warn.

## Step 1: Backtest. What would Guard have done with your bot?

Paste your bot’s public Hyperliquid address, or explore a sample below. Compare its real history with a replay behind your rules.

The samples are public Hyperliquid vaults (the first is the default):

- **Mostly passes** `0xe4be02d34bfa56815bb3fb0ab6308d67d3409b76`: +39.5% in the 90 days to 6 Oct 2026, through a 14.6% drawdown. Guard takes 27 of its 68 entries as they were, resizes 34 and refuses 7: +30.4%, 7.0% drawdown.
- **Deep swings** `0x78ab93343554d9b9fc7260f44844fad8f36d3d79`: −34.6% in the 90 days to 6 Oct 2026, through a 47.0% drawdown. Guard takes 7 of its 42 entries as they were, resizes 33 and refuses 2: +1.5%, 9.9% drawdown.
- **A liquidation** `0x3005fade4c0df5e1cd187d7062da359416f0eb8e`: +9.2% in the 90 days to 6 Oct 2026, through a 3.4% drawdown, liquidated once. Guard takes 1 of its 40 entries as they were, resizes 3 and refuses 36: +3.6%, 1.8% drawdown, no liquidation.

- runs entirely in your browser
- no wallet connection · no signature · no keys
- nothing to approve, nothing that can move funds
- we never see the address

### How to use it

1. Paste the Hyperliquid address of your bot. Only its public trade history is read.
2. Set your rules: leverage cap, loss at the stop, liquidation distance, position size, daily loss stop, drawdown halt, required stop.
3. Compare the two equity curves and the trades where Guard would have changed the outcome.

### What it shows

- Return over the window (30, 90 or 180 days; 90 by default), return per 1% of worst drawdown, worst drawdown, worst day and liquidations: behind Guard and as it happened.
- Equity over the window, both curves, with the periods halted by the daily loss stop or the drawdown halt shaded, and every liquidation marked.
- The trades that mattered: the largest differences between your bot and Guard.
- What the replay had to assume, listed under the result.

### How honest is this?

A replay is a what-if, not a promise. Skipping or shrinking a trade can change what your bot would have done next, and prices, fees and funding after a skipped trade are taken from your real history. Losses are capped at your stop only where your bot actually had one. Results include fees and funding as Hyperliquid recorded them.

## Step 2: Watch your bot live

Enter its address. Every new trade is judged against your rules the moment it happens, right in this tab.

- read-only · public data · no keys, no signature
- runs while this tab is open
- warns, cannot block: blocking needs Guard (step 3)

Streams your address’s public trades from Hyperliquid and judges them with Guard’s engine in your browser.

## Step 3: Guard (Coming with Guard 1.0 · not released yet)

Run Guard on the machine where your bot runs: pick your system (macOS, Linux, Windows or Docker); a server over SSH, Homebrew and one-click cloud are the other ways. Every command matches Guard's v1.0.0 release and works once it is published.

**macOS**

```
$ curl -fsSL https://zunder-design-preview.pages.dev/i | sh -s -- \
    --rules zr1_eyJ2IjoxLCJt…siKiJdfQ
# checks the release’s signature, installs, asks the rest here
# then start it: zunder-guard run --network paper
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**Linux**

```
$ curl -fsSL https://zunder-design-preview.pages.dev/i | sh -s -- \
    --rules zr1_eyJ2IjoxLCJt…siKiJdfQ
# checks the release’s signature, installs, asks the rest here
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**Windows**

```
$ & ([scriptblock]::Create((irm https://zunder-design-preview.pages.dev/i.ps1))) `
    -Rules zr1_eyJ2IjoxLCJt…siKiJdfQ
# checks the release’s signature, installs, asks the rest here
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**Docker**

```
# 1. guided setup: rules, account, mode and (testnet) the key, with hidden input
$ docker run -it --rm \
    -v zunder-guard:/data ghcr.io/zunderlabs/zunder-guard:v1.0.0 \
    init --interactive --rules zr1_eyJ2IjoxLCJt…siKiJdfQ
# 2. run it, reachable from this machine only
$ docker run -d --name zunder-guard --init --restart unless-stopped \
    -v zunder-guard:/data -e ZUNDER_GUARD_LISTEN=0.0.0.0:8547 \
    -p 127.0.0.1:8547:8547 ghcr.io/zunderlabs/zunder-guard:v1.0.0
# paper mode; testnet: add -e ZUNDER_GUARD_NETWORK=testnet to the second command
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**On a server (SSH)**

```
$ ssh -t you@your-server "curl -fsSL https://zunder-design-preview.pages.dev/i \
    | sh -s -- --rules zr1_eyJ2IjoxLCJt…siKiJdfQ"
# checks the release’s signature, installs, asks the rest on the server
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**Homebrew**

```
$ brew install zunderlabs/tap/zunder-guard
$ ZUNDER_GUARD_HOME="$(brew --prefix)/var/zunder-guard" \
    zunder-guard init --interactive \
    --rules zr1_eyJ2IjoxLCJt…siKiJdfQ
$ brew services start zunder-guard
# paper mode · listening on 127.0.0.1:8547 · v1.0.0
```

**One-click cloud**

```
Your own server, your own account:
  Fly.io · Render · Hetzner · DigitalOcean · AWS Tokyo
# your key is typed on your server, never sent to us
# settings and templates: the deploy wizard, “One-click”
```

Planned properties: run it where your bot runs; a Sigstore-signed release, checked before it installs; starts in paper mode; listens on 127.0.0.1 only.

### Point your bot at Guard (planned)

A few settings change: the URL, the key Guard gives your bot, isolated margin. Your bot keeps its own logic.

**ccxt**

```diff
  exchange = ccxt.hyperliquid({
-     "privateKey": API_WALLET_KEY,
+     "walletAddress": "0xYourAccount",
+     "privateKey": GUARD_CLIENT_KEY,  # from zunder-guard init
+     "sandbox": True,  # Guard accepts either signature
+     "urls": {"test": {"public": GUARD, "private": GUARD}},
+     "options": {"builderFee": False, "refSet": True},
  })
  # isolated margin; a stop on each entry, or Guard attaches one
```

**Freqtrade**

```diff
  "exchange": { "name": "hyperliquid",
-   "privateKey": "<api wallet key>",
+   "walletAddress": "0xYourAccount",
+   "privateKey": "<guard client key>",
+   "ccxt_config": { "sandbox": true,
+     "options": { "builderFee": false, "refSet": true },
+     "urls": { "test": { "public": "http://127.0.0.1:8547",
+                         "private": "http://127.0.0.1:8547" } } }
  },
+ "margin_mode": "isolated", "trading_mode": "futures"
```

**Python SDK**

```diff
  from hyperliquid.exchange import Exchange
- ex = Exchange(wallet, constants.MAINNET_API_URL)
+ ex = Exchange(guard_client, "http://127.0.0.1:8547",
+              account_address="0xYourAccount")
  # no trailing slash on the URL
```

**AI agent (MCP)**

```diff
  // claude_desktop_config.json
+ "mcpServers": { "zunder-guard": {
+   "command": "zunder-guard",
+   "args": ["mcp", "--key-file", "/path/to/mcp-client.key"] } }
  // key from: zunder-guard client add --out …; the agent can trade, never loosen a limit
```

Your bot gets a key issued by Guard. The real trading key stays inside Guard, so a compromised bot can never trade past your limits.

### Later: pair this page with your Guard (planned)

Type the code Guard printed. The monitor from step 2 then shows real decisions, and gains a kill switch. read-only by default · this site only; the page may pull the kill switch, never place an order.

Guard 1.0 is not out yet. Join the waitlist and we will tell you when the commands above work. [Join the waitlist](https://zunder-design-preview.pages.dev/#waitlist).