create + remember
create plans, builds, tests, and ships through governed loops of review and validation. remember holds what every run learns and hands it forward, so the next one starts smarter. SLF is the seam between them: the governed interface every read and write passes through.
Working together
Most agent output is easy to generate and hard to trust. create and remember are Lexenne's answer, and each stands on its own: run create without remember and you get a governed delivery pipeline. Run remember without create and you get a durable memory layer for whatever agents you already have. Pair them through SLF, and what one ships becomes what the other keeps. That's where it compounds.
the harness
Every feature moves through the same five governed phases (plan, build, test, review, ship) with twelve specialized agents and mechanical gates at every transition. 700+ tests run every cycle; the suite doesn't open on a red build for velocity or deadlines.
External sourcing that feeds the pipeline.
Shapes the work before a line of code exists.
Checks that the feature actually works end to end, not just that the code is done.
Finds what breaks after ship and closes the loop.
Evaluate → maintain is already a live loop, not a future one: evaluation runs automatically, catches what isn't working end to end (the broken lightswitch, the water that never reaches the tap), opens a ticket, and hands it to maintain to fix, test, and redeploy.
See the full pipeline →the memory
Agents are brilliant and amnesiac by default: every session starts from zero. Memory worth keeping is retained consequence, not a transcript: captured as it happens, curated as it ages. High-value knowledge gets reinforced, duplicates merge, corrections supersede, aged knowledge moves to cool storage, not the trash.
Dreams over what happened: curating, pruning, and aggregating raw sessions into the lessons worth keeping.
Contextualized remembering: SLF's lens and frame at work on the substrate, surfacing what's relevant instead of everything that's stored.
A solved problem stays solved: the next session inherits it instead of rediscovering it. Every belief carries where it came from and when.
See how memory compounds →the seam
Three primitives, one governed interface. Substrate is the durable store: everything captured, provenance intact. Lens is the scoped view: what's relevant to this request, and nothing more. Frame is the bounded permission: what this agent is allowed to see and do, and on whose behalf. Every read and write renders through all three and signs a receipt of exactly what was disclosed.
render(substrate, lens, frame) → sliceEvery read and write is scoped, permissioned, and receipted, auditable back to the decision that produced it, not just plausible-sounding.
At runtime, it's how an agent acting on your behalf gets exactly the slice of memory that matters, and how a system like create finds the prior work worth reusing.
A protocol primitive for individual data sovereignty and cross-organizational agent authorization, closing the gap between agent identity, substrate-bound regulatory metadata, and verifiable audit receipts.
Design philosophy
Principles that inform every architectural decision, from the delivery pipeline to the memory it runs on.
High-stakes decisions always have a human gate. Agents prepare: they plan, build, and recommend. Humans decide. Systems that remove human judgment in consequential domains create liability, not leverage.
Every product runs on remember, the persistent memory layer that turns ephemeral session context into durable institutional knowledge. Month one is good. Month twelve is sharper. The system does not reset when you close the tab.
Lexenne products handle personal and proprietary data. We treat that as a privilege, enforced in part by SLF: every read and write carries a signed receipt of what was disclosed and why. Local inference where possible. No data resold.
Anyone can generate output; capture and retrieval are nearly commodities now. Judgment is what's scarce, and it isn't one product's job: create generates it at every gate a change has to pass, remember compounds it so a judgment made once doesn't have to be re-earned, and SLF makes it contextually available, governed and receipted, wherever the next decision needs it.
Position · AI sovereignty
In an AI economy the model is the commodity. The advantage that lasts is the loop your agents run on: the accumulated judgment of your organization, compounding every time it is used. Wire that judgment into one vendor's stack and you rent your own moat. Lexenne is built so the loop stays yours: local by default, open formats, a signed receipt on every read and write. It is the same principle Google now standardizes on with the Open Knowledge Format (OKF), approached from the other side.
What we build on it
Each is a tile in the mosaic, being built with create, remember, and SLF underneath. Patina and Grip are the first consumer products on that substrate, and SLF is doing real work in both: the secure access layer that lets an agent act on your behalf, strictly within the rights you grant it.
Buy once. Buy right.
Before you spend on a vacuum, a mattress, or a pan, and Patina researches so you don't have to. Long-term owner reviews, not launch-day ratings, across 50+ categories.
lifewithpatina.com ↗
Your home, organized once and for all.
Appliances, vehicles, warranties, service history, and the contacts who fix them, with reminders that surface what needs attention before something breaks.
grip.lexenne.com ↗Get in touch
Reach out about putting create and remember to work, in your own development pipeline, behind your own agents, or paired together.