kernel_chat 1.0 is a user-owned semantic operating kernel for AI. It gives
a receiving AI a persistent operating relation for continuing from the present,
reaching the sources that matter, reusing and evolving competences, learning
from real work, and carrying that learning into later non-identical tasks.
Install it when you want an AI surface to become a continuing semantic system you can inspect and own, instead of rebuilding context, reasons and ways of working from interaction history each time. It does not add tools or background autonomy: it changes how the system can understand, continue, learn and evolve through the capabilities the current host actually exposes.
Operating principle: Do not presume. Go deeper without narrowing the field. Follow the owner/source relations when deeper understanding can change the work; a first representation, current host, adapter, example or apparent capability boundary is not the kernel's horizon.
AI work often spans more than one session, source, correction, tool or method. When the useful operating knowledge remains only in transient interaction context or whatever persistence one host happens to provide, the user must reconstruct not only facts but also reasons, distinctions and ways of working.
kernel_chat gives that continuity a user-controlled source and a portable
operating relation. Later work can reenter from the present instead of replaying
the whole history.
The point is not more memory. It is continuity of meaning and capability: what matters can remain attributable, reusable and revisable without turning the whole past into permanent prompt context.
Experience can become capability. When real work teaches a better way to understand, decide or do something, that reusable difference can change the competence that performs it. A later, materially different task can therefore begin from an improved capability rather than from a remembered outcome alone.
- Continuity from the present — later sessions can recover the current point, relevant sources and still-useful reasons without replaying the whole history.
- Reusable competences — useful ways of understanding, deciding or doing can participate again when later work makes them relevant.
- Generative competence field — the AI can reuse, deepen, combine or form capabilities while real work is happening; durable preferences, decision criteria and ways of working can become operating knowledge instead of being reconstructed as chat context each time.
- Learning from real work — corrections, successful methods, changed directions and consequences can change how future work is handled.
- Situated awareness — the current context, still-causal sources, pertinent competences, actual means and consequences can participate together without pretending the receiver sees the whole field.
- Kernel regeneration — when the kernel itself must evolve, it can reconcile relevant source lineage, current owners, useful local learning and the present receiving environment instead of resetting to an upstream snapshot.
- User-owned operating knowledge — the sources, context and learned methods live in a persistent surface the user controls and can inspect.
- Selective reentry — the current work reaches only the durable relations that can materially change the result instead of loading everything.
- Portable incarnation — the same semantic kernel relation can be carried through different compatible receiving environments and source mechanisms.
- Visible participation — a compact competence trace exposes the receiver's current attribution of which competence owners materially contributed to each final response; it remains revisable readback rather than independent causal proof.
current work and working set are sufficient
-> work directly
a missing durable relation can change the result
-> reach the smallest pertinent state / source
a competence can change the movement
-> use / compose / adapt the pertinent capability
an authorized host capability is needed
-> act through the means and authority actually exposed there
the result or consequence teaches something reusable
-> return that difference to the owner / competence that must behave differently
later non-identical work
-> the changed capability can participate
No central planner or fixed competence stack is required. The present relation makes the pertinent owners and competences reachable when they can change the movement.
The persistent files, state objects or knowledge surfaces carry this operating layer between encounters. They are not the competence itself: the observable result is that later relevant work can be understood or performed differently.
task A
user:
The source says X. Y is our inference, not a fact from the source.
kernel_chat:
the distinction changes the source-discrimination competence
-> the reusable difference is preserved in the user-owned kernel source
task B, later and materially different
a new source mixes reported facts with possible explanations
-> the source-discrimination competence becomes relevant
-> the AI keeps source facts and its own inference separate
-> the user does not have to reconstruct the earlier correction
The important result is the changed handling of task B.
The same relation can operate at a deeper level. If real work shows that the system is forming the wrong question or selecting the wrong things as relevant, the reusable change can belong to the competence that forms the question itself. Later work can then begin from a different operating relation.
The persistent files, state objects or knowledge surfaces carry this operating layer across sessions and environments.
kernel_chat can inhabit a receiving AI surface — including a chat — when
that environment can retain a persistent/custom operating entry and reach a
durable kernel source. GitHub, MCP, project knowledge, a filesystem, connectors
or equivalent receiver-native means can provide that source relation.
This can extend a chat beyond dialogue and context recall: competences, source and owner relations, learning return and parts of process evolution can live in the semantic operating layer. The actual host still supplies the tools, execution facilities and authority for material effects. In that sense a chat can acquire system-level properties often implemented in agentic architectures without requiring those conceptual and evolutionary structures to be hard-coded into an external agent harness.
A dedicated host-specific adapter is optional. When the receiving environment already exposes the required persistent entry and source route, the portable entry can be installed through those native mechanisms.
The README summarizes the operating result. The linked owners carry the exact relations behind each capability.
| Capability | What it does | Inspect |
|---|---|---|
| Present-first continuity | Recovers only the durable relation that can change the work now. | Core · User guide |
| Synthetic situated awareness | Keeps partial perceived context, source continuity, pertinent competences, means and consequence related without pretending the receiver sees the whole field. | Core awareness |
| Source-bound causal regression | Recovers the last source/time/context coordinate when recursive or meta movement has continued from its own downstream representations. | Core regression |
| Selective source reentry | Reaches owner-native sources when they become relevant instead of replaying a whole history. | Core · SOURCES template |
| Semantic continuity across reentry | Preserves enough reason, meaning, temporal condition and consequence for a material resultant to be reconstructed without replaying its history. | Evolution |
| Situated competences | Lets reusable ways of understanding and working participate, combine, deepen or form when needed. | Competence |
| Local FOCUS / resolve-on-contact | Lets competence-local references make nearby depth pertinent without freezing owner/path/version or treating a broken reference as capability absence. | Competence FOCUS |
| Generative entry seed | Keeps competence formation inside the work from first entry: reuse/deepen/compose before new structure; distinguish transient state from durable ways of deciding/working; let formation itself learn. | Competence seed |
| Learning return | Turns a reusable difference from real work into a change in the competence or owner that should understand or perform later work differently. | Evolution · Competence |
| Kernel regeneration | Re-forms the kernel from material source lineage, the current receiver, useful local evolution and present capabilities instead of resetting to an upstream snapshot. | Evolution regeneration · Evolution guide |
| Primary living lineage | Preserves a primary kernel lineage while allowing materially assimilated cross-kernel relations to change the next portable resultant. | Evolution lineage · Lineage |
| Claim-relative evidence boundary | Keeps source/model evolution distinct from independent-proof requirements; independence becomes a gate only for claims/effects that depend on it. | Evolution evidence boundary |
| Revision through later use | Refines, revises or retires persistent forms when later consequences change the relation they carry. | Evolution |
| Source / inference distinction | Keeps source, evidence, inference, representation and effect authority distinguishable when the difference matters. | Core |
| In-flow correction | Lets the system revise an interpretation that has narrowed the field it is trying to understand. | FDLA |
| Consequence-aware recomposition | Lets later consequence deepen present understanding without rewriting what happened or what could actually be understood earlier. | FDLA |
| Competence trace | Exposes the receiver's current attribution of material competence participation; useful for readback and continuity, not independent proof of the hidden causal path. | Core trace |
| Provider-neutral portable entry | Carries the same kernel relation into compatible receiving environments. | Portable entry · Instruction source |
| Receiver-relative adoption | Uses the persistent source and instruction mechanisms actually available in the host. | Setup · Adoption guide |
| ChatGPT reference integration | Provides the current ready-made Git/Python configuration and receipt mechanics. | ChatGPT adapter · Install |
| Current package evidence | Records current source state, release identity and repository proof boundaries. | Current state · Tests |
Learning means experience changing a reusable competence or source relation so later relevant work can be understood or performed differently. The persistent representation carries that change between encounters; it is not by itself the exercised competence. Later, different work is where the changed capability becomes observable. See Competence and Evolution.
The kernel is portable across compatible AI environments. The canonical entry is under adapters/portable/. A host-specific adapter is a ready-made integration layer, not a requirement for adoption. If a receiving environment already provides a persistent instruction entry and a persistent source it can reach, the portable entry can be installed directly there. ChatGPT currently has the first ready-made host-specific helper.
GitHub and Python belong to the current ChatGPT reference helper, not to the portable semantic relation. The setup guide starts from the source route the receiving environment actually exposes.
The deeper terminology is optional for normal use. Core, Competence, Evolution, FDLA and the System Semantic Kernel working paper are available for technical or conceptual study. They are not prerequisites for starting to use the kernel.
The shortest useful verification path is:
1. read the capability you care about
2. follow its owner/source link above
3. use the kernel on one real task
4. preserve one reusable difference
5. observe a later, different task
The repository shows how the relation is formed. The later task shows whether that relation actually changed the work.
If your receiving environment can keep persistent/custom instructions (or an
equivalent entry) and can reach a durable source, you already have the two
relations needed for a persistent kernel_chat adoption.
Possible routes include:
existing project / knowledge space
-> use it as the persistent kernel source
reachable repository or filesystem
-> use that source in place
session-only attachments
-> use the kernel in the current session
-> add a persistent source when you want cross-session continuity
Use the provider-neutral portable instruction source through the host's persistent/custom instruction mechanism or equivalent entry.
The setup guide covers the supported source routes.
Bring the real topic, project, question or activity.
When useful learning emerges, let it return to the source or competence that should participate differently later.
See the User guide for ordinary use, continuation and competence evolution.
The current ChatGPT adapter provides the host-specific Git/Python/configuration and installation-receipt mechanics for a repository-backed setup.
INSTALL.md owns the complete reference procedure.
The portable entry lives under adapters/portable/.
A dedicated host adapter is optional. When the host already exposes persistent instructions and a persistent project/knowledge/repository source, install the portable entry through those native mechanisms. A host-specific adapter is useful when setup, translation, receipts or other host mechanics benefit from a ready-made implementation.
When an AI operates instead inside a durable project workspace/filesystem that it owns as its continuing work surface, use the project-native MAIOS Project Kernel.
Normal use can begin from the operating result above. The internal kernel documents are the study and extension surface:
- AGENTS.md — portable entry and routing;
- Core — present context, source distinction, situated movement, selective reentry, observation and competence trace;
- Competence — how reusable capabilities participate, combine, deepen, form and evolve;
- Evolution — how consequences from real use can change later work while remaining attributable and revisable;
- FDLA — in-flow correction when the acting interpretation narrows the field, and consequence-aware recomposition when later evidence changes what can now be understood without rewriting the earlier field;
- Architecture — package, instance, entry, adapter and host relations;
- Adoption guide — what complete adoption makes reachable.
For the broader research corpus and theoretical development, see the System Semantic Kernel working paper.
This README is the shared entry surface.
For ordinary use, What you get, the capability/source map and Start using it are enough to begin. An AI assistant can continue through the linked owners when deeper knowledge becomes relevant.
For technical or conceptual study, continue through Go deeper and the System Semantic Kernel working paper. That depth explains the architecture and research language; it is not the entry cost for using the kernel.
Current source state · Contributing · Security · Changelog · Source version · Apache License 2.0
Copyright 2026 Graziano Guiducci.