# ZeroTrade Operator Quickstart

## What ZeroTrade is

ZeroTrade has two distinct surfaces:

- The public portal at `https://thegame.talktoai.org`
- The local node runtime that lives on the operator machine, mini PC, VPS, or Ubuntu server

The public portal is for buying, activation, downloads, docs, and updates.
The local node is where the paper, replay, and future live trading runtime actually runs.

If a customer buys the paid hosted website workspace instead of the self-hosted node, they use the portal account surface and encrypted API vault instead of this operator quickstart.

## What is implemented right now

- no-login node checkout and activation flow
- paid hosted website access with signup-code-gated account activation
- local node CLI via `zerotrade`
- local agent API on `127.0.0.1:8010`
- local browser panel on `http://127.0.0.1:8010/panel`
- paper, replay, and demo-safe runtime posture
- deterministic risk-core foundation
- advisory Oracle using local Ollama and optional BYOK OpenAI
- encrypted-at-rest strategy vault for installed presets
- mobile-friendly public status surface

## What is not finished yet

- full production broker coverage for all target markets
- full live trading rollout for ordinary users
- a complete strategy marketplace or polished strategy editor
- complete Telegram command automation by default

Treat the current system as a serious paper and operator foundation first.

## Recommended host profile

- minimum: 16 GB RAM, 64-bit CPU, SSD
- recommended: 32 GB RAM, Ryzen 7 or Ryzen 9 class CPU, NVMe SSD
- default local AI model for 16 GB class hosts: `gemma4:e2b`
- optional heavier local AI model: `gemma4:e4b`
- Ubuntu is the preferred production host

## Install on Ubuntu

Basic node install:

```bash
curl -fsSL https://thegame.talktoai.org/install | bash
```

Node install with local AI:

```bash
curl -fsSL https://thegame.talktoai.org/install | INSTALL_LOCAL_AI=true OLLAMA_MODEL=gemma4:e2b bash
```

Heavier local AI option:

```bash
curl -fsSL https://thegame.talktoai.org/install | INSTALL_LOCAL_AI=true OLLAMA_MODEL=gemma4:e4b bash
```

## Activate the node

After payment and order verification, use the issued values:

```bash
zerotrade activate-license --account-id <ACCOUNT_ID> --license-key <LICENSE_KEY>
sudo systemctl restart zerotrade-agent zerotrade-oracle
```

## Run the product from SSH

ZeroTrade is installed on the server or PC that runs the node.

From your home PC, SSH into that machine using either its domain or its server IP:

```bash
ssh ubuntu@example.com
# or
ssh ubuntu@serverIP
```

Open the terminal control surface:

```bash
zerotrade
```

If you want the shortest operator onboarding path:

```bash
zerotrade guide
```

Get the local access guide:

```bash
zerotrade access
```

The node API and panel are intentionally local-only by default. They bind to `127.0.0.1:8010`.

## Open the local browser panel from your own machine

This part is easy to misunderstand:

- `127.0.0.1:8010` is the panel on the server itself
- you do not open that directly over the public internet
- instead, you create an SSH tunnel from your home PC to the server
- once that tunnel is open, `http://127.0.0.1:8010/panel` works in the browser on your home PC because SSH forwards your local port to the server's local panel port
- if you type that browser URL before the SSH tunnel exists, it is normal for it not to reach the server panel
- the public site and the private node can live on the same Ubuntu server as long as the panel stays private

Create the SSH tunnel from your home PC:

```bash
ssh -L 8010:127.0.0.1:8010 ubuntu@example.com
# or
ssh -L 8010:127.0.0.1:8010 ubuntu@serverIP
```

Keep that SSH session open, then open this URL in the browser on your home PC:

```text
http://127.0.0.1:8010/panel
```

This is the cleanest way to inspect the local node panel without exposing it publicly.

## First commands to run

```bash
zerotrade
zerotrade guide
zerotrade doctor
zerotrade status
zerotrade panel
zerotrade mode set replay
zerotrade strategy catalog
zerotrade strategy install-preset sol_momentum_scout
```

## Paper execution checks

When you want to prove the deterministic paper execution lane:

```bash
zerotrade execution blotter
zerotrade execution positions
zerotrade execution draft --strategy-id sol_momentum_scout --symbol SOL-USD --venue paper-solana --side buy --quantity 1 --reference-price 145 --expected-edge-bps 60
zerotrade execution submit --strategy-id sol_momentum_scout --symbol SOL-USD --venue paper-solana --side buy --quantity 1 --reference-price 145 --expected-edge-bps 60
```

The paper execution rail is meant to prove draft, risk, fill, and blotter behavior before deeper live adapters are trusted.

## Adaptive strategy checks

When you want the node to run its sealed daily strategy review:

```bash
zerotrade strategy evolve-daily
zerotrade strategy evolution-log
```

In replay and paper posture the node can apply bounded daily variants automatically. In live posture it stages sealed candidates for review instead of silently rewriting the active live playbook.

## Strategy protection

Strategy presets are stored in the local strategy vault and encrypted at rest.

- this protects installed strategy payloads from sitting on disk in plain text
- it does not turn the product into magic or make reverse engineering impossible for a fully compromised host
- deterministic risk-core still decides whether orders are allowed
- AI can watch, rank, summarize, and explain, but cannot bypass the guardrail

## Safety posture

- start in `demo`, `replay`, or `paper`
- do not treat local AI as live execution authority
- do not expose the node panel publicly
- keep the browser panel behind SSH tunnel or another deliberate private access path
- only consider live mode after paper behavior is proven and the live rail is explicitly enabled