Products — the knowledge-product pipeline

The Products view is a knowledge-product factory. You bring a thesis and a corpus of raw material — reports, research, transcripts, notes — and a staged agent pipeline researches, outlines, refines, and finishes a two-component knowledge product: a dense agent-facing knowledge set an AI executes from, plus a human-facing manual (PDF) a person reads.

The pipeline is operator-directed by design. Agents do the reading, extraction, and writing; a local engine does everything deterministic — paths, IDs, status, file staging, export; and you review and dispatch at every stage boundary. Nothing advances because a timer fired.

Products is an Ultra surface — see Tiers: Pro & Ultra. On Pro the view stays visible with a lock and an upgrade note.

The view at a glance

A persistent left sidebar lists every product and drives which one the stage tabs operate on. The tab bar reads as the pipeline: Research → Scope → Drafts, plus a Registry tab that tables all products across the pipeline.

The lifecycle in one line: create → sight the material → research → the scope workshop → package and export.

Create a product

1. Click New in the product sidebar.
2. Name the product, write the seed thesis (what this product argues and for whom), and pick the seed files — the raw material the pipeline will work from.
3. Save. The product appears in the sidebar and the Research tab becomes its dispatch surface.

An existing product can also serve as a template: Use as template in the Registry pre-fills a new product with the source's thesis, outline, and seed files.

Research — build the knowledge base

The Research tab is a sequence of dispatch cards, run top to bottom. Each dispatch accumulates artifacts rather than overwriting, so you can re-run any step as the material grows.

1. Sight. The sighter reads every seed file and produces a structured topic index — what material exists, where, about what. Everything downstream navigates by this map instead of re-reading the corpus.
2. Compose. The composition scout reads the sighted material plus your thesis and proposes a foundation outline. The first run populates the working outline; later runs accumulate alternatives you can adopt.
3. Research. Dispatch focused research passes. Each run targets one of three scopes — a single section, a general cross-section pass, or the outstanding-research backlog — and produces a build-ready, de-duplicated research note in the product's own voice. Researchers also maintain a shared gap ledger at the product root, so what is still missing is always visible (and dispatchable) per section.
4. Generate alpha. When the notes cover the outline, this step stages canonical per-section files mechanically and dispatches an auditor that writes a consolidated product overview — thesis, goals, cross-section ownership, duplication findings. That overview plus the full outline is what opens the Scope workshop.

Scope — the section workshop

The Scope tab is the human-in-the-loop heart of the pipeline. It lists every section with its current artifact state, and you work the sections to final:

• Refine a section: dispatch the refiner with the section's research note, any reference files you select, and your instructions. It transforms notes about the section into the near-final section itself — dense, complete prose — and writes a new revision each time, never editing in place.
• Finalize a section: the finalizer applies the auditor's cross-section ownership map, scrubs off-voice wording, and produces the final agent-facing section.
• Close gaps: sections flagged as thin can get a targeted scope research pass without leaving the tab.
• Re-architect the outline from here if the product's shape needs to change mid-flight.
• Roll over when the section set is done — staging both components into the draft area for packaging.

Drafts — package and export

By the time a product reaches the Drafts tab, the writing is done; this stage packages:

• Review the deliverables — the agent-facing set (read-only) and the human-facing per-section documents (editable, with inline image previews).
• Final touch-up — re-dispatch the human-facing author per section to add images or refine wording before the PDF is built.
• Cover image — generate the product cover.
• Package & Export — build the human-facing PDF (images placed), and optionally export the agent-facing set as MDX or PDF alongside it.

Everything the pipeline produces is ordinary files in your workspace — the export step assembles, it does not hide anything.

Registry

The Registry tab is the cross-product table: every product with status, lane, and section progress, filterable and sortable, with per-product actions — open, re-research, refine scope, resume drafting, use as template.

Who runs each stage

The pipeline is agent work end to end, so which model runs a stage is the pipeline's real cost dial — and it is a control the product carries rather than something you accept as given. It lives in one collapsible panel in the Research tab, positioned before the first dispatch because that is the only moment the choice is actionable.

Three levels, resolved narrowest-first:

Points worth knowing before you touch it:

• Inheriting is a real state, not an unset one. A stage showing an inherited value keeps following its parent; saving the panel without changing that stage does not silently pin it. There is always a visible reset back to inherit.
• Fan-out stages are the ones that matter. Most stages are one run per dispatch. Sighting runs once per batch of seed files and drafting runs once per section, so the matrix shows a run count beside those two — a model choice there is multiplied.
• A per-dispatch override applies to the whole job, every stage inside it, and is deliberately styled as a one-time control rather than a setting.
• The same panel also picks the agent CLI for a stage. Claude is the documented path and is what an unconfigured product resolves to; the choice between engines is covered under choosing an agent engine.

The cover image is not in this matrix — it is an image-generation call with its own model vocabulary, not an agent run.

Costs and requirements

• Agent stages run on your own subscription — sighting, research, refinement, and authoring are agent runs, on whichever agent CLI that stage is configured for; the deterministic engine work costs nothing. Claude is the documented path. See BYO Claude & keys, and "Who runs each stage" above for the model dial.
• Images are optional and bring-your-own. The cover and section infographics use the image-generation Gemini key from Settings ▸ API Keys — a separate key from the one the knowledge base uses, and one that needs a paid tier. The pipeline runs end-to-end without it.
• Your corpus stays local. Seed files, notes, sections, and exports are files on your disk throughout.

Where to go next

• Build a knowledge product — the same ground as a walkthrough
• Tiers: Pro & Ultra — where Products sits in the subscription
• Workspace & documents — where the pipeline's files live