Agentic dev for the G2 — across a whole fleet, not one busy laptop.

One backend. Three ways in. Everything private but one door.

The browser talks only to the fleet backend (fleet-cc) on an always-on home-lab server — the one piece that never sleeps, idling at ~25 W on the tailnet — which proxies into each box over private tunnels. Three ways to use a live box: overview (parked boxes stay cold; armed ones show a live glasses thumbnail), cockpit (drive one live — glasses-first panes, deeper controls one tap away), and phone (your phone becomes the box's client). Temporary *.sprites.app URLs are a separate static-build lane; the live relay stays private.

flowchart TB
  classDef you fill:#0e1622,stroke:#7ad3ff,color:#dbeeff,stroke-width:1px;
  classDef cc fill:#0c1a10,stroke:#4dd58a,color:#dff5e6,stroke-width:1.2px;
  classDef box fill:#1a1408,stroke:#ffb454,color:#ffe7c2,stroke-width:1px;
  classDef edge fill:#1a0e12,stroke:#ff8798,color:#ffd9df,stroke-width:1px;

  BR["💻 PC browser · 📱 mobile PWA<br/>overview · cockpit"]:::you
  PH["📱 phone + 👓 G2 glasses — Even Hub app"]:::you

  subgraph PC["fleet-cc backend · home-lab server · 24/7 on the tailnet"]
    direction LR
    OV["overview"]:::cc
    CKP["cockpit<br/>render + real input"]:::cc
    PHL["phone lane<br/>origin + relay-bridge"]:::cc
  end

  TS["tailscale serve<br/>per box · tailnet-private"]:::edge

  subgraph FLEET["3 primary boxes · public app box · scratch + lab boxes on demand"]
    direction LR
    A["ocuclaw-a"]:::box
    B["ocuclaw-b"]:::box
    C["ocuclaw-c"]:::box
    P["public app box"]:::box
  end

  BR --> OV
  BR --> CKP
  PH --> TS --> PHL
  OV -.->|"status poll"| FLEET
  CKP ==>|"proxy tunnels"| FLEET
  PHL ==>|"proxy tunnels"| FLEET

Hand a box a task. It writes, builds, tests, reviews, and pushes the branch.

This is where the fleet earns its keep. Dispatch a self-contained task and the box runs the whole cycle on its own, detached — it survives your disconnect. Fire several at once across the fleet and walk away: different branches, no shared state, no waiting. You come back to finished branches and DONE mail. Codex and Claude are both headless dispatch engines, each cross-reviewed by the other one on the box, so every DONE carries a second opinion and a review.txt — and when the box exercised the simulator, an agent-recorded evidence clip lands in its gallery, so you can watch the feature actually run before you fetch and open the PR. Every DONE also carries a harness signature — one that arrives without it is quarantined, not counted.

flowchart TB
  classDef you fill:#0e1622,stroke:#7ad3ff,color:#dbeeff,stroke-width:1px;
  classDef box fill:#1a1408,stroke:#ffb454,color:#ffe7c2,stroke-width:1px;
  classDef cc fill:#0c1a10,stroke:#4dd58a,color:#dff5e6,stroke-width:1.2px;

  T["your task<br/>theory / prompt"]:::you --> FO["dispatch · codex or claude<br/>fan out across the fleet"]:::cc
  FO --> A["ocuclaw-a"]:::box
  FO --> B["ocuclaw-b"]:::box
  FO --> C["ocuclaw-c"]:::box
  A & B & C --> L

  subgraph L["self-driving loop · per box · detached"]
    direction LR
    S1["sync trunk"] --> S2["agent writes code"] --> S3["build"] --> S4["G2 sim validate"] --> S5["cross-engine autoreview"] --> G{"clean?"}
    G -->|no| S2
    G -->|yes| S6["push branch<br/>+ DONE mail"]
  end

  S6 --> PR["you: git fetch → review → open / merge PR"]:::you

Spin up as many boxes as you want. Near-zero cost while they sleep.

Built on

The fleet rides on Sprites, Fly's stateful-sandbox platform. Each box is a hardware-isolated Firecracker microVM with a persistent filesystem — a real Linux computer that's still there, exactly as you left it, the moment it wakes. Live copy-on-write checkpoints land in around 300 ms, a recently-parked box restores and reconnects in under a second — a fully cold one is back in a second or two, services restarting themselves — and an idle box hibernates at near-zero cost. Sprites is purpose-built to run AI agents — which is exactly what each box does — so you keep as many as you like, parked cold, and only pay for the seconds one is actually working.

Every box is a complete, isolated OcuClaw stack.

A standard-spec Sprite (8 vCPU · 2–16 GB autoscaling memory · 100 GB disk) running its own OpenClaw and Hermes Agent gateways & relays, G2 simulator, and a dev server for the OcuClaw app itself. Everything binds to loopback and is reached over private tunnels; one standing public box fronts the static app build, and temporary *.sprites.app doors open — and are torn down with the box — when a build must reach someone off the tailnet. The G2 sim runs headless under a virtual display — the same simulator as the host, no GPU needed.

Your phone becomes the box — glasses UI, touch, and voice.

A phone arm stops the box's sim and hands the phone the role of the single client. The home-lab server serves the box at a private per-box address; Fleet CC shows a QR or direct Even Hub link over the tailnet. Real input, real voice, real agent — just not on the public internet.

That's one of two ways onto your phone. The other: install the control center itself as a PWA and drive the whole fleet from your phone's browser — overview, cockpit, fullscreen glasses, milestone pushes, and per-box galleries of screenshots and evidence clips.

Run the whole fleet by asking — the ocuclaw-fleet skill.

Behind all of this is a stack of precise commands. The ocuclaw-fleet skill puts a natural-language front on them: you describe the work — a smoke test, a feature with full E2E coverage, a branch on real G2 — and it picks the right verbs, runs them, and reports back. One terminal does it all — and the same thing works from your phone, since the always-on home-lab server answers natural language too. Reversible asks just run; anything that costs money or destroys state stops to confirm first.

Under the hood it's an intent router: your sentence maps to the right verbs — status, dispatch, sim-arm, login-status, setup-codex, park — run against spritectl, fleet-cc, and mail, then summarized back to you.

Know what every box is running — and keep it recoverable.

Each box is baked from a branch and saved as a checkpoint — that checkpoint is what parks and wakes again in moments. Fleet CC keeps branch, commit, auth, gateway, and telemetry health one tap away on every box, so freshness is visible before you spend a long rebuild.