Personal knowledge
as the v0 wedge.

Alexandria is the substrate. Life With Patina is the consumer surface. The substrate has been running daily and already serves multiple systems, so the wedge rests on working infrastructure.

The seven-type grant taxonomy lives in an uncomfortable tension with itself. Its examples are mostly drawn from regulated domains (healthcare, financial services) because those domains make the type distinctions easiest to motivate. But the architecture is explicit that regulated domains are not the v0 wedge. The grant-taxonomy deep-dive surfaces that circularity directly: "the real test of the taxonomy is whether it is well-shaped for personal-knowledge sovereignty, and that test has not run yet."

This page is what runs that test. The wedge is personal knowledge, the durable things you own and the things you've learned about them, and the wedge has working infrastructure. The substrate (Alexandria) is in production. The consumer applications that will exercise the substrate via SLF-shaped lens contracts (Patina and Grip, the Life With Patina brand) are the next layer being wired up.

Three concerns sit at three layers, with a clean separation of what each is for.

Lexenne (company)
├── genarch.dev         generative architecture: SLF / Alexandria / SPA / Forge
├── lifewithpatina.com  consumer lifestyle brand (primary v0 wedge)
│   ├── Patina          buy-it-for-life curation (flagship)
│   └── Grip     household management
└── strata-work.com     autonomous job-search (alpha, used locally)

genarch is the infrastructure layer. It carries SLF (the protocol), Alexandria (the substrate), the Sovereign Personal Agent (the runtime), and the autogenous-synthesis Forge (the agent harness those things are developed inside). Nothing in genarch is a consumer product; everything in genarch serves the layers above.

Life With Patina is the consumer surface and the primary wedge for SLF. Two products sit underneath it. Patina (the flagship) is buy-it-for-life curation, helping a person make better long-horizon purchase decisions about the durable goods they live with. Grip is household management, the appliances, maintenance schedules, warranties, vendor relationships, and accumulated service history that govern how a home runs. Both products operate on the same substrate; both want different lenses onto it.

Strata, autonomous job search, is alpha, used locally. A product pivot may come later; for now Grip and the substrate work take priority. It is also the least aligned with the SLF wedge thesis, since regulated job-market data carries different adoption dynamics than the low-stakes personal-knowledge data the wedge rests on. The SLF-alignment focus runs through Patina.

Alexandria is the personal knowledge substrate. Append-only signed facts with provenance; LanceDB for embeddings and hybrid search; SQLite for the graph tables and FTS5 fallback; a Letta-style eight-block memory namespace mapping. The architectural choices are independently validated, Cognee, an unrelated open-source knowledge-graph system, converged on the same LanceDB + SQLite + graph layout from first principles. Graphiti (from Zep) picked Neo4j with bi-temporal columns; Alexandria adopts the temporal pattern without the heavier database engine.

The design defines two interpretive primitives on top of that storage layer. Both are specified in the substrate model; enforcing them is the compounding-loop work now in active build, not yet running today:

• The Cornelius confidence model. An ordinal scale, established (1.0) to probable (0.75) to speculative (0.5) to contested (0.25), with a propagation rule: a dependent claim's confidence cannot exceed the minimum of its supporting claims, so a retracted root claim should walk its dependents and rescore them. The scale is recorded on facts today; the propagation-and-rescore enforcement is part of the compounding loop in active build, not yet live.
• Swanson synthesis detection. Three patterns the design will surface across the corpus: convergence (claims sharing evidence from different sources), tension (contradictory claims), and gap (claims with no supporting evidence). The substrate is meant to identify these, not resolve them. Detection is specified, not yet implemented.

What's running, what consumes it. Alexandria has been my daily knowledge system for months. It carries notes, decisions, lessons, project state, and the entity graph that ties them together. It serves the autogenous-synthesis Forge directly, the twelve-agent development system in which the SLF spec, SPA prototype, Strata, and Patina codebases are all developed. It serves Strata's backend. It's available to multiple systems already; the substrate is not the dependency. The work next is wiring additional consumers in.

What that proves, concretely: the substrate-vs-lens architecture survives daily real use. Lens-filtered cross-session retrieval is live, so an agent opening a session pulls in relevant prior context (the page you are reading was produced by an agent whose retrieval calls hit this substrate). The retrieval is good enough to rely on rather than work around. What is landing now is the first piece of the compounding loop: Phase B capture-chat, which ingests ticketless work into the substrate so knowledge accrues without a formal task, behind a capture-to-retrieval verification gate. Confidence propagation, Swanson detection, and conflict resolution (the hard case, where the best memory systems score at or below 6% on MemoryAgentBench, arXiv:2507.05257) are the build ahead.

What it does not prove yet: multi-user behavior, multi-provider composition, adversarial lens design, regulatory compliance posture under audit. Those are the next set of wedge tests, and they live in the consumer-product layer.

Personal knowledge is the right wedge for three reasons. Low stakes. The substrate is purchase decisions, warranty schedules, repair logs, accumulated lessons-learned about the things in your house, not protected health information, not financial records, not credentials that govern legal status. The architecture's regulatory primitives can be exercised without the user's first encounter being a compliance ceremony.

Multi-app pattern. Patina (curation: should I buy this?) and Grip (operations: what do I own and what does it need?) want different views onto the same substrate. Same purchase record. Different lens, different role, different audience. That is exactly the substrate-with-multiple-lenses pattern SLF was designed for, exercised in a consumer context where the user can tell the difference between "showing me product reviews" and "scheduling service for the dishwasher I bought three years ago."

User motivation is convenience, not compliance. A difficult part of regulated-domain consumer products is that the user's motivation to grant access is extrinsic, they grant because they must, not because the product is good. Low-stakes consumer wedges flip that: the user grants because they want the product to work. That distinction matters for whether the grant UX gets pressure-tested by adoption.

Every grant type in the taxonomy maps onto a concrete Patina use case. The mapping is the page that closes the circularity:

None of these are hypothetical operations on hypothetical data. They are the operations a person performs when they manage durable goods over years; they are the operations Alexandria already represents internally; they are the operations Patina and Grip will surface to users via lens contracts. The grant taxonomy was illustrated by healthcare because healthcare regulators have already enumerated the type distinctions. The grant taxonomy will be tested by Patina.

Alexandria as it runs today is governed by my access controls. I'm the only consumer-side reader; Forge and Strata read with my authorization; the substrate trusts what reaches it. That is sufficient for a single-power-user knowledge system. It is not sufficient for multiple consumer applications operating on the same substrate, with each app holding different lens contracts, the user retaining the source-of-truth position, and every access producing an auditable receipt.

SLF specifies what is needed:

• Intrinsic gates on substrate facts. A purchase record carries a vendor-disclosure tag; a repair invoice carries a no-onward-disclosure tag; an appliance warranty carries an expiry. Gates travel with the fact, evaluated by the holder-of-record before any lens reads. In this v0 wedge (T0: the user's own substrate), gate enforcement is structural. The threat model deep-dive covers enforcement tiers and receipt non-emission for cross-party deployments.
• Per-context lens projection. Patina's lens sees price history, product reviews, decision rationales. Grip's lens sees physical location, scheduled service, current vendor contracts. Same facts; different projections; both respect the substrate's gates.
• Frame-bounded action. An agent authorized to "schedule oil change" cannot also "publish your service history publicly." The frame names what the agent is allowed to do, not just what it is allowed to see.
• Receipt SLFs as first-class output. Every operation produces a signed receipt the user retains. Inspection later is not a database query; it's a walk through the user's own audit chain. See the receipts deep-dive for the chain mechanics.

None of those four primitives are speculative at the protocol layer, and the reference implementation now runs. slf-core is a standalone Apache-2.0 library that takes a grant to a scoped read to a signed receipt, and its conformance suite runs green, including a case that runs against a read-only snapshot of the real Alexandria corpus rather than a fixture. A gate-excluded fact never reaches the reader, every operation is receipted, and a tampered or suppressed receipt is rejected; a property-based suite over more than a thousand generated cases confirms that narrowing a grant never widens what it discloses. The substrate is built, and the grant, gate, and receipt primitives are implemented and verified in code. The lens contracts that wire Patina and Grip into Alexandria's read path are the next concrete deliverable.

The architecture composes. The same substrate-lens-frame primitive appears at three different layers:

• Storage layer (Alexandria): Facts are substrate; queries are framed; agent skill files declare lens contracts naming which entity types and relationships they read.
• Application layer (Patina, Grip): Each app is a lens onto the same substrate; each app's user-facing operations are frames; each operation produces a receipt.
• Protocol layer (SLF): The same primitive specified as a wire format, with intrinsic regulatory gates as first-class metadata, deferred grant mechanics to underlying OAuth drafts.

That is what the SLF overview's diagram of substrate / lens / frame gestures at. This page makes it concrete in one direction: how the protocol-layer specification maps down through the storage and application layers in a working system. The substrate-lens-frame primitive is the shape of how a person's knowledge moves between their own substrate, the applications they use, and the agents they delegate to, well beyond a credential-passing abstraction. One primitive, learned once, that works at every layer where it appears.

• Patina and Grip are not shipping to consumers yet. The substrate they will consume is built; the consumer applications are the in-flight work.
• Alexandria + SLF is not deployed integration. The substrate runs, and the SLF primitives (intrinsic gates, lens contracts, receipts) are implemented and verified in slf-core, but that library is not yet Alexandria's live access mechanism. The work is wiring them in.
• The wedge bet is a bet, not a proof. The case for personal knowledge over regulated-domain wedges rests on a strategic argument about adoption cycles, not on outcome data.
• One person's daily use of Alexandria is genuine evidence with narrow scope. It validates the substrate architecture for one user across many roles. It does not validate multi-user, adversarial, or audit-under-regulator conditions.
• Strata being deprioritized doesn't mean Strata is wrong. It runs as alpha, used locally, and may become a product later. SLF-alignment focus shifts to Patina because the multi-app, shared-substrate pattern is intrinsic to Patina in a way it isn't to Strata.
• genarch is not a separate company. It's the infrastructure-layer umbrella inside Lexenne, SLF, Alexandria, SPA, and the autogenous-synthesis Forge sit there together. The brand is for clarity about what layer owns what; it is not a corporate structure.

If you read this with a knowledge-graph, product-strategy, or sovereign-data lens and the wedge bet reads forced, the evidence reads narrow in the wrong places, or the Strata-to-Patina pivot reads as rationalized rather than reasoned, that is the feedback the draft needs. The wedge is the part of the broader thesis where the conviction is highest and the external proof is lowest. Push on it.