Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

Zero-to-one ideas: Harness Builder, Studios, sharing results, sharing a harness

dee053b2575a888
diff --git a/docs/plans/2026-09-17-001-zero-to-one-ideas.md b/docs/plans/2026-09-17-001-zero-to-one-ideas.md
new file mode 100644
index 000000000..e040df276
--- /dev/null
+++ b/docs/plans/2026-09-17-001-zero-to-one-ideas.md
@@ -0,0 +1,154 @@
+# Zero-to-one ideas: what Harness needs next
+
+Status: ideas, not yet plans · 2026-09-17
+Context: written after building the Harness Store end to end — 18 harnesses on a fresh machine, a store
+page per harness with real prompt → output examples, permission modes in New Harness. Each idea below
+says what it is, why it matters, what already exists to build on, and the open questions. Pick one, then
+turn it into a plan beside this file.
+
+---
+
+## 1. Harness Builder — a new harness from one sentence
+
+**What.** "A harness for KiCad." "For Unity." "For our Terraform repo." An agent writes the whole
+package — `harness.json`, toolchain setup and doctor, a viewer (or `viewer.use` of an existing one),
+`AGENTS.md` and skills, a starter template, store facts — then proves it: installs it on a fresh machine,
+runs a first prompt through it, captures the output as the package's first store examples, and offers to
+publish it.
+
+**Why.** Every harness in the store today was written by hand. The Builder turns the store from a
+catalogue we curate into a platform anyone can extend, and it is the most direct path to the long tail
+of domains (EDA, game engines, data tools, internal company tooling).
+
+**What exists.**
+- The package contract and its checker: `store/spec/`, `harness dsh check`, `cli/src/dsh/manifest.ts`.
+- A starter package: `store/starter/`.
+- The fresh-machine install recipe (`env -i HOME=<tmp>`, `store/tools/runtimes.sh` for Node, uv/Python,
+ micromamba) and the conversion of all 21 packages to it.
+- The showcase pipeline: a real run → a 1600×1000 picture of the viewer → `store/showcase/<name>/` →
+ `examples` in `store.json` → the store page.
+
+**Open questions.**
+- Where does a built harness live — a repository of the person's own (`store/registry/<owner>/<name>.json`
+ entry) or a local-only install until they publish?
+- How much of the proof is automatic before publishing is allowed (doctor passes, one prompt produced an
+ artifact, the viewer rendered it)?
+- Licensing and credit when the Builder wraps an existing open-source project, as the store's own
+ wrappers do (upstream name, author on the tile, THIRD_PARTY_NOTICES).
+
+---
+
+## 2. Studios — harnesses that hand work to each other
+
+**What.** One request that runs across several harnesses in one tab, each step's output becoming the
+next step's input: text-to-cad designs a part → Blender renders it → Remotion cuts a launch video →
+Marp builds the keynote. Every step is visible in its own viewer pane, and any step can be re-run.
+
+**Why.** It is the product's whole story in one demo, and something no single-agent tool can do: many
+specialised agents, each with its own toolchain and viewer, on one project.
+
+**What exists.**
+- Tabs that hold several agents and panes (swarms), viewer panes that follow a harness's verdict
+ artifact, and a verdict contract (`.harness/verdict.json`: ready, artifact, phases).
+- A first message on create (`agent_create`'s `prompt`), which is how a step would be started.
+
+**Open questions.**
+- The handoff: a shared project folder each harness reads from, or an explicit artifact passed by path?
+- Who orchestrates — a coordinating agent, or a declared pipeline (a "studio" manifest)?
+- How a failed or unready step (`ready: false`) holds the chain, and how a person steps in.
+
+---
+
+## 3. Share what you made
+
+**What.** One click turns a finished run — the prompt, a picture of the output, later a replay — into a
+public page, and optionally into a community example on that harness's store page.
+
+**Why.** The growth loop: store pages fill with real work by real people, and every shared page is an
+invitation to try the prompt.
+
+**What exists.** `examples` on store entries (`StoreExampleSchema`, `cli/src/dsh/registry.ts`), the store
+page that renders them, and the review/rating service in the control plane.
+
+**Open questions.** It needs the backend (not released yet). Moderation, attribution, and what a
+picture may show (paths, usernames, hostnames in viewer chrome — the showcase work had to check for
+exactly these).
+
+---
+
+## 4. Share a harness with someone
+
+Two steps, deliberately apart: read-only first, read-write only once the security model is designed.
+
+### Step 1 — read-only: "watch my harness"
+
+**What.** Bob sends Alice a link to one running harness. Alice sees what Bob sees — the agent's terminal
+as it streams, and the viewer pane (the 3D model, the board, the deck) — live, in her own app or a
+browser. She cannot type, click into the viewer in any way that changes it, or reach anything else on
+Bob's machine.
+
+**Why.** Pairing, reviews, demos, "look what it's doing" — the social moment of watching an agent work,
+without screen sharing.
+
+**What exists.**
+- The app already attaches to agents on other machines through the daemon, and the CLI terminates
+ end-to-end encryption for relayed machines (`cli/src/lib/e2ee/`, `harness link create/import/list`).
+- Terminal streams are framed and addressed per agent (`terminal_open`, binary frames with a stream id).
+
+**The security shape, even for read-only.**
+- **Scope is one agent, enforced by Bob's daemon**, not by Alice's UI: the share grants
+ `terminal_open` for that agent's stream and nothing else — no `agents_list`, no `fs_list_dir`, no
+ `agent_create`, no other agent's stream. A share is an allow-list of frame types and one agent id.
+- **No input path exists at the protocol level** for a read-only grant: input frames, resize, restart,
+ permission responses and question answers are refused by the daemon, whatever the client sends.
+- **Terminal output is sensitive.** It shows paths, environment dumps, tokens an agent printed, file
+ contents. Bob should see what a share exposes before sending it; consider redaction of known secret
+ shapes (the app already has `redactSecretsInText` for logs).
+- **Viewers are local web servers with their own write APIs** (a viewer can save notes, re-render,
+ trigger builds). A read-only share must not proxy them wholesale — either a snapshot/stream of what
+ the viewer shows, or a proxy that allows only safe GETs. This overlaps with the missing remote-viewer
+ forwarding (see Gaps).
+- **Revocable, expiring, visible.** A share has an expiry, Bob can end it at once, and Bob sees who is
+ watching right now.
+- **Identity.** Alice signs in; a share is to a person (or an org), not a bearer link anyone can
+ forward — or, if bearer links are allowed for demos, they are short-lived and read-only by
+ construction.
+
+### Step 2 — read-write: "work in my harness together"
+
+**What.** Alice can also type to the agent (and maybe drive the viewer), as a collaborator in Bob's
+harness.
+
+**Why it needs its own design: this is Alice on Bob's computer.** Anything that can type into the
+agent's terminal can run code as Bob's user, on Bob's machine:
+- An agent in an auto-approve mode runs the commands it is asked to run; Alice asking is enough.
+- Engine TUIs have shell escapes (Claude Code's `!` bash mode, for one) — raw keystrokes are a shell.
+- The agent's environment holds Bob's credentials: vendor logins, git credentials, SSH agent, cloud
+ CLIs, the keychain the agent can reach.
+- The workspace is a folder on Bob's disk, and the agent is not confined to it.
+
+**Directions to think through, not decisions.**
+- **Prompt-level input, not keystrokes.** Alice sends messages to the agent through a composer that
+ the daemon delivers as a prompt; raw terminal input stays Bob's.
+- **Permission mode caps.** A shared harness runs in Ask first (or Plan) for Alice's turns: every command
+ Alice's prompt causes needs Bob's approval, or at least Alice's own approval shown to Bob.
+- **Isolation.** Shared harnesses run in a sandbox or container with only the workspace mounted and no
+ access to Bob's credentials; the harness's toolchain comes with it.
+- **A driver's seat.** One person drives at a time; handing over is explicit; Bob can take it back or end
+ the session instantly.
+- **Audit.** Every input from Alice is recorded against her identity, visible to Bob.
+- **Explicit, per-session consent** from Bob, time-boxed.
+
+---
+
+## Gaps found on the way (not zero-to-one, but they will hurt soon)
+
+- **Viewers do not work across machines.** A harness running on another machine cannot show its viewer
+ pane in the app; `store/agents/godogen/README.md` names forwarding a viewer from a linked remote
+ machine as a platform requirement still to build. Harness is multi-machine by design, so this is a
+ core gap — and step 1 of sharing needs the same forwarding, safely.
+- **Installed harnesses never update.** `harness dsh` offers `list`, `install`, `check` and `remove`
+ (`cli/src/dsh/command.ts`) — no update. A fix to a package (today's RDKit verdict fix, the text-to-cad
+ Chromium setup) only reaches a machine that removes and reinstalls it. Needs: an installed package
+ knows its source commit, the catalog knows the latest, the store shows "Update", and an update keeps
+ workspaces working.