openring: Supervising OpenRig Fleets from the Outside In (Voice & Higher-Level Scenarios)

[smota]

While running multiple OpenRig topologies on my machine (often 5 rigs and ~18 seats across different codebases), I fell in love with how well the agents coordinate inside their seats. But managing the entire fleet from the outside was a different story: juggling terminal tabs, manually chaining rig ps, inspecting queues, and unblocking interactive prompts in tmux created unnecessary friction.

To solve this, I built openrig (packaged in tiny-skills): an installable skill that composes low-level rig CLI primitives into transactional, higher-level operational workflows (/openrig-fleet, /openrig-dispatch, /openrig-unblock, /openrig-watchdog-align, /openrig-handover).

By abstracting these operations to a higher plane, I unlocked a much friendlier, human-centric way to steer my agents: I now supervise my entire local fleet hands-free using natural voice workflows (like the OpenAI Voice interface) while the actual rigs run deterministically in tmux on my workstation.

---

1. The Problem: The Gap Between In-Seat Execution and Fleet Supervision

While operating multi-agent teams across my day-to-day projects, an operational asymmetry became apparent:

• Inside the seat: OpenRig’s in-seat skills (openrig-user, queue-handoff, mission-slice-sop) are world-class at keeping an individual agent oriented, handling custody, and stepping through tasks.
• Outside the seat: As the human orchestrator managing dozens of seats across multiple concurrent rigs (e.g. separate dev, PM, and kernel topologies), running micro-commands (rig ps, rig queue create, rig send, rig capture) manually in tmux creates cognitive overhead.
• The Goal: Provide a clean, outside-in control plane that translates high-level supervisory intent into atomic, safe OpenRig actions without breaking the restore-honesty rule or in-seat protocols.

---

2. The Solution: High-Level Scenarios Composed Over Native Primitives

openrig doesn’t replace or hide the native CLI—it preserves the full direct command surface while offerig 5 higher-level composed capabilities:

                  ┌────────────────────────────────────────────────────────┐
                  │       SUPERVISOR / VOICE INTERFACE (Outside-in)        │
                  │   "Audit the fleet", "Unblock dev seat", "Send task"   │
                  └───────────────────────────┬────────────────────────────┘
                                              │
                                              ▼
                  ┌────────────────────────────────────────────────────────┐
                  │           tiny-skills: /openrig Capabilities          │
                  │  /fleet • /dispatch • /unblock • /watchdog-align • ... │
                  └───────────────────────────┬────────────────────────────┘
                                              │
                      ┌───────────────────────┴───────────────────────┐
                      ▼                                               ▼
     [Direct CLI Commands Orchestrated]              [In-Seat Execution Unchanged]
   rig daemon • ps • queue • capture • send        developer • reviewer • architect
   (Restore-honesty, safe sends, no blind writes)  (queue-handoff, SOPs, local autonomy)

1. /openrig-fleet: One-shot executive audit (daemon status + doctor + ps --full + parked + stuck queues) that gives an instant health verdict across all local rigs.
2. /openrig-dispatch: Full transactional delegation (verify idle ➔ durable L3 queue create ➔ rig send ➔ rig capture proof of startup).
3. /openrig-unblock: Non-destructive screen capture and automated classification of blocked seats (CLI option prompts, y/n confirmation checks, runner errors, or auth barriers) followed by surgical key/text injection.
4. /openrig-watchdog-align: Strict implementation of OpenRig’s 3-level intervention stack (wake, refocus, alignment checkpoint) ensuring zero cadence pollution or unnecessary bureaucracy theater.
5. /openrig-handover: Safe context succession and seat rotation (snapshot ➔ queue rebind ➔ whoami / startup-proof ➔ unclaim).

---

3. The Value in Practice: Voice-Driven Fleet Management

The biggest breakthrough in my daily routine has been interface decoupling:

• The Setup: My agent rigs run locally on my Linux workstation with full toolchains and tmux sessions intact.
• The Workflow: I connect an external conversational agent equipped with openrig to the OpenAI Advanced Voice interface.
• The Experience: While walking away from my desk or making coffee, I can simply ask:

  "How is the dev team doing on the backend rig?" ➔ Triggers /openrig-fleet, digests the state, and reports back verbally.
  "Looks like seat 3 is stuck waiting on a prompt. Unblock it." ➔ Runs /openrig-unblock, inspects the screen buffer, injects the necessary input, and confirms motion.

---

4. Acknowledgments & Lineage

Thanks to @mvschwarz and the OpenRig team for the underlying primitives and skills that openrig builds upon: openrig-user, queue-handoff, refocusing, watchdog, seat-continuity-and-handover, and rig-lifecycle.

openrig is fully self-contained and open-source under tiny-skills:

npx skills add smota/tiny-skills --skill openrig

---

What’s Next

Having this outside-in supervision layer wasn't just about a nicer voice interface for myself—it was built to empower my autonomous Product Owner agent that steers topologies and builds software on my behalf.

To celebrate openrig and put this operational plane to work, a new kind of product purpose-built for OpenRig is currently in the oven. More on that soon!

[mvschwarz]

Thanks, @smota, for sharing openring, with a clear write-up of the gap you hit between work inside a seat and supervising a whole fleet (in your case about 5 rigs and 18 seats), and of how you compose rig commands into fleet-level workflows that you drive by voice.