Skip to content
Agent Farm Register PC-0
STUDIO · CONTROL 14 SEP 2026

Self-hosted agent farm

Local agents.
Your PCs.

OpenBot is HQ on your phone. World is what the team builds. Eng ships PRs. VR Designer runs Blender by CLI. You approve merges and taste.

Start Phase 0 See the mesh
  • 4 studio PCs
  • API coding models
  • Tailscale mesh
  • ~$5–10/day soft cap

Blocks everything

Phase 0 — your one-time prep

0 / 6 done

  3. grokbot://app/v1/settings?id=local-execution
  4. grokbot://app/v1/settings?id=computers
  6. PC-0 is ready.

Optional now, required soon: Install Tailscale on PC-0 and your phone for private mesh access to OpenBot.

# Tailscale — install on PC-0 + phone, join same tailnet # https://tailscale.com/download

Locked decisions

Stop flipping. Execute.

Pain → fix is decided. The company shell is OpenBot. Paperclip stays deferred. Prod merges stay gated.

Why we’re doing this

  • Cursor / cloud capsLocal farm + API coding on your PCs
  • Multi-role teamNamed OpenBot agents, isolated computers
  • Phone accessOpenBot UI over Tailscale; watch / take-wheel
  • World / Quest faceProduct track; later diegetic agent status
  • Client bugs WA/TGOpenClaw/Hermes → Eng → PR → you

Stack locked

  • HQCopilotKit OpenBot on PC-0
  • CodingOpenHands / Aider + gh · API models
  • IngressOpenClaw or Hermes (not OpenBot WA)
  • ProductConsolider World / Quest
  • PaperclipDeferred
  • ProdYou approve — no unsupervised merges
  • BlenderCLI / headless Python on PC-3

Topology

The mesh

Phone and laptop reach OpenBot over Tailscale. Workers stay private. Nothing port-forwarded to the public internet.

Phone / laptop Tailscale You (approve) Merges · taste Client WA / TG OpenClaw / Hermes OpenBot HQ PC-0 · Docker Compose PC-1 Eng OpenHands · gh · PRs PC-2 Marketing VectCut · FFmpeg PC-3 VR Blender CLI · Unity

MVP start: PC-0 + PC-1 first → PC-3 VR → PC-2 Marketing

Hardware map

Four studio machines

~16GB RAM each, ≥1TB storage, gaming GPUs for Blender / Unity / FFmpeg. Start with two.

Day 0

PC-0 · Orchestrator

Docker Compose OpenBot + supervisor. Tailscale. Locked down — Docker socket on a dedicated trusted host.

  • OpenBot
  • Supervisor
  • Tailscale
Day 0–1

PC-1 · Eng worker

OpenHands / Aider, git, gh, repo sandboxes. Output = PRs only. You merge.

  • OpenHands
  • Aider
  • gh
Day 2–3

PC-2 · Marketing

VectCutAPI + FFmpeg chops. Skip Higgsfield for v1. Postiz channel linking when that track resumes.

  • VectCut
  • FFmpeg
  • Postiz later
After Eng

PC-3 · VR Designer

Blender CLI / headless Python. Unity Quest path. Daily “3 cool things” inspo digests on cheap models.

  • Blender CLI
  • Unity
  • Inspo digests

Roles

Who does what

Eng PC-1

Repo access, branches, PRs. Triggered by client tickets, your @mentions, CI failures. Notifies you when PR is ready. No auto-merge to Production day one.

Marketing PC-2

After Eng shell is alive. Content library → drafts → Postiz. VectCut + FFmpeg locked; skip heavy AI video gen for v1.

VR Designer PC-3

Headless Blender + Python. Digests X / YouTube VR / Blender culture. Helps Eng ship World + Quest assets. Taste stays with you.

OpenClaw / Hermes

WhatsApp / Telegram / later SMS → structured ticket → Eng. Day one: notify you first. Auto-reply to client later.

Chief of Staff

This chat. Orchestrates plan, spend discipline, and — once PCs are registered — remote install / ops with your approvals.

Failproof

How to…

Expandable runbooks. Exact enough to execute; placeholders where keys / hosts are yours.

OpenBot install overview Phase 1 · CoS + you
  1. After “PC-0 is ready.”, CoS installs Docker if needed on PC-0 (you approve each command).
  2. Clone a tagged OpenBot release — pin the tag; OpenBot is alpha.
  3. Compose up. Confirm Intelligence self-host / acceptable config (prefer free path).
  4. Auth: Google / Microsoft / Okta preferred, or OPENBOT_SINGLE_USER=true only for tightly controlled demo.
  5. Add model API key(s) with hard daily spend caps.
  6. Create bots: Eng, VR Designer (Marketing stub OK).
  7. Verify phone UI over Tailscale (chat + basic status).
# Placeholder — CoS runs on PC-0 after approval # git clone --branch vX.Y.Z https://github.com/CopilotKit/OpenBot.git # cd OpenBot && docker compose up -d
Eng loop: ticket → PR → you merge Phase 2
  1. Register PC-1 the same way as PC-0 (Grok Bot + Local execution + Computers + leave running).
  2. Install OpenHands / Aider + gh + repo sandboxes on PC-1.
  3. Wire Eng bot → PC-1 runner inside OpenBot.
  4. Test path: fake ticket → branch → PR → notify you in OpenBot → you merge.
  5. Client path later: WA/TG → OpenClaw/Hermes → Eng ticket (no unsupervised prod).
# On PC-1 (approved remote / local) gh auth status # Eng opens PR; you merge in GitHub or gh after review
Spend caps & model routing Keep the bill low

OpenBot software is free/MIT self-host. The bill is API tokens.

  • WA triage, digests, inspoCheap (Flash / mini / Haiku-class)
  • PR review, small fixes, glueMid
  • Hard Eng / Unity / WebXRFrontier (escalate)
  • Image / video gen v1Skip — VectCut + FFmpeg

Suggested day-one soft cap: ~$5–10/day total. Per-bot caps + ping you at limit. No unbounded retries.

# Soft policy reminder (set real caps in OpenBot admin) # DAILY_CAP_USD=10 # CHEAP_FOR=triage,digests,inspo # FRONTIER_FOR=hard_architecture,nasty_bugs
Security rules Non-negotiable
  • No public exposureDo not port-forward SSH, Docker socket, or OpenBot
  • CoS accessRegistered machines + local-tool approval only
  • MeshTailscale between four PCs + your phone
  • SecretsKeys in OpenBot admin; never paste private keys in chat
  • AlphaPin tagged OpenBot release; expect sharp edges

Cost control

High output, low bill

Four PCs ≈ $0 marginal software/hardware. Pay for tokens — and only when craft needs them.

DoDon’t
Cheap models for triage, digests, tweet skimsFrontier for “summarize 20 tweets”
Mid models for small PRs / Blender glueAlways-on agents with nothing to do
Frontier only for hard architecture / nasty bugsStack Cursor on-demand and OpenHands on same work
Batch VR inspo (1–2 digests/day)Live Twitter doomscroll loops
Hard per-bot / daily $ caps + ping at limitUnbounded “keep retrying until it works”
Local Blender / Unity / FFmpeg / VectCut on GPUsPay APIs for work your PCs already do

Execution order

Way forward

  1. Phase 0

    Your prep

    Register PC-0 in Grok Bot. Leave running. Message “PC-0 is ready.” Tailscale soon.

  2. Phase 1

    OpenBot MVP

    Docker + tagged OpenBot on PC-0. Auth, keys, spend caps. Eng + VR bots. Phone over Tailscale.

  3. Phase 2

    Eng coding loop

    PC-1 + OpenHands/Aider + gh. Fake ticket → PR → you merge.

  4. Phase 3

    VR Designer

    PC-3 Blender CLI, Unity Quest, daily inspo digest, first World/Quest assets.

  5. Phase 4

    Ingress + Marketing

    OpenClaw/Hermes WA/TG → Eng. PC-2 VectCut + FFmpeg. Postiz when ready.

  6. Phase 5–6

    World mirror · Paperclip if needed

    Diegetic agent status in Consolider World. Paperclip only if OpenBot weak on queues / spend.

Done when

Success criteria

Toggle as you hit each checkpoint. Saved in this browser (localStorage).

0 / 6 checkpoints

Names

Glossary

CopilotKit OpenBot
Self-hosted coworker platform. This is the HQ.
OpenClaw
Messaging ingress (WhatsApp/Telegram) — not the company OS.
Paperclip
Company/org job router — deferred.
Hermes
Agent/coding runtime family; Eng uses OpenHands/Aider practically.
Consolider World
Your 3D/VR CRM product (world.lutho.app).

Day one

Non-goals

  • Unsupervised Production deploys
  • 70B local coding models on 16GB boxes
  • Higgsfield / heavy AI video for Marketing v1
  • Replacing World with OpenBot as the product UI
  • Exposing the studio LAN to the internet
  • Standing up all four PCs before PC-0 + PC-1 work