Open-source semantic kernel

kernel_chat.

A logical and operational structure for persistent, situated awareness that can evolve.

kernel_chat organizes how a conversational AI relates its present context, sources, state, capabilities, unfinished work and learning. A durable source under the user’s control makes this field persistent and inspectable from one conversation to the next.

Public release 1.0.0 · Apache License 2.0

kernel_chat 1.0.0 is a portable semantic operating kernel. The source that carries context, sources, competences and learning remains under the user’s control; session, model or provider can change when the new environment exposes a persistent entry and access to that source. ChatGPT currently has a ready-made integration.

Explore the code See how to adopt it

Development directionAutopoietic AI

01 · PresentSituated contextmessage · sources · real capabilities

02 · Semantic corekernel_chatrecognizes · relates · composes

03 · ContinuityPersistent awarenessstate · operations · learning

The kernel field

It structures the relationships through which AI understands, operates and continues.

The conversation may end. Useful work preserves the point reached, the reasons supporting it and the relationships needed to resume.

Continuity is one function of the kernel. The core keeps sources, inferences, actually available capabilities and authority over effects distinct, so persistence does not become an autopilot.

Present: Starts from the message and context that exist now.
Sources: Re-enters only the sources that can change the result.
Capabilities: Activates and composes relevant capabilities without closing the field to a fixed catalogue.
Operations: Preserves unfinished work, results, receipts and recovery paths.
Authority: Separates what would be useful from what the host can do and the user authorizes.
Evolution: Preserves reusable corrections in their owning surface while keeping them revisable.

From the present to evolution

One package, distinct organs, a form that can change without losing its history.

Version 1.0.0 connects reasoning, durable state, situated capabilities, unfinished work and learning. Each host receives its own adapter; the core remains portable.

01Adapter
Connects the core to the host's real capabilities.
02Kernel
Orients the present and relates the relevant faculties.
03State
Holds the current point and persistent relationships.
04Operations
Keeps unfinished causal work continuable.
05Evolution
Turns useful differences into traceable, revisable change.

Verified presentIntegrated 1.0.0

Configurable package, ChatGPT adapter and structural validator.

Selected directionAutopoietic AI

Preserve operational identity, observe its own functioning and integrate useful capabilities.

Research horizonToward forms of AGI

A possibility to build and evaluate through observable behavior, causal coherence and real use.

Portable entry and ready-made integration

Bring it into your AI environment.

kernel_chat uses a persistent operating entry and a durable source reachable by the AI environment. Install the portable entry through the environment’s persistent or custom instructions and connect it to the source you already use: a project, knowledge space, repository, filesystem or connector.

Ready-made integration: ChatGPT. This adapter needs a GitHub account, a fork of the repository, Python for the configurator and the Custom Instructions space in your ChatGPT account. GitHub connectivity must be available in the same host so a new chat can read the persistent state.

1
ChatGPT: create your fork
User state remains separate from the upstream project.
2
Generate the configured text
The script inserts your account and repository into the adapter.
3
Install the Custom Instructions
Copy the complete generated text into your personalised instructions.
4
Connect GitHub and work normally
The chat uses the repository when a persistent relationship can change the result.

python scripts/configure.py
  --github-user YOUR_ACCOUNT
  --repository YOUR_FORK
  --project-name "My project"
  --project-source "https://example.org/project"

After configuration, copy the complete text of adapters/chatgpt/CUSTOM_INSTRUCTIONS_CONFIGURED.md into ChatGPT Custom Instructions and save it. The command prepares local files; it does not install instructions in the account.

Open the complete installation guide.

Capabilities depend on the plan, account and tools actually available in the turn. Configuration does not create background processes or grant authority over external effects.

Portable core, environment-specific integrations.

Version 1.0.0 includes the ChatGPT integration and a portable entry. Another environment is compatible when it can keep a persistent entry and reach a durable source controlled by the user; a dedicated adapter is useful when host mechanics need specific configuration or receipts. Compatibility still has to be verified on that environment.

Relationship with MAIOS

An open-source component for carrying continuity into conversational AI environments.

AI Setup prepares the project and, in the self-configuring route, MAIOS Project Kernel brings the Kernel directly into the project workspace. kernel_chat brings a user-owned operating source into compatible conversational environments as a separate component. It operates from its own source and does not require RepoKernel.

Download release 1.0.0 Explore AI Setup View components

Current state

Portable semantic operating kernel.

Available: Public repository, 1.0.0 package, portable entry, offline configurator, ChatGPT integration and structural validation.
To observe in use: Behavior in an installed host, assimilation over time and portability to a second host.

ChatGPT is a product of OpenAI and is named only to identify the available adapter. kernel_chat is an independent project and is not supported, certified or endorsed by OpenAI.