Keystone OS — IP Register & 2-Year Buildout Plan

⚠️ Strategy decision record (read first)

This article is a defensive publication. It is published openly, with full enabling detail, on a publicly reachable surface. That choice has consequences that are deliberate, not accidental:

1. Publishing establishes a priority / prior-art date. Once this article is public, the

inventions described below are timestamped public knowledge. That blocks others from patenting them and protects Keystone's freedom to operate.

1. Publishing forecloses Keystone's own patents on the disclosed specs — strictly

outside the US (most jurisdictions have an absolute novelty bar: any enabling public disclosure before filing kills the patent), and in the US after a 12-month grace period from first disclosure.

1. **Therefore the chosen protection stack is: defensive publication + trademark +

copyright**, not a patent portfolio. This is the right fit for a solo, local-first project: it secures freedom-to-operate, authorship, and brand for ~$1k of trademark filings instead of $40k+ of patent prosecution with examination risk.

False-marking note. Nothing in Keystone is currently patent pending — no provisional or non-provisional application has been filed. In the US, marking an unfiled invention "patent pending" is improper. The register below uses honest status labels (Defensive publication / Trademark — to file / Copyright), and reserves a Pre-publication filing gate (§6) for any item the owner decides to patent instead — which must be provisionally filed before that item appears on any public surface.

1. Strategy in one line

**Publish the methods (priority + freedom-to-operate), trademark the names (brand), rely on copyright for the code and docs. Chase patents only on an item you deliberately pull out of publication and file first.**

2. The 2-year buildout plan

Horizon: 2026-H2 → 2028-H1 (8 quarters). Solo developer; calendar is best-effort, not a commitment. Every milestone names the loop stage it strengthens (per the North Star: Observe → Remember → Reason → Act → Verify → Converge) and the IP it touches. Engineering items are grounded in the existing roadmaps: the Progress Report §6, the Σ₀ serving portfolio §6, and the Product serving contract.

2026-H2 — Close the loop in the live product + lock the names

2027-H1 — Ship Σ₀ to all users + harden self-improvement

2027-H2 — Local-first embedded bet + the knowledge graph

2028-H1 — Convergence substrate + register refresh

Plan-level honesty: items tagged [design] / [roadmap] / [conditional] are not built. The embedded path (2027-H2/2028-H1) is a gated bet that can return NO-GO, in which case cloud stays the product. None of the IP value depends on those bets landing — the specs in §4 are protected by publication regardless of ship status.

3. IP register

3.1 Inventions / methods (defensive-publication register)

Status legend: DP = covered by defensive publication (this article and/or the linked doc) · DP-pending = will be DP when this article is published · opt-out = candidate to pull from publication and patent instead (see §6).

3.2 Trademarks

3.3 Copyright

• Automatic on all source code and written specs from the moment of authorship — no

filing required for protection to exist.

• Recommended: add a repo-root LICENSE + per-file headers; register the two

flagship written works (the CSF spec and the Collapse Certificate) with the copyright office if statutory-damages leverage is wanted (~$45–65 each).

4. Per-spec breakdown (full enabling detail)

Each spec below is written to be enabling — precise enough to reproduce, with a pointer to the running code. That is exactly what makes this a valid defensive publication.

4.1 Fast-layer plasticity

What it is. A non-parametric "fast weight" layer that updates in real time after each external grounding event, as a thesis-safe alternative to per-loop neural weight updates: no catastrophic forgetting, no irreversible gradient step, no eval gate — because every weight is a pure function of an append-only grounding log, so it updates instantly per loop yet is fully replayable and reversible.

How it works ([implemented] — grounding-calibration.js):

• A grounding event is { key, predicted, outcome } where key is the dimension trust

is calibrated on (provider / agent / source), predicted ∈ [0,1] is the confidence the system asserted, and outcome ∈ {0,1} is external ground truth (a web check, a settled market, a passing test — never the model's own say-so).

• Events append to data/convergence/grounding-calibration.jsonl (append-only, replayable).
• The fast weight for a key is the Beta posterior mean

trust(key) = (1 + hits) / (2 + n) — starts at the 0.5 prior, moves toward empirical correctness with each grounding.

• Calibration quality is the Brier score brier = mean((predicted − outcome)²)

(0 = perfect, 0.25 = coin flip).

• recordGrounding() appends one event and returns the updated weight; trust() is what a

caller (e.g. the router) consults each loop; calibration() folds the whole log into per-key weights + a headline global Brier.

Loop stage: Verify → Converge (produces the calibrated confidence the Reason/route stage then consumes).

Novelty claim. Not the Beta posterior or the Brier score (both textbook). The contribution is the system: treating real-time, per-loop trust as a pure deterministic fold over an external-grounding ledger, giving instant, replayable, reversible adaptation that substitutes for fine-tuning in an agent loop — honoring "learning via retrieval + experience, not weight modification."

Prior art (design-around map): Beta-Bernoulli conjugacy; Brier (1950) calibration; Thompson sampling; online calibration literature. The novelty is the integration, not the estimators.

4.2 Decode canary

What it is. A per-token controller that closes the instrument → actuator loop on a language model's decoder: it turns live decode-health signals into a surprise measurement and feeds that back into the decode knobs, so a looping/degenerating decode is detected and corrected token-by-token rather than only measured after the fact.

How it works ([implemented] — decode_canary.py):

• Per generated token, observe() computes decode-health signals over decoded ids: running

self-repeat, n-gram echo, argmax margin, realized exit depth, and a two-sided softmax-entropy z-score (greedy collapse → entropy drops → over-confidence alarm).

• These fold (weights w_repeat=0.6, w_echo=0.3, w_margin=0.1) into a **1-D Kalman

observation** for SurpriseMonitor.evaluate(). The Kalman frame is deliberately mean-reverting to a healthy prior, so sustained looping yields a sustained large innovation (high NIS) instead of the monitor quietly adapting to the collapse.

• High NIS drives sigma0_proximity() → 1; knobs() maps that proximity onto decode

actuators: suppress repetition harder, inject novelty, exit the latent loop sooner.

• Pure-CPU and model-free — it consumes token ids + scalars, never model tensors, so it

is unit-testable without loading a model (tests/test_decode_canary.py).

Loop stage: Act (decode) + Verify (surprise instrument).

Novelty claim. The closed-loop coupling: a Kalman/NIS surprise frame, mean-reverting to a health prior, that converts multi-signal decode-degeneration into a single proximity scalar which actuates the decoder in real time — unifying repetition control, entropy-collapse detection, and adaptive loop-exit under one fault-detection controller.

Prior art (design-around map): repetition penalty / no-repeat-ngram; contrastive & entropy-aware decoding; Kalman NIS fault detection (aerospace). Each ingredient is known; the per-token closed-loop decoder controller is the contribution.

4.3 3¹² Convergence Lattice

What it is. A proof that the project's "CSF format" and "Tesseract reasoning geometry" are one object: a 3^12 = 531,441-cell balanced-ternary lattice. CSF is how a point is stored; the Tesseract spiral is how a point moves to a fixed point.

How it works ([substrate implemented] — src/csf/v07/, converged_tesseract.py; design TESSERACT-CSF-SINGULARITY.md):

• Storage face — a lattice cell is a 12-vector of QutritState(amplitude, phase);

change is a list of QutritDelta(dim, amp_delta, phase_delta) packed toNUM_DIMENSIONS=12bytes each (qutrit_delta.py, NUM_DIMENSIONS=12, TOTAL_POSITIONS=3**12). A QuantumDustField holds a baseline (converged cells) + active deltas; every other cell is implicit "dust." get_state resolves baseline ⊕ deltas else None.

• Motion face — ConvergedTesseract never materializes all 531,441 cells; it loads a

minimal observer-collapsed wavefront (cells within a ternary-Hamming radius of the present center, ranked by information density: active deltas > baseline > dust). loop_lm.converge_step supplies the stopping rule: iterate until ‖h_t − h_{t-1}‖/‖h_{t-1}‖ < ε.

Loop stage: Remember (storage face) + Observe→Converge (motion face).

Novelty claim (honest, narrowed). The protectable contribution is the wavefront/dust representation + the store→move→converge mechanism on one shared lattice — not "ternary is good." The repo's own falsification work (X3) refined down the BitNet-sparsity-equivalence sub-claim (value-sparsity is population-dependent, 0.137–0.835; matching BitNet's 0.66 is a coincidence of population).

Prior art (design-around map): radix economy (base-3 optimum, prior art); BitNet b1.58 ternary; Geiping recurrent-depth latent reasoning; STARS stable fixed points; Ouro LoopLM; hyperdimensional computing. Base-3 and ternary substrates are firmly published — claims must stay on the minimal-wavefront + unified store/move mechanism.

4.4 CSF-Omni format

What it is. Keystone's one lossless binary container, with a deterministic best-fit compression stage and built-in integrity (SHA-256 + CRC), reporting 422× on the memory log (up from 14× with the old zlib path) — matching the best-in-field coder while strictly beating every other tested codec.

How it works ([implemented] + [measured] — CSF-FORMAT-SPECIFICATION.md, engine csf_pack.py; benchmark PDF linked from the KC):

• v0.8 layout: [Magic CSF\0][Version][Flags][ManifestLen][Manifest JSON][Blob region][Footer: sha256 + size].
• v0.9 CSF-Omni: for each blob, deterministically try the candidate codecs

(zlib / bz2 / lzma / zstd / brotli) and keep the smallest, recording the winner — every result round-trip-verified lossless; integrity via per-file SHA-256 + footer.

• Validated by a 6-agent adversarial fleet; v0.8 archives remain readable.

Loop stage: Remember.

Novelty claim (honest, weak). Multi-codec best-fit selection is a known technique and the 422× is corpus-specific (highly repetitive JSONL memory logs). The value is the integrated, integrity-checked, adversarially-verified format + reproducible benchmark, not a novel compression algorithm. Defensive publication is the right (and only sensible) vehicle here — a method patent would be weak.

Prior art (design-around map): every constituent codec; "try-all-pick-smallest" archivers (e.g. precomp, zpaq-style model selection).

4.5 Σ₀ collapse certificate

What it is. A Lyapunov-contraction theorem (scoped to normal operators A) plus the Σ₀ trigger and Lemma L2 (a closed-form, machine-checked one-step anisotropy lift) that together bound the reasoning loop so it won't collapse into confident nonsense.

How it works ([proven] + [implemented] — SIGMA0-COLLAPSE-CERTIFICATE.md, SIGMA0-L2-ANISOTROPY-LIFT-PROOF.md, code src/cio_sde/collapse.py, surprise.py):

• The collapse trigger's "flat" leg fires when the eigenvalue coefficient-of-variation

a(Σ) = std(λ)/mean(λ) < ε_a (5e-2). L2 proves that one aligned Σ₀⁻¹ covariance bump of magnitude b ≥ Δ := (ε+a)μd / (√(k(d−k)) − εk) lifts anisotropy back above ε_a, breaking the flat condition (proof + script experiments/prove_l2_anisotropy_lift.py, test tests/test_cio_sde.py::test_l2_anisotropy_lift).

• Four ground-truth-verified experiments;passing tests (34 certificate +stability-gate, verified 2026-06-22).

Loop stage: Verify (the safety mechanism for the whole loop).

Vehicle: copyright + academic publication — NOT patent. Mathematical theorems are not patentable subject matter. This is the flagship arXiv candidate: publishing maximizes citation/priority value, which is the whole point of a proof.

Honest scope: L1 (alignment) is proven only for normal A and open for non-normal; L4 (proximity floor) is an engineered hypothesis. Safety ≠ capability — Σ₀ bounds collapse, it does not make the model clever.

4.6 Convergence-IO stack

What it is. A typed governance + routing layer: small, independently-tested primitives that route every action through a constraint-satisfying execution graph with provenance, each mapping to a numbered governance principle (P1–P10).

How it works ([implemented + unit-tested] — src/convergence_io/, docs convergence-io/):

• DCF (P1) every datum carries a class label; labels propagate → gates CCF.
• NAP (P2, denial form) explicit denials; **a hard denial cannot be overridden by a

capability claim** (the load-bearing ordering invariant).

• AAPF (P3) every action emits a reproducible hashed ActionRecord to an append-only

ledger.

• PCSF (P4) provider availability + fallback chain + circuit breakers; CCF (P4) an

agent must prove a claimed capability at action time.

• CEG the substrate G=(V,E,D,τ,S,H) typed graph with an optimizer returning a

constraint-satisfying plan; D a per-node time-dilation field (slow uncertain regions, speed confident ones → maps to how much grounding to buy).

• Gate order: classify → deny → prove → route → record.

Loop stage: Act + Verify (governance over execution).

Novelty claim. The integrated typed primitive stack with the NAP-over-capability ordering invariant and the dilation-field-as-grounding-budget primitive. (The dilation primitive is the one piece with the most independent method-patent potential — flag it in §6 if exclusivity is ever wanted.)

Prior art (design-around map): OPA/Rego policy engines; capability-based security; W3C PROV provenance; constraint-graph planners. The composition + ordering is the contribution.

Status caveat: implemented + tested in Python; the live JS chat path consumes a parallel adapter (grounding-policy.js), so not every primitive is on the hot path yet (2027-H2 milestone).

4.7 Convergence-exit

What it is. Recasting Ouro's confidence-based Q-exit as a fixed-point exit: stop the latent reasoning loop when the hidden state stops moving (‖h_t − h_{t-1}‖/‖h_{t-1}‖ < ε), i.e. when the trajectory reaches h* ≈ f(h*).

How it works ([implemented, research mode] — loop_lm.py mode="converge"): generate(mode="converge") exits on contraction rather than Q-exit confidence, returning exit_reason: "convergence_exit" and mean_contraction. The served deep path uses the default mode="qexit"; convergence-exit is the falsifiable "spiral" experiment (E2), not yet wired into serving.

Loop stage: Reason (adaptive depth).

Novelty claim (incremental, honest). A real but incremental extension of published recurrent-depth early-exit. Defensive publication only — not worth a patent.

Prior art (design-around map): Ouro Q-exit; Geiping et al. recurrent depth; STARS fixed-point stabilization; deep-equilibrium models (DEQ) — DEQ fixed-point framing is close prior art, so claims here are weak by design.

4.8 Σ₀ continual-training flywheel

What it is. A closed, offline self-improvement loop for the local coder adapter, with two independent ground-truth gates: only execution-verified (green) subprocesses become training data, and only a measured pass@1 win promotes a new adapter.

How it works ([implemented] — SIGMA0-CONTINUAL-TRAINING.md): harvest → execution-verify (gate 1: only green runs train) → train (QLoRA) → eval → eval-gated promote (gate 2: only a measured pass@1 improvement ships). Kept offline by design; weights/adapters stay off-repo.

Loop stage: Converge.

Novelty claim. The double ground-truth gate — execution-verification on the input side and eval-gated promotion on the output side — as a drift-resistant, fully-offline flywheel. Reconciles "self-improvement" with the North Star's "no online weight modification" by keeping training human-triggered, eval-gated, and on a user-data-free corpus.

Prior art (design-around map): STaR / rejection-sampling fine-tuning; RLAIF; execution-feedback code training; eval-gated CD. The specific double-gate + offline + no-user- data fencing is the contribution.

5. How each spec maps to the loop

        Observe ─► Remember ─► Reason ─► Act ─► Verify ─► Converge

           │          │          │       │        │         │

   Observatory[4.x] Lattice    Conv-   Decode   Σ₀ cert   Calibration[4.1]

                    [4.3]/CSF   exit    canary   [4.5]     Continual-train[4.8]

                    [4.4]       [4.7]   [4.2]    Conv-IO   Lattice motion[4.3]

                                        Conv-IO  [4.6]

                                        [4.6]

Every protected spec strengthens exactly one loop stage — satisfying the North Star's feature gate. None is a separate subsystem.

6. Pre-publication filing gate (the patent opt-out path)

Defensive publication is the default (§1). But if the owner decides any single item is worth exclusivity instead, it must leave the publication path and be filed first:

1. Pull it from this article and every public surface before publishing/updating.
2. File a US provisional (~$60–130 micro-entity fee; ~$2k–5k if attorney-drafted) — this

buysmonths and preserves the option to convert to a full or international (PCT) filing.

1. Only then may it be marked "patent pending," and only then is it safe to publish.

Highest opt-out candidates (least prior-art-encumbered, working code):

• §4.1 Fast-layer plasticity — cleanest method, tightly scoped.
• §4.2 Decode canary — concrete controller, model-free.
• §4.6 dilation-field-as-grounding-budget (the one Convergence-IO primitive with method

potential).

Everything else in §4 has high prior-art exposure or is non-patentable math — defensive publication is strictly the better vehicle for those.

Decision required before this article goes public: confirm that none of the §4 specs is an opt-out. Publishing this article forecloses patents on every spec it contains. If that is the intended strategy (it is, per §1), proceed. If any item should be patented, remove it from §4 and file it first.

7. Honest scope & what is not claimed

• This is an engineering + IP-strategy document, not legal advice. Cost figures are

planning-grade market rates, not quotes. A trademark clearance search and a patent attorney's prior-art review are prerequisites to any filing.

• No patent is currently filed or pending. The register tracks intent and vehicle, with

honest status labels.

• Several specs (§4.3, §4.4, §4.7) have high prior-art exposure and are deliberately

routed to defensive publication, not patent — the repo's own falsification work is cited rather than hidden.

• Trademark strength varies; "Keystone" needs clearance and "Ouro" must not be claimed

(it is ByteDance's mark).

• Publication value is real but contingent: it secures freedom-to-operate, priority, and

authorship — it does not by itself create licensing revenue.

Sources (verified on disk 2026-06-22)

• Fast-layer plasticity — apps/lantern-garage/lib/grounding-calibration.js
• Decode canary — src/sigma0/decode_canary.py · tests/test_decode_canary.py
• 3¹² lattice — TESSERACT-CSF-SINGULARITY.md · src/csf/v07/ · src/converged_tesseract.py
• CSF-Omni — CSF-FORMAT-SPECIFICATION.md · src/csf/csf_pack.py
• Collapse certificate — SIGMA0-COLLAPSE-CERTIFICATE.md · SIGMA0-L2-ANISOTROPY-LIFT-PROOF.md
• Convergence-IO — docs/convergence-io/README.md · src/convergence_io/
• Convergence-exit — src/sigma0/loop_lm.py
• Continual training — SIGMA0-CONTINUAL-TRAINING.md
• Buildout sources — KEYSTONE-PROGRESS-REPORT-2026-06-19.md · SIGMA0-AGENT-PORTFOLIO-UPDATE.md · KEYSTONE-PRODUCT.md
• North Star — CONVERGANCE-SIGMA0-BRIEFING.md

</content> </invoke>