Connect the capability to the recipient’s work
Reach the source method and use case, then consult current provider contracts for the technical choices that matter.
Kernel Plugin Incarnation
Bring a semantic kernel into an AI plugin
Connect the source capability to the recipient’s skills, tools and interface while preserving the knowledge that lets it continue.
When a capability needs an installable plugin form or must move to a different AI ecosystem.
Product metacompetence · Builders and systems · Public edition 0.3.2
A plugin connects an archive to the research assistant’s method
The method explains how to qualify and connect sources; a supported tool reads the archive. Integration connects those contributions without putting credentials in the skill.
The key relationship. Forms the kernel’s plugin incarnation while keeping its methods, tools, installation, use and learning connected.
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 ↗Bring a semantic kernel into an AI plugin
Bringing a capability into a plugin means preserving the knowledge that makes it useful and connecting it to the recipient environment’s actual means.
This resource helps decide what belongs in the method, what needs a tool and how use should change the next incarnation.
Compose instructions, tools and interface
Instructions carry the method, integrations provide data and actions, and the interface supports the user’s decisions.
Correct the cause of the friction
Distinguish discovery, method, source freshness, access and authority before changing the capability.
Preserve knowledge beyond local plugin state
Distinguish package files, local plugin data and the project’s durable source. Check their lifecycle in the recipient and preserve irreplaceable knowledge outside locations that may be removed.
Kernel Plugin Incarnation 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.
Connect a research assistant’s method to an archive tool
The method explains how to qualify and connect sources; a supported tool reads the archive. Integration connects those contributions without putting credentials in the skill. A first case observes data access and method use separately.
Repair a competence’s entry when installation already works
Real work reveals that the installed plugin’s entry does not make the useful situation recognizable. Correct discovery and the pertinent description while preserving the valid method body. Reinstallation or additional tools do not automatically address that cause.
Correct retrieval when an index returns a superseded source
The plugin finds the right document through an index but retrieves an old version. Retrieval must reach the current source or preserve uncertainty about freshness. The case can also change the porting method: retrieval evidence must concern the source actually supporting the result.
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 Kernel Plugin Incarnation
Forms the kernel’s plugin incarnation while keeping its methods, tools, installation, use and learning connected.
Conduct the plugin field from the actual job
A plugin task may concern product purpose, component design, packaging, installation, discovery, authentication, controlled actions, evaluation, distribution, portability or troubleshooting. Let the work select the knowledge needed. Do not run every family as a checklist. Preserve one semantic source with thin receiver-specific incarnations where possible, rather than independently rewriting the product for each host. Consult current official specifications and provider documentation before making format, compatibility, permission or submission claims; keep observation date and uncertainty where they affect the choice.
Put each function in a component that can supply it
A skill carries method, examples and situated decisions. A service/tool layer can supply live data, authentication and controlled actions. UI makes human-visible state and intervention useful when the work benefits. Lifecycle actions require a host that actually executes the corresponding hooks; a file in an archive does not establish runtime execution. A specialist process is optional and requires the host's actual mechanism and the person's selected mandate. Provider-specific constructs belong to that incarnation rather than silently redefining the portable source.
Make a public operation self-contained: bundle or explicitly declare the components required for the intended user goal. A private combination of several installed connectors does not mean another recipient receives those means. Keep durable project knowledge outside an uninstallable package cache; distinguish installed files, disposable local state and the project's continuing record.
Resolve discovery and execution separately
A technically valid package may be uninstalled, disabled, absent from the present session, undiscovered, unauthenticated or unused. Inspect the actual failing relation. The name and description must expose the recognizable goal so the method can be reached. Body knowledge cannot help if discovery never supplies it. A connected tool may still lack the data permission or exact effect mandate needed for the action.
Put enforceable access and data controls at the service boundary. Model instructions guide conduct but do not replace server checks. Distinguish authenticated identity, service authorization, host permissions and the person's mandate. Use least privilege and minimize private data exposed to tools, logs and UI. Inspect executable scripts, hooks, dependencies and untrusted inputs where their behavior changes trust or use. Keep credentials out of source and skill text.
Use cases that distinguish causes
Choose a case capable of exposing the suspected loss: direct or indirect intent, incomplete input, unrelated request, follow-up, unavailable connection or missing permission. These are choices, not a compulsory quota. Observe activation, completeness, unsupported inference, tool use, preserved authority and context/process cost where material. Retain version, conditions, actual result and the responsible owner. Do not repair an authentication failure by changing semantics or a semantic failure by merely renaming the package.
A search result or indexed repository view may be stale. When freshness changes action, recover the exact current owner coordinate and read the smallest decisive source directly. Preserve previous observations with their own scope. For distribution, distinguish a local prototype, shared repository, team installation and public submission. A source push is not installation or public approval. Port user intent, method, source/effect distinctions and useful learning while translating manifests, tools, configuration, UI and runtime mechanisms through the receiving host. Return a local lesson to the product, a provider lesson to its adapter, and a general incarnation lesson to this competence.
Read the complete operating method
Object and destination
Form the relation through which a semantic capability or kernel becomes a usable plugin in an AI environment. Understand the recipient's work and the source capability enabling it. Transfer coherent knowledge and means. Correct files represent capability; use in the recipient shows exercise.
Reach the source method and its reasons. For a concrete format, installation, interface, authentication or compatibility choice, consult the chosen environment's current official documentation. Preserve observation date and scope rather than treating remembered provider behavior as current fact.
Distinguish functions to compose them
Understand what belongs in instructions: contextual interpretation, method, source selection, continuity and learning. Tools may provide current data, service access or material action. Interfaces expose options, state and consequences when they help user choices. These relations guide design while remaining revisable through the case.
Reuse supported tools performing the needed function. Form a connection for an actually absent capability. A connector does not repair a semantic method; rewriting a skill does not configure account access. Keep credentials and account state outside public instructions.
Let recipients understand the means needed for promised work. When a function depends on an external service, make its connection reachable and explain it in use. If an optional capability is missing, continue the valid method using available materials without simulating service data or actions.
Follow capability into use
Distinguish kernel source, plugin version, skill snapshot, linked service and recipient state. Source changes do not automatically update installed plugins. A generated folder does not prove loading, discovery or exercise.
Distinguish plugin-local state, package files and durable project knowledge. Check the host's current lifecycle contract for updates and uninstallation. Keep the only copy of irreplaceable knowledge outside removable storage: plugin working space can have a different lifetime from the project.
Prepare the smallest form enabling complete initial work. Check provider-required format and use a pertinent case to observe the method. A claim of recipient use should identify the version, context and observed result. “I used the skill” alone does not show which contribution changed an answer.
Understand friction
Recover the difference causing interruption: unreadable package, undiscovered skill, incomplete method, obsolete source, missing service or insufficient permission require different corrections.
A research plugin may choose the right source while an index returns an old copy. Editing skill prose does not update that source. Reach the owner's current coordinate when freshness changes the decision; if unavailable, keep uncertainty with the particular affected claim.
Distinguish account authentication, service authorization, host permissions and user mandate for the concrete action. Technical sending capability is not selection of a message. That distinction governs the effect without blocking useful content preparation.
Portability and return to the method
Across hosts, preserve a recognizable semantic source and adapt the mechanisms making it reachable. Matching filenames do not establish functional equivalence. Reactive chats and agentic environments may differ in tools and persistence; describe what the recipient can actually do.
After meaningful use, preserve version identity, decision reasons, result and useful difference. A particular lesson changes the plugin; a packaging error changes packaging; a loss translating capability can change this transfer competence. One event may have several object-specific returns.
This is a meta relation because it forms how capability becomes an operating product. It is autological when plugin work reforms transfer itself. If source selection repeatedly yields stale data, change that criterion and its rationale before another port. Continuing learning is distinct from publishing a release.
Use and continuity in the recipient
Use supplied materials in chat or actual files, tools and guides where available. Ask only for missing context that matters and proceed when a useful result is possible. Preserve reasons, decisive sources, differences and continuation in the project's actual location; otherwise return a reusable note.
Instructions can change the used method without changing model weights or proving stable learning. Distinguish availability, actual use and later behavior. Accounts, tools and authority over concrete effects follow the recipient's real mandate and environment.
Nature and provenance
MAIOS adaptation of Kernel Plugin Incarnation, preserving translation between semantic capability, product and recipient. Provider-specific format and installation follow current official documentation. This kit does not establish particular compatibility or completed installation.
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.
Kernel Plugin Incarnation and improvement of the method
Transfer work can improve how transfer is done
The meta relation concerns the passage from a capability to an operating product. A plugin remains an incarnation in a recipient environment, with its own means and state.
The relation becomes autological when the transfer competence enters its own work: an integration criterion can change through what the recipient reveals.
An updated package, an installation, an exercise and sustained learning are different results. Autopoietic return changes the method of the next incarnation; it does not automatically update accounts.
Competence, meta and autology: the conceptual guide ↗How Kernel Plugin Incarnation learns through work
Retain why the form was chosen and what use actually showed. Each lesson returns to the method or component that must behave differently.
The public instructions remain provider-neutral so concrete integration choices can use current official contracts.
Use Kernel Plugin Incarnation 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 Kernel Plugin Incarnation 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 ↗