repo github.com View on GitHub ↗

Nimbalyst — Visual Workbench for Supervising Coding Agents

TL;DR

Nimbalyst (MIT, ~1000★, TypeScript/Electron monorepo, v0.66.x) is a free, local-first visual workspace and session manager for driving coding agents — Codex and Claude Code, plus Opencode/Copilot in alpha. Its whole reason to exist is Agent Supervision: it makes agent output legible (approve/reject/annotate agent changes as red/green WYSIWYG diffs across markdown, mockups, Mermaid, Excalidraw, CSV, data models, and Monaco code), lets you run and track a fleet of parallel sessions (kanban, search/resume, link sessions↔︎files), and routes your attention to the agents that need you — including async review from a mobile app ("which agents need you, which are still working"). It stores state and workflow in open plain files (markdown + slash commands on disk/git), not an opaque DB. Should you care? As a product it is one team's tooling, not a source of principles — but it is a concrete, load-bearing second witness that the human-oversight problem building-effective-agents held back is real enough to build an entire IDE around, which is why it promotes Agent Supervision from a held theme to its own concept. Worth a look if you supervise multiple agents and feel the review-bandwidth bottleneck; skip if you want architectural guidance rather than a workbench.

What it is / how it is organized

A repo triaged at altitude — what it is, how it's structured, what to take from it — not a per-file reading:

What: a cross-platform desktop app (Electron) plus a native iOS app that acts as a visual editor and agent session manager. You edit documents in WYSIWYG while coding agents work alongside you, and you approve their changes visually.
Shape: an npm-workspaces monorepo. Load-bearing packages: packages/electron (desktop app), packages/ios (SwiftUI), packages/runtime (cross-platform AI/sync/Lexical editor services), packages/collab-protocol (wire format for the sync server), packages/extension-sdk + packages/extensions (pluggable editors), plus cli, android, browser-extension, marketplace, opencode-plugin.
Extension model: every editor — even the built-ins — goes through the same EditorHost contract, so custom file-type editors are first-class (Astro editor, visual git log, mindmap, slides, 3D object editor cited as examples).
Notable seams: the collaboration sync server (wss://sync.nimbalyst.com) is a separate Cloudflare-Worker project; clients only carry the wire protocol. The repo ships its own .claude/ (agents, rules, commands) and a posthog-analyses/ folder that treats product analytics (time-to-first-value, retention, slash-command usage) as its own eval surface. Telemetry is anonymous/PostHog with an explicit no-PII, no-content policy.
Not concept-worthy here: the docs tree is enormous (~90 files) and mostly implementation guidance; reading it per-file is an on-demand deep-research burst, not this.

Concepts introduced

Agent Supervision — new page. The operator's workbench for keeping a human in control of a fleet of semi-autonomous agents when review bandwidth is the bottleneck: legible diff approval, parallel-session/fleet management, and attention routing. Framed as HCI for agents — the inverse of the ACI.

Held, not dropped (themes the capture touches that don't warrant their own page yet — spin out on demand):

Open/plain-file storage as agent-interop substrate — "content and status in markdown, workflow in slash commands, plain files on disk or git." Deeply firehose-aligned (markdown is truth) and folded into Agent Supervision as a claim; promote to its own concept if a second source frames open storage as an interoperability standard rather than a product choice.
Agent-vendor-agnostic tooling — one workbench over Codex, Claude Code, Opencode, Copilot. Held as an observation about the emerging "harness-over-many-agents" layer; promote if a capture argues vendor-neutrality as a design principle.
Pluggable-editor / EditorHost extension architecture — a software-engineering pattern (uniform host contract for first-class extensions), not an LLMOps concept; held.
Product analytics as a product-eval surface — posthog-analyses/ measuring AI-feature adoption, time-to-first-value, retention. Interesting as "evals of the product, not the model"; held as evidence, could link to the evals spine if a source formalizes it.
Async / mobile agent review — replying to agents by text/voice, swipe-to-approve diffs, push-notification-driven resumption. Folded into Agent Supervision's attention-routing lever; the mobile-specific UX is held.

Key claims

A visual workbench over coding agents exists to solve human oversight at fleet scale — legible diff approval + parallel-session management + attention routing. (observation — Agent Supervision) — the product's entire framing is that supervising agents, not generating code, is the hard part.
Rendering agent changes as accept/reject/annotate diffs (red/green WYSIWYG) across many artifact types is what makes review fast enough to keep a human in the loop. (best practice — Agent Supervision) — context: human-in-the-loop over file-mutating agents; the diff representation is tuned per artifact (code vs. mockup vs. data model).
Surface which agents need you vs. which are still working, so blocked/idle agents are visible without polling — including from mobile. (best practice — Agent Supervision) — context: supervising many parallel sessions; attention routing is the tractability lever.
Store agent state/status in open plain formats (markdown + slash commands, files on disk/git) rather than an opaque app DB. (best practice — Agent Supervision) — context: workbenches where portability, git-diffability, and transparency matter.
These are agents, not workflows — autonomous sessions the human steers — so the tooling question is oversight, not orchestration. (observation — Workflows vs Agents) — the capture is a concrete instance of the autonomous-agent branch, wrapped in human checkpoints.
Designing the human→agent interface is a distinct problem from designing the agent→tool interface (ACI). (observation — Agent-Computer Interface (ACI)) — Nimbalyst is HCI for agents; the ACI is the mirror-image interface, and both merit deliberate design.

Why this `builds_on` (and where it corroborates)

The dominant stance is builds_on, not novel, because the capture does not open an unattached region — it promotes a theme the graph explicitly held back. The Building Effective Agents distillate parked "human-in-the-loop checkpoints & stopping conditions" inside Workflows vs Agents with the note that "a 'human oversight' concept could spin out if more sources converge." Nimbalyst is that convergence: an independent team built an entire IDE around human oversight of agent fleets. That second witness is what justifies spinning out Agent Supervision as its own concept and adding the oversight claim back to Workflows vs Agents.

Two secondary threads (recorded as backlinks, not duplicated concepts):

Inversion of the ACI. Agent-Computer Interface (ACI) is the agent's interface to its tools (agent→world). Nimbalyst is the human's interface to its agents (human→fleet). Same discipline — invest in the interface — applied to the opposite direction; noted as HCI for agents.
Transparency / simplicity corroboration. Nimbalyst's "open storage, plain files, show the diff" is Agentic Simplicity's transparency principle instantiated in a workbench — an independent product choosing legibility and no-lock-in over a managed black box.

No contradicts tension surfaced: this is a product embodiment of the agent-architecture region, complementary to it, not in conflict.