Understand the new recipient
Start with purpose, sources and actual means, retaining what must continue across sessions.
Incarnate Neutral Kernel Node
Start an AI assistant with its own identity and continuity
Adapt shared capabilities to a new recipient while preserving its project, local state and learning.
When transferring a kernel or a family of competences to another assistant, team or environment.
Transfer metacompetence · Builders and systems · Public edition 0.3.2
Start a research assistant with the new project’s knowledge
A team supplies a shared method, but the new node begins from its own question, sources and means. Its first work connects a source to the project and preserves why it matters.
The key relationship. Helps a node begin from its own purpose and means, distinguishing the shared package from installation and the work that follows.
An illustrative situation to adapt to your work. Read the complete cases ↓
Adapt the competence to your work
You supply the context: research, a service, a creative project or a team’s work. Examples make the method visible; adaptation preserves the relationships that make it work while understanding the purpose, sources, people and means of your own assignment.
Tell your AI what you want to achieve, what already exists and a practical situation to address. Ask how this competence changes the work and which knowledge from your domain should participate. MAIOS provenance identifies the shared knowledge; you can use it directly in your AI or compose it with an existing kernel.
Adaptation examples in other contexts ↗Start an AI assistant with its own identity and continuity
An assistant can receive a mature method and begin its own project, with its own identity, sources and learning.
This resource forms that passage: from shared capability to the recipient’s first useful work and later reentry in a new conversation.
Cross a first complete piece of work
Connect entry, competence, result and reentry guide in forms the recipient can actually use.
Cultivate the node without overwriting it
Shared updates compose with local knowledge. Learning returned to others carries the method while leaving private identity and state with the node.
Incarnate Neutral Kernel Node in practice: worked cases
These cases illustrate situations, causal distinctions and choices you can adapt to your work.
Italiano. The following cases illustrate how the method is used.
Let a new research assistant begin as its own node
A team supplies a shared method, but the new node begins from its own question, sources and means. Its first work connects a source to the project and preserves why it matters. Later reentry uses its local guide without importing the originating assistant’s unfinished tasks.
Carry continuity from chat into a file-enabled environment
The ability to preserve reasons and sources remains; the means change. A chat reentry note can become a project guide connected to the environment’s entry. Adaptation follows what is actually read rather than claiming continuity from copying alone.
Integrate an update without overwriting local knowledge
A new shared edition improves source selection. The node has learned a distinction in its own domain. Integrate the incoming method with those local reasons and follow affected projections. A neutral lesson can return to the source without private data.
Apply the method to your case
Use SKILL.md or START_CHAT_EN.txt with the relevant sources and your actual context. Keep observations, interpretations and what remains open distinguishable. Preserve the useful reason and continuation in the project’s guide.
Operating choices with Incarnate Neutral Kernel Node
Helps a node begin from its own purpose and means, distinguishing the shared package from installation and the work that follows.
Form a receiver and preserve its own life
Distinguish the upstream source package, a node-owned fork or adaptation, a configured projection, installed host files and the present conversation. A first incarnation forms an initial receiver. An update meets a receiver that already has local decisions, knowledge and observed effects. Preserve those contributions while understanding which source changes remain useful. Version equality cannot establish semantic equality, and different versions need not imply a defect.
Map each material source function to the receiving owner that must carry it. Adapt discovery, entry, persistence, tools and learning to the actual host; a renamed folder alone cannot transport those functions. Retain rejected or deferred relations with reasons where a later return could otherwise lose them. An assessed change remains pending until its receiving implementation and relevant use occur; unchanged upstream files do not finish that work.
Inspect a selected source/receiver pair
The supplied scripts/inspect_kernel_pair.py is a read-only adaptation of the source inspector. It uses Python 3.10+ and Git, without network calls. Copy references/port-map.example.json into your project, set source and destination repository paths, source scope if any, assessed commit and tree identities, owner paths and pending relations. Placeholders must be replaced with actual values; the example is a format illustration, not a claim about your repositories.
Use git -C SOURCE rev-parse HEAD for the assessed commit and git -C SOURCE rev-parse HEAD:kernel for a selected subtree; use HEAD^{tree} when assessing the whole repository. Use the destination's whole tree identity. Run python scripts/inspect_kernel_pair.py --workspace PATH --map PATH_TO_MAP. Repository paths in the map can be relative to the selected workspace or absolute. Run python scripts/test_inspect_kernel_pair.py to exercise scoped freshness and pending work with temporary Git repositories.
The report exposes current identities, dirty work, relevant source/destination deltas, missing mapped paths and pending integration. An unrelated repository commit can leave the assessed subtree unchanged. A missing assessed commit makes comparison unavailable; do not manufacture equivalence. Dirty work is reported separately because committed tree comparisons do not include it. Inspect a relevant local delta before acting. The report never installs, merges, closes pending relations or proves semantic transfer. Follow the actual meaning and receiving knowledge, then record what implementation and use established. Preserve a recoverable earlier state for the exact changed surface rather than resetting another owner's work.
Read the complete operating method
The recipient begins from its own work
Help a new assistant or AI node begin with shared capabilities, recognizable purpose and continuity of its own. Understand the work it should enable, sources belonging to the project, host means and relations that should continue across conversations. Neutrality preserves recipient identity; it does not require an empty system without inherited experience.
Reach the transferred method and its reasons. Carry capability and transferable knowledge while leaving private identity, temporal state, credentials, local topology and effect authority at their origin. A new project's assistant does not inherit unfinished tasks from the project that formed the method.
Understand the node's forms
Distinguish shared method package, recipient-owned copy or profile, host-adapted configuration, instructions actually available there and conversational work. These forms are related, but none alone establishes the others.
A repository may be the node's source, a chat its local present and a configuration an entry into its method. Continuity exists when purpose, sources, useful knowledge and reentry can traverse actual work. Do not attribute user state or recipient-only behavior to the package.
Form a complete first movement
Begin with a useful result feasible through present means. Form an entry enabling context comprehension, pertinent knowledge, action and preservation of what emerges. With files, connect a guide to a stable reentry point; with chat alone, return the guide to carry forward. Separate work feasible now from a part requiring an absent tool.
Make competence formation usable: when initial work teaches a reusable choice, connect cause, conditions and consequence to the method needing it. Make understanding its own operation usable too: if an entry or persistence loses knowledge, that relation can become an object of work. A few deep locations can carry these functions without a mandatory component catalogue.
Adapt discovery, tools and memory while preserving meaning. A harness mechanism is not automatically present in chat. Consult current official instructions when a concrete configuration depends on a provider. A written file alone does not establish installation.
Birth and updates
A new node can begin from current shared capability and form its first case. An existing node also carries decisions, knowledge and local changes. Compare incoming contribution with what it learned and integrate the relevant difference without overwriting identity or project state.
Follow affected method, entry, guide, configuration and installed instructions. Package release does not update recipient copies automatically. Preserve pending integrations even without another source change; absence of a new delta does not complete previous work.
Local learning and shareable return
The node learns in its own context. Reentry difficulty can correct its guide; a successful example can refine a competence. Separate reusable relations from private data and account details before sharing. Preserve what happened, which choice changes and conditions for reuse.
Return to shared source is a distinct effect from local editing. When selected, transfer the method while leaving the node its own memory. Nodes can share capabilities and learn reciprocally without becoming copies of one another.
The meta relation concerns formation of conditions for node work and competence evolution. It becomes autological when startup recognizes and reforms its own limit. A second reentry may reveal that actions survived but reasons did not; correct both the guide and the startup method. The first case documents itself; a different later case can show whether correction continues.
Use and continuity in the recipient
Use supplied chat materials or actual files, tools and guides. Ask only for missing context changing work and act when a useful result is possible. Preserve reasons, sources, learned differences and continuation where the project actually stores knowledge; otherwise return a reusable note.
Instructions can change the method used without changing model weights or proving stable learning. Distinguish available knowledge, use and later behavior. Account access, tools and authority to publish, send, install or distribute depend on the real environment and mandate.
Nature and provenance
MAIOS adaptation of Incarnate Neutral Kernel Node. It transfers recipient formation and cultivation without importing another node's identity, state or authority. Host-specific technical forms remain adaptations for that destination.
Reachable operating knowledge
Read OPERATING_GUIDE.md as part of this method when forming the work. It carries the practical knowledge, decision relations and available means for this capability. The complete chat starter includes this knowledge and worked examples, so it remains usable without private sources. Preserve the public source identity and adapt through the recipient's actual means.
Incarnate Neutral Kernel Node and improvement of the method
A node can inherit capabilities and develop its own method
The meta relation forms the conditions through which a recipient can understand, act and evolve its competences.
The starting method can become its own object. If reentry loses the reasons behind choices, experience can change both the node’s guide and the way the next start is prepared. This is the autological relation.
Shared package, configuration, installation, conversation and learning have distinct states. Autopoietic continuation requires local learning to reach the form through which the node works again.
Competence, meta and autology: the conceptual guide ↗How Incarnate Neutral Kernel Node learns through work
The recipient first preserves learning in its own method. A transferable relation may later contribute to a shared source, with its provenance retained.
Use in a different situation makes continuity observable. A copied repository or a completed profile does not demonstrate it alone.
Use Incarnate Neutral Kernel Node in chat or a project
In a chat
Paste or attach START_CHAT_EN.txt and add your context. It includes the complete English method. If the chat cannot retain files, request an updated work guide and bring it to the next conversation.
In an agentic environment
Make this folder readable and connect its entry to relevant work through the host’s supported mechanism. Identify sources, tools and durable knowledge storage. Reading the package does not install services or account access.
With an existing kernel
Integrate the capability into the guides and competences already in use. Compare the functions they preserve and change only the differences that affect the work.
Without a kernel
Use the included operating method directly. Start from a real case and retain what lets it continue. Compose other resources when their knowledge becomes useful.
Give Incarnate Neutral Kernel Node an assignment
Read or copy the complete English starter and add your context. English is the kit’s primary language; Italian counterparts are included.
Download the package · 0.3.2 ↓Adopt it in your environment ↗Read the guide ↗Read the competence ↗Read the complete starter ↗