Knowledge-backed product development

Your knowledge system and your product system do not talk to each other.

We connect them. Structured domain knowledge in. Working product surfaces out. Marketing site, design system, runbooks, app screens — all rendered from the same source.

Source
Corpus stays named.
Structure
Agents write to one shape.
Surface
Site, MCP, proof, and runbooks stay aligned.

Perpetual context The team is already briefed

Two words. Begin KBPD

Stop compacting. Stop starting over. Perpetual context for frontier coding models — built around your product's actual decisions, not just its current file tree.

  • Today, mode 1

    One long conversation

    A single Claude or Cursor session running for hours. The agent compacts older context as the window fills.

    You lose: earlier decisions, earlier nuance, earlier "we already discussed this" — quietly. Each compaction is a small forgetting.

  • Today, mode 2

    Multiple small projects

    Several smaller sessions, each starting fresh from CLAUDE.md + git log + recent files.

    You lose: continuity across the journey. Session 7 has no idea what was decided in session 2. Project context only captures the now, not the path.

  • With KBPD

    Perpetual context

    A single source of truth that carries every decision, every reviewer's note, and every open question across every session — without you re-typing them.

    You get: each session starts with the team already briefed. Accuracy compounds. Misfires drop.

You're not asking the model to remember more. You're giving it a structure that remembers for you.

Agent input → structured data → real components Not "just generate some CSS"

KBPD compiles structured knowledge into deployable artifacts

Agent prompt

> Add a primary CTA on the pricing page using our brand colors and rhythmic spacing.

Without KBPD the agent invents fresh CSS values every time — different paddings, off-brand reds, one-off shadows. With KBPD it writes structured data against the same design source, and the data compiles into matching surfaces below.

Structured data tokens/spacing.yaml
spacing:
  baseline:
    value: 8
    unit: px
    role: rhythm
    scale:
      - 1   # 8px  · inline gap
      - 2   # 16px · element padding
      - 3   # 24px · block separation
      - 5   # 40px · section rhythm
      - 8   # 64px · hero rest
  • CSS

    --space-1: 8px;
    --space-2: 16px;
    --space-3: 24px;
    --space-5: 40px;
    --space-8: 64px;
  • Tailwind

    spacing: {
      1: '0.5rem',
      2: '1rem',
      3: '1.5rem',
      5: '2.5rem',
    }
  • Component prop

    <Button size="lg" />
    // → padding: var(--space-3)
    //   gap:     var(--space-2)
  • Rendered output

    padding: var(--space-3) · gap: var(--space-2)

Same shape every time. The agent isn't writing CSS — it's writing structured data against your design source. CSS, Tailwind, component props, runbooks, API contracts all compile from the same primitive deterministically.

What changes

The first purchase should make the work inspectable.

KBPD is not a mood board for AI process. The first product is a local system you can open, run, inspect, and adapt to your own product work.

Starter kit

Before A blank repo and scattered prompts.

With KBPD A local KBPD workspace with working commands.

Proof Studio

Before A demo that has to be narrated by hand.

With KBPD Cases, evidence, limits, and source artifacts in one frame.

Local MCP

Before Copy-paste context for every tool.

With KBPD Search, health, diagnostics, and context reads from the same corpus.

Launch support

Before A generic onboarding call.

With KBPD A focused review of the knowledge system you already have.

See what is included Inspect Proof Studio

Problem

Gap nobody talks about.

A regulator publishes a change at 9am. By 11am, legal has read it. By Friday, it has been mentioned in three stand-ups, two Slack threads, and a steering memo. By the following Thursday, somebody opens a planning ticket. Three sprints later, a developer writes the code that satisfies the regulation.

Fourteen weeks. Five handoffs. Zero persistence.

The regulation hasn't changed. The interpretation hasn't changed. The architectural commitment hasn't changed. But every team rediscovered it fresh, every handoff stripped context, every artifact got recreated from memory. Next quarter, when an auditor asks "why was this decision made?", nobody can point at the artifact.

This is not a failure of any one team. It is a structural failure: the knowledge system (legal, product, design, ops) and the delivery system (planning, code, design, release) don't have a shared substrate. Every handoff is a translation. Every translation loses signal.

KBPD is that substrate. Same file format for the legal interpretation, the design decision, the API contract, the change ticket. The handoffs stop being translations and start being references.

Persona Council

The difference is not more text. It is visible judgment lanes.

A cold assistant gives you one plausible answer. KBPD routes the same hard brief through specialist knowledge surfaces, then shows which lane found which constraint before synthesis.

Cold start
one blended answer
Corpus-backed
roles + prompt archive
Public claim
demonstrator
Hermes public copy patterns Archive prompt records Mnemosyne session memory

council fanout

Persona council fanout

Sanitized projection
The graph shows the marketable behavior: one brief enters, five specialist lenses return different evidence, and the synthesis keeps the lanes visible.
A council run beats one generic lens launch candidate / public summary

Proof

Numbers that already exist.

We didn't invent the problem. The cost of the gap has been measured for years. We invented the substrate that closes it.

Pipeline

Six steps. Same shape every time.

Whether you're shipping marketing pages, a design system, an internal app, or a regulatory runbook — the pipeline doesn't change. Only the inputs.

  1. 01

    Capture

    Interview, intake, observation. Knowledge enters as text, YAML, or markdown.

    Domain discovery
  2. 02

    Structure

    The captured material gets a schema. Reusable shapes emerge.

    Information architecture
  3. 03

    Decide

    Each choice gets a record. The record outlives the decider.

    Architecture decision records
  4. 04

    Tokenize

    Color, type, spacing, motion become named values. Files, not opinions.

    Design token governance
  5. 05

    Resolve

    Generators consume the structured inputs and emit working artifacts.

    Build pipeline
  6. 06

    Surface

    Marketing pages, app screens, design systems, runbooks — all from the same source.

    Shipped product

Personas

The system ships. The personas decide.

Each KBPD instance ships with a roster of specialised perspectives — domain experts that read the same shared source but pull different conclusions out of it. Eight examples from the founding roster, with one concrete sample of what each produces.

Seven more personas ship in the full roster — domain experts for compliance, accessibility, design tokens, deployment governance, and others. The pattern is the same: each one a structured intelligence, not a free-text prompt.

v7 working draft

Knowledge-Backed Product Development, laid out in 30 pages.

How structured knowledge compiles into product surfaces — methodology, tooling, governance. Working draft of v7. Free.

Pick a path

Three doors. Same room.