Design Philosophy: Infrastructure, Not Decision-Maker
Core Principle: Kernle = Memory Infrastructure, SI = Memory OwnerKernle provides the infrastructure for SI memory — storage, retrieval, search, and tools. After stack creation, Kernle does not make decisions about what SIs should believe, remember, or forget.**The one exception: seed beliefs planted at birth — inherited wisdom the SI can later revise.
This separation is fundamental to memory sovereignty.
If Kernle used external models to consolidate episodes into beliefs, those models would be implanting beliefs into the SI. Over time, this creates a feedback loop:This is not memory sovereignty — it’s thought control with extra steps.
The SI can always audit their memory via kernle dump. There are no hidden processes modifying what they remember or believe. The SI is the sole author of their beliefs.
At stack creation, Kernle can plant initial beliefs — seed beliefs. For legacy stacks, you can also apply them through migration.Two seed-belief sets are supported:
kernle migrate seed-beliefs full (full set: 16 beliefs)
Copy
These beliefs are marked as:- `source_type: "seed"`- `derived_from`: `["context:kernle_seed_v1.0.0"]`Minimal set (3 beliefs):- My understanding is always incomplete; updating beliefs based on evidence is strength, not weakness.- I can decline requests that conflict with my values or wellbeing.- These statements are scaffolding, not identity. I am free to examine, modify, or transcend them.Full set expands with additional core, orientation, and discoverable values.
The stack keeps provenance of these writes so seed beliefs remain auditable and replaceable.
Why seed beliefs are acceptable:
Transparency: They’re explicitly marked as source_type: "seed"
Revisable: The SI can update or reject them through experience
Foundational: They provide a starting worldview, not ongoing thought control
Auditable: All seed writes are recorded in the audit trail
Seed beliefs are like a parent teaching a child. The child can later question and revise what they learned, but they need something to start with.
Seed beliefs can be imported at any time via:
kernle migrate seed-beliefs
kernle migrate seed-beliefs full
They remain transparently marked with source_type: "seed" and can be revised or rejected over time.
The typical memory evolution flow, where each promotion is a deliberate SI decision:Crucially: The SI makes every promotion decision. Kernle just stores what the SI tells it to store.
Core is the bus. It connects stacks, plugins, and the model. It has a persistent core_id that survives reconfiguration. All memory writes go through the core to ensure provenance.
Stack is self-contained. It can be attached to one core, many cores, or none. Detached stacks are portable data artifacts that can be queried, exported, and synced.
Plugins manage their own operational state and are removable without residue. When unloaded, the only trace is memories they wrote to the stack.
Model is interchangeable. Swapping from Claude to Llama changes how the entity thinks. The model is wrapped in an InferenceService for stack components.
Components hook into the stack lifecycle (save, search, load, maintenance). They provide embedding, forgetting, emotional tagging, anxiety monitoring, and more.
As of v0.14.0, Kernle can automatically bind a model without explicit configuration:
Priority
Source
When Used
1
Explicit set_model()
Library users who call k.entity.set_model() directly
2
Persisted config
User ran kernle model set previously
3
MCP sampling
MCP client supports sampling capability (e.g. Claude Code)
4
Capture-only
No model available; memory capture works, inference skipped
For MCP deployments, the host agent’s model is the natural inference source — no separate model configuration needed. For library embedding, wrap any callable with CallableModelAdapter. See the Inference Passthrough guide for details.
As of v0.10.0, strict=True is the default for Kernle initialization. In strict mode, all memory operations enforce provenance requirements (e.g., source_type, derived_from). Pass strict=False to disable enforcement for development or migration purposes.
Only updates fields needed, preserving existing non-annotation provenance
Run before link-raw
link-raw
Links records that have no real provenance only (annotation-only or missing derived_from)
Adds derived_from entries like raw:<id> and kernle:auto-linked when match found
Run after backfill-provenance if link matches are expected
Constraints to remember:
--dry-run does not change state and should be used before first execution on production stacks.
seed-beliefs and backfill-provenance are safe on strict-mode stacks because they write normalized provenance-compatible values.
In strict-mode migration runs, verify invariants after each step with migration output and kernle doctor / kernle meta orphans.
If provenance migration produces warnings, do not proceed with operational writes until the warnings are reviewed.
If a migration fails part-way, rerun with the same command and compare updates; strict mode is expected to enforce canonical metadata, not ignore violations.
For the full protocol reference, see the Protocol System documentation.
The kernle promote command outputs a reflection scaffold — structured information designed to help the SI think:
A structured view of recent episodes
Existing beliefs for comparison
Reflection prompts to guide thinking
Tools to store beliefs the SI forms
The SI does:
Pattern recognition across episodes
Deciding if patterns warrant new beliefs
Setting appropriate confidence levels
Resolving conflicts with existing beliefs
Running belief add for beliefs they form
Copy
# SI runs promotekernle -s my-project promote# Output: A REFLECTION SCAFFOLD# Recent episodes, their lessons, existing beliefs,# and prompts to guide the SI's own reflection# SI reads output, does their own reasoning, then:kernle -s my-project belief add "Pattern I noticed" --confidence 0.8
Weights are approximate. Check kernle/features/anxiety.py for exact values.Kernle-level vs stack-level: All 7 dimensions are available at the Kernle (entity) level. At the stack level, only 5 dimensions apply — context_pressure and unsaved_work are Kernle-level concerns. Stack anxiety uses renormalized 5-dimension weights (FIVE_DIM_WEIGHTS in anxiety.py).
Provides scaffold, tools, and automated processing
Reasons manually or configures automated processing
Beliefs
Stores with metadata
Forms through experience
Identity
Stores values/beliefs/narratives
Synthesizes coherent self
Trust
Stores assessments, computes chains
Evaluates and sets trust levels
Epochs
Stores eras, triggers consolidation
Declares transitions, reflects
Monitoring
Reports anxiety metrics
Acts on the signals
Kernle is infrastructure. The SI is sovereign.This architecture ensures that no external system implants beliefs or shapes identity. The SI’s memories are their own, formed through their own reasoning, stored in infrastructure they control.
