"I just bought a Seed."
Here's every step to a sensing home.

Find your 2.4 GHz network name

ESP32-S3 and C6 nodes only see 2.4 GHz; the C5 is the dual-band exception. If your router broadcasts one combined name, that's fine — but if 2.4 and 5 GHz have separate names, note the 2.4 GHz one. Bonus for C6 nodes: if your router supports WiFi 6 (802.11ax) on 2.4 GHz, enable it — the C6 then captures 242-tone high-fidelity CSI instead of 64-tone (4× the spectral detail). (And if you're wondering why your laptop's far fancier WiFi can't just do the sensing itself: every WiFi chip computes the needed CSI internally, but only the ESP32's maker exposes it — your OS keeps that door locked, which is why these little boards exist at all.)

Reserve IP addresses

In your router's DHCP settings, reserve a fixed IP for the machine that will run the sensing server (your laptop or the V0). The nodes are provisioned with this exact IP — if it changes, every node goes silent and you'll think the hardware died. Reserve the Seed's IP too while you're there.

Open the firewall port

The nodes stream to UDP 5005 on the sensing-server machine. macOS will prompt to allow it; on Linux check ufw; on Windows allow the app through Defender Firewall.

The 30-second demo (Docker — recommended)

docker run -p 3000:3000 -p 3001:3001 ruvnet/wifi-densepose:latest
# then open  http://localhost:3000  in your browser

You'll see a Three.js view with a 3D body skeleton, signal heatmap, phase plot and a vitals panel — all from synthetic CSI. The image is multi-arch (Intel/AMD + Apple Silicon).

Verify with the API — your first "it works" moment

curl http://localhost:3000/health
# Expected: {"status":"ok","source":"simulated","clients":0}
curl http://localhost:3000/api/v1/sensing/latest   # latest frame
curl http://localhost:3000/api/v1/vital-signs      # breathing + heart rate
curl http://localhost:3000/api/v1/pose/current     # 17 COCO keypoints

Building from source instead? (V0, or you want the latest)

git clone https://github.com/ruvnet/RuView.git
cd RuView/v2
cargo build --release                              # Rust 1.85+ recommended
cargo test --workspace --no-default-features       # optional: runs 1,400+ tests
# binary lands at  target/release/sensing-server

Port gotcha that bites everyone: Docker publishes 3000/3001, but the source binary defaults to 8080/8765. Running from source, pass the ports and UI path explicitly: --http-port 3000 --ws-port 3001 --ui-path ../ui.

The basic provision — one command per node

python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "YourPassword" \
  --target-ip 192.168.1.20 --node-id 1

--target-ip is the reserved IP of the sensing-server machine from phase 02. --node-id must be unique per node (1, 2, 3…7) — it's the only way the server tells your nodes apart; there is no discovery handshake. Re-running the script merges new settings, it doesn't wipe old ones.

Multi-node array: give each node a TDM slot

So nodes take turns transmitting instead of jamming each other:

python firmware/esp32-csi-node/provision.py --port COM7 --tdm-slot 0 --tdm-total 7
python firmware/esp32-csi-node/provision.py --port COM8 --tdm-slot 1 --tdm-total 7
# …and so on through slot 6 for a 7-node array

Optional but recommended: on-device vitals (Tier 2)

python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "YourPassword" --target-ip 192.168.1.20 \
  --edge-tier 2

Tier 2 makes each node compute presence, breathing, heart-rate, motion and fall flags on the chip (~33 KB RAM) and stream them alongside raw CSI — this is also what the Seed ingests in phase 09.

Mesh authentication — not provisionable yet

Mesh beacon authentication (HMAC-SHA256, ADR-032) exists in the firmware but has no provisioning flag yet — skip this; it is not user-configurable today.

Confirm packets are arriving at all

sudo tcpdump -ni any udp port 5005   # expect a steady packet stream from each node's IP

Restart the server in ESP32 mode

# Docker:
docker run --rm -e CSI_SOURCE=esp32 \
  -p 3000:3000 -p 3001:3001 -p 5005:5005/udp \
  ruvnet/wifi-densepose:latest

# From source (e.g. on the V0):
./target/release/sensing-server --source esp32 --udp-port 5005 \
  --http-port 3000 --ws-port 3001 --ui-path ../ui

Only one process can own UDP 5005. If you ran a standalone aggregator for testing, stop it first — the sensing server is the aggregator behind the dashboard, API and WebSocket.

Check every node showed up

curl http://localhost:3000/health            # "source" should no longer say simulated
curl http://localhost:3000/api/v1/nodes      # every node-id you provisioned, with RSSI + freshness
curl http://localhost:3000/api/v1/sensing/latest

Open the two dashboards

The Observatory auto-detects the live server: its HUD badge flips from DEMO to LIVE. That badge is your single source of truth — if it says DEMO, you're looking at canned data, not your home.

Leave the room, then run

wifi-densepose calibrate --udp-port 5005 --duration-s 60 --output baseline.bin   # you must NOT be in the room

The CLI ships in the RuView build (wifi-densepose-cli crate). On a V0 appliance you can instead press Calibrate on its dashboard at http://cognitum-v0:9000. Pets count as "not empty" — shut the cat out.

Know when to redo it

Recalibrate after: moving furniture, moving/adding any node, or when room-status reports baseline drift. It's deliberate that this never happens automatically — the system can't verify the room is empty by itself, and a baseline captured with someone in the room silently poisons everything downstream.

Guided enrollment — the system coaches you through 8 anchors (~4 min)

wifi-densepose enroll --room-id living-room
#   → "Stand still in view of the sensor…"  [✓ anchor accepted: coherence 0.91]
#   → "Sit down…"                            [✗ low SNR, retrying]
#   …walk, lie down, leave the room, etc. — 8 anchor poses total

Each anchor has a quality gate — if your WiFi was noisy during one, it just asks again. Do this once per room.

Train the specialist bank

wifi-densepose train-room --enrollment ./enrollment.json --output ./room-bank.json

Instead of one big model, RuView trains six small statistical specialists calibrated to your room — breathing, heartbeat, restlessness, posture, presence and anomaly. All six always train (there's no flag to pick a subset). They run in microseconds, fully on-device.

Confirm — and learn this status command, you'll use it forever

wifi-densepose room-status --bank ./room-bank.json
#   baseline: fresh (drift 0.04 < 0.20)
#   breathing  ✓ trained  conf p50 0.88
#   heartbeat  ✓ trained  conf p50 0.71
#   posture    ✓ 3 prototypes (stand/sit/lie)
#   anomaly ✓ · presence ✓ · restlessness ✓

Pair with the Seed over USB (once)

# Plug the Seed into your laptop via USB — it appears as a network device at 169.254.42.1
curl -sk -X POST https://169.254.42.1:8443/api/v1/pair/window     # opens a 30-second pairing window
curl -sk -X POST https://169.254.42.1:8443/api/v1/pair \
  -H 'Content-Type: application/json' -d '{"client_name":"my-laptop"}'
# SAVE THE RETURNED TOKEN — it is shown exactly once

Pairing is USB-only by design — nobody on your WiFi can pair with your Seed.

Provision the nodes' feature stream (UDP 5006 — separate from the CSI stream)

python firmware/esp32-csi-node/provision.py --port COM9 \
  --ssid "YourWiFi" --password "secret" \
  --target-ip 192.168.1.20 --target-port 5006 --node-id 1

--target-ip here is your laptop (where the bridge runs) — not the Seed. The bridge is the middleman; current limitation is that it runs on a host machine, not on the Seed itself. Nodes need --edge-tier 2 (phase 05) to produce the feature packets.

Run the bridge

export SEED_TOKEN="your-pairing-token"
python scripts/seed_csi_bridge.py \
  --seed-url https://169.254.42.1:8443 --token "$SEED_TOKEN" \
  --udp-port 5006 --batch-size 10 --validate

Watch the memory grow — and maintain it

python scripts/seed_csi_bridge.py --token "$SEED_TOKEN" --stats     # vector counts, ingest rate
python scripts/seed_csi_bridge.py --token "$SEED_TOKEN" --compact   # run periodically — Seed works best under ~100K vectors

From here, AI assistants (Claude, etc.) can query your home's sensing history through the Seed's MCP proxy — "was anyone in the living room at 3am?" becomes an answerable question, with a cryptographic audit trail behind the answer.